?

That's what ->> does, yes

-> is thread first, so it passes each result as the first argument of the next body

->> is thread last, same but as last argument

-> is used for maps/objects, ->> is for sequences

Generally, anyway

Yup, I get it now. Nice way of putting everything under one macro. I guess I need to practice writing more functional code. Any good cheat sheet for the clojure core functions?

Thanks for the help btw.

A cheat sheet? Like this https://clojure.org/api/cheatsheet ?

Haha, it has a good area for transducers. I think that's where I'll go next.

There's a lot there. Have a peak through them, and 90% of the time you ask "surely there's a function for this" there probably is

So feel free to ask in here about "is there a function that does X?" when you come to that point

That's what I kind of like about clojure, there's a function for everything. Meanwhile in JS, I have to conjure some weird JS syntax to do something as simple as cloning a list.

I think I saw someone say there's about 600 functions in clojure.core but I haven't counted them...

Perhaps archive the repo? Or is that too drastic?

@U04V70XH6 Perhaps clj-kondo could lint deps.edn for deprecated libraries :)

doall does that https://clojuredocs.org/clojure.core/doall

Or, into

Also, if you don't care about the return value but just want to perform side effects, doseq accepts the same syntax as a for expression.

idk why, into worked out but not doall

maybe into helped me format the data as well hmmm

I guess a more complete example will make it easier to understand. Laziness can be tricky!

Was sending the data outputted from a for into jdbc but it was having some issues. And I was thinking it might be a result of laziness

doall returns back the same passed lazy seq - while forcing side-effects. into creates a new, realized collection and returns it. Not much insight into the doall implementation, but the source is easy to follow and see what is happening.

Maybe I just needed the data to be in a vector and not a seq

> Was sending the data outputted from a for into jdbc but it was having some issues. And I was thinking it might be a result of laziness this is highly unlikely - if jdbc reads the value, it will be calculated (btw. nitpick there's no "for loop" in clojure, for is a list comprehension not a looping construct)

Can you explain with a small example collection? Are the filter and remove predicates complements of each other?

Yeap complements. So tgt what is filtered and what is filter will return the entire collection

Does group-by work for you? You have to adjust the fn accordingly.

Hmmm that might work o:

I know that this is a late reply, but I wrote https://www.learn-clojurescript.com to help JavaScript developers. Let me know if it's useful!

After you import it, you can use (InternetProtocolStats/getTCPv4Stats)

See https://clojure.org/reference/java_interop#_member_access, it's the 4th one down on that list.

I don't think so: (InternetProtocolStats/getTCPv4Stats) Syntax error (NoSuchFieldException) compiling . at (/tmp/form-init261843597932239110.clj:1:1). getTCPv4Stats

Oh goodness, i've completely misunderstood your question

This is an interface

you'll need to find some class that implements the interface, instantiate that, and call the method on it

there's one for each os listed at the top

WindowsInternetProtocolStats, MacInternetProtocolStats, etc

(.getTCPv4Stats (LinuxInternetProtocolStats.)), or similar

Ok, thanks. I was hoping I wouldn't have to be platform specific like that...

It appears to be a limitation of the library you're using

Thank you all! I was really starting to pull my hair. Not really working with Java much...

What error do you get interacting with the last bit in a long? this works fine in my repl:

(let [show-bits
      (fn [x]
        (dotimes [bit 64]
          (print (if (bit-test x (- 63 bit)) "1" "0")))
        (println))
      x (bit-or (bit-shift-left 1 63)
                (bit-shift-left 1 25)
                (bit-shift-left 1 4))]
  (show-bits x)
  (show-bits (bit-set x 50))
  (show-bits (bit-clear x 63))
  (println (bit-test x 63))
  (println (bit-test x 25))
  (println (bit-test x 4))
  (println (bit-test x 0)))
1000000000000000000000000000000000000010000000000000000000010000
1000000000000100000000000000000000000010000000000000000000010000
0000000000000000000000000000000000000010000000000000000000010000
true
true
true
false

yeah, you can do bitwise ops on all 64 bits of a long, if you are treating it as a series of 64 bits the question of sign shouldn't come up at all

Thank you all for your kind answers. It seems to work now using only longs 🙂 - I describe the solution in greater detail here - https://clojurians.slack.com/archives/C053AK3F9/p1627332915264100?thread_ts=1627322982.252400&cid=C053AK3F9

Ah i see, didn' realise they had their own functions. Thanks. I had hoped to use longs, but i guess if that is not possible, biginteger are the best bet

some of these seems to point to unfamiliarity with working with bit operations, like https://github.com/mdallastella/vinnik/blob/master/src/vinnik/bitboard.clj#L13-L16 uses raising 2 to the 64 power to create a board of all 1s instead of a bitewise not operation

depends, if you stick with biginteger (dec (.shiftLeft (biginteger 1) 64)) should be sufficient

(bit-or (bit-shift-left (bit-not (bit-shift-left 1 63)) 1) 1) or similar if you want to stick with longs

it replaces the power call with the shift

2^64 <=> 1 << 64

-1 being the 64 bit long that gives you 64 1 bits

user=> (Long/toBinaryString -1)
"1111111111111111111111111111111111111111111111111111111111111111"
user=> (count (Long/toBinaryString -1))
64
user=>

sure, I mean, if you want do absolutely nothing

I use this site to calculate the bitboard positions and what i am expecting - https://gekomad.github.io/Cinnamon/BitboardCalculator/

So in case of 64th bit i would expect the bitboard representing the kings position to be 9223372036854775808 - Then the possible moves would be the 3 bits sorounding it - 4665729213955833856 - However what i return is -18014398509481984

I haven't fully parsed out what's going on here, but a minor style note, most of those usages of unchecked-long do nothing - it's a function that coerces a runtime value to long even if it's outside range, it isn't a constructor for some special "unchecked" version of a long as a unique type, so using it on literals that are clearly small enough to fit in a Long is strange.

The idea is basically. To calculate the moves of the king, i can move in 8 different directions. BIt shifting in any of these will return a long with a bit set in that position i can move the king. If i union these i get all king moves. The "not-A-file" is for when the king is on the very left file or the very right file. In this case i don't, want to calculate the left or right shifts, since they will set a bit on wrong rank.

4665729213955833856, the number you say represents the 8 positions around the king, but that number only has 3 bits set

so maybe that is not right?

you may need to be using unsigned-bit-shift-right

user=> (bit-shift-right -1 1)
-1
user=> (unsigned-bit-shift-right -1 1)
9223372036854775807
user=> (Long/toBinaryString (bit-shift-right -1 1))
"1111111111111111111111111111111111111111111111111111111111111111"
user=> (Long/toBinaryString (unsigned-bit-shift-right -1 1))
"111111111111111111111111111111111111111111111111111111111111111"
user=>

(the second one is only 63 digits because a leading 0 is trimmed off)

Switching to ((unsigned-bit-shift-right) fixed it!! Thank you so much - Also the 64'th position will be the very corner of the chessboard, if the king is here, he only has 3 possible moves. Therefore only 3 set bits 🙂