i give up, what value would make this true. i thought the answer was nil, but its not considered true so it fails.

(let [x __]
  (and (= (class x) x) x))

@drewverlee imagine if you took an iterator, and took a class of a thing, and found the class of the class of the thing, etc.

what would be the fixed point where it just repeats?

does it have to return true?

or just a truthy value?

well, if it has to return true it's unsolvable

I think I recognize it as a koan

unsolvable, because x would have to be true

which it isn't

if the and wasn't there, nil would work

right

well, class of true isn't true

it's Boolean

how to release code to Clojars if I don't use Boot or Lein? I mean no JVM..

After migrating to shadow-cljs I found my build.boot already unnecessary except for releasing package.

@ghadi thanks, but I don't see how this ties to relying on one map initialization key while initializing another

I was thinking more along the lines of writing a macro, unless some pattern helps with that specific concern

Here's one failed shot at such a macro by the way:

@drewverlee

(if (let [x java.lang.Class] (and (= (class x) x) x)) "hello" "goodbye")

crowd groans

Hi all! I'm developing a mobile app with re-natal. I need to draw a curved line chart, (and maybe animate it). what is the best API to do it? I saw d3 and ART, but d3 is most for the web.. I alsodiscovered Victory https://formidable.com/open-source/victory/docs/native and React-native-Chart https://github.com/tomauty/react-native-chart. What do you think? thanks 🙂

@gmercer Thanks. I tried class and i thought i tried java.lang.Class to, i must have done something else though.

@noisesmith thanks for the hint :0

Hello dear channel!

I'd like to ask a question on ztellman's wonderful manifold: I have trouble to bring manifold deferreds and streams together to perform HTTP requests ins parallel.

Hey everyone, I'm trying to understand how lazy evaluation works in Clojure. One thing I've noticed from playing around with the repl is the way in which lazy lists work, for example in Haskell take 10000 $ repeat "foo" will pass the unevaluated values to take and it would be the take function which evaluates the list as it requires. However, (take 10000 (repeat "foo")) requires an initial startup time where repeat is initially lazy but then appears to be evaluated hastily evaluated by take. My thinking on that is that either: 1. Take evaluates the tail first which means (take x (...)) must evaluate to x before returning 2. Repeat does not pass the lazy list to take but instead returns a list of length x 3. This is something to do with the repl and ghci evaluates expressions lazily whilst the clojure repl doesn't

@alexsays There is no lazy evaluation in Clojure.

> Repeat does not pass the lazy list to take but instead returns a list of length x I'm not sure I understand. (repeat "foo") knows how many (`x`) elements take wants before take is evaluated?

Only lazily realized lists. evaluation in clojure is always strict/eager, unlike haskell

(seq (range 0 10))

^ that immediately gives you an object (a seq/list) that happens to have a lazy tail

The REPL in haskell confuses things a bit because you have evaluate stuff to print it meaninfully, right?

Ah ok, so http://www.braveclojure.com/core-functions-in-depth/#Infinite_Sequences_ is more just talking about the nature of lists rather than anything specific to clojure?

But the easiest way to think about it is: laziness in clojure specifically refers to lazy sequences

@alexsays what in that chapter contradicts what ghadi has said?

it's talking about lazy sequences

> However, Clojure comes with a few functions to create infinite sequences.

@alexsays repeat doesn’t realize anything, and take only parameterizes how many items will be returned, it’s the printing that realizes if anything (in a repl context at least)

Don't think any of it directly contradicts. It could be that I'm coming at from the concept of everything being lazy > A lazy seq is a seq whose members aren’t computed until you try to access them To me that indicates that for a list of xs, x won't be evaluated until that element is accessed.

@alexsays there’s a crucial bug in nrepl here - nrepl isn’t lazy, and if you call (take 1000 x) all 1000 elements are realized before any are printed

this is an nrepl bug, in a real direct clojure repl the items print as they are realized

> To me that indicates that for a list of xs, x won’t be evaluated until that element is accessed. remember that printing accesses the items

the chapter has a good book of exactly that: (repeatedly (fn [] (rand-int 10))) that function is not computed until the element is accessed

to be clear -- the call to repeatedly is made

the data structure that repeatedly returns might not be fully realized

that is the major difference between clojure and haskell (I think).

strict (clojure) non-strict (haskell)

@ghadi the ghc repl is just a monad at its most basic level that's passed a stream of expressions that it lazily evaluates.

ah super clear

we have exactly one lazy type: clojure.lang.LazySeq - we don’t have lazy evaluation

^^ what noisesmith said

"Clojure has a helpful function that can build concrete datastructures lazily."

So it's not really any strangeness is execution order but more to do with the fact that there's only a small number of data structures which are lazy

exactly

high five everybody

Is it worth tending to not think about the lazy structures - and assume that when the time comes to use them I'll know - or are they considered an important part of the language?

Thinking of my experience with scala where LazySeq is only really used in a few edge cases

the lazy structures are pretty ubiquitous: map, filter, remove, take, drop, concat

(for just a few very common examples)

though now most of them have non-lazy transducer variations too

> So it's not really any strangeness is execution order but more to do with the fact that there's only a small number of data structures which are lazy there was confusion about this just a second ago

(let [will-throw (try (map risky-function collection) (catch Throwable nil))]
   (reduce rfunc [] will-throw)

I've read a little bit on from that chapter and played around a bit. Think I've got my head around it; thanks for the help guys

👍