if you have something like (into [] a-transducer (range n)) - does the range sequence gets created and cached here?

there is no seq

range returns a thing that both implements Iterable and IReduce, both of which have custom fast paths when processed via reduce, which into does

gotcha thanks, was just learning about reducible collections

looking at the source, in these case is using transduce instead of reduce but yeah, same concept

and range doesn’t actually cache anything

@alexmiller if you do (map foo (range n)) - the values of range don't get stored in memory?

that’s not the code you have above

and what happens is much different

oh ok, though you were saying it in general

when using a range as a reducible (as with into), the whole thing just boils down to a single loop over the data and no values are cached in memory

even when used as a seq, it builds chunks that store only the start/step/count values, not the actual data values

neat, so something not to worry about to much

what makes a collection reducible? what are properties must it satisfy?

implements IReduce

and has a reduce method

for a long-only range for example: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/LongRange.java#L229-L238

the into example above is primarily running this loop

where f is the transducer

and val is []

this is not the only path to being reducible, but it’s the fastest

you can also participate in the CollReduce protocol

for building non-caching reducible things on the fly, there's also eduction

so basically it needs to know how to perform a reduce on itself

yes

vectors and maps also know how to do this

in the case of long range

and the results of cycle, iterate, repeat

is there a predicate for reducibles?

(doc reducible?) returned nil 😉

no, not currently

ok

you can use instance? though

#(or (instance? clojure.lang.IReduceInit %) (satisfies? clojure.core.protocols/CollReduce %))

@alexmiller that reminds me, has there ever been any consideration of a for variant for producing a similar reducible/iterable? I remember poking around a while back thinking there'd be one. I figure it just doesn't come up enough as an optimization to be necessary, particularly since you can usually achieve the same thing with eduction, iterate, etc, but while we're talking about it....

just curious!

does the sequence fn just does the opposite of a transduce?

not sure what that would mean, but no :)

heh, let me reread this

the sequence function, when used with a transducer makes an incrementally computed sequence

mostly it's just there so you can generate a lazy-sequence by composing transducer functions (map, filter, take, etc) without having to use them as lazy sequence functions - saves the overhead of the intermediate sequences

there are some differences from lazy sequences as each intermediate step is fully computed

transducers are a push model, not a pull model

so for example, lazy sequences can compute infinite intermediate sequences and you can use as much of that as you like

but sequence with a transducer would work forever producing the intermediate step

most commonly this comes up with mapcat

oh, yeah, ike if you had a filter that's never satisfied it would run forever trying to get to a value that satisfies the filter even if you only try and get a single item from it

yeah

well, that may be true of both

hahaha yeah I realized that after I said it, whoops

like (take 2 (mapcat #(repeat 1000 %) (range 5))) only needs to produce 2 values

actually, that explains why the core transducer functions don't just do, like, ([pred col] (sequence (filter pred) col)) for the lazy-seq-producing form, instead using lazy-seq directly

but (into [] (comp (mapcat #(repeat 1000 %)) (take 2)) (range 5)) will produce 1000 values and give you 2

which I always do when I write my own because I am a lazy fool

both seqs and transducers have their place

https://clojure.org/guides/faq#transducers_vs_seqs

oh sure. I just mean, when I write my own custom transforms, I like to follow teh same pattern as core and make them work either as transducers or sequence functions based on arity. but I usually just take the shortcut of using sequence. this conversation has me reconsidering that, though

yeah, I wouldn’t do that

they really are different

yeah, I see why it's a bad idea now that you point out the effects of the push behavior. thanks

there's likely also more overhead for the same result

@alexmiller your into and concat example was to demonstrate what the sequence fn does with a transducer? that it fully computes intermediate values

or as you better said, each intermediate step is fully computed

finding a use case for sequence, is like when you want a lazy result of intermediate steps

that use case is imo small

yeah, I guess is not used much in practice, or at least can think of any right now.

Has anyone here successfully deployed a “create-react-app” app with ring? I’m having trouble to work with registerServiceWorker.js, it says on the console log:

No internet connection found. App is running in offline mode.

I’m using ring.middleware.resource/wrap-resource and it works

Is https://www.reddit.com/r/Clojure/comments/z0o6u/robbit_reddit_apibots_in_clojure/ state of the art for getting started with "write a reddit bot in clojure" ?

the github link doesn't work, and the author doesn't seem to appear either

Well, adding https://github.com/ThatGuyHughesy/creddit to https://github.com/yetibot/yetibot is on the list.

Hi. I'm trying to write a test with cljs.test. I want to have all the names from my main module right available in the test module. Without prefixes or explicit enumeration. Can I do that?

You mean without requiring them?

Basically (:use [app.main :only [multiply]]) works while (:use [app.main]). While the docs say that both are correct.

@orend Any way that works.

(:require [app.main :refer :all])

I believe :use is discouraged these days.

Still doesn't compile Only :as, :refer and :rename options supported in :require / :require-macros;

Wrong message, real one > Don't know how to create ISeq from: clojure.lang.Keyword

Can you paste your entire ns form?

did clojurescript drop support for :all? am i misremembering that?

This might also be useful: https://gist.github.com/ghoseb/287710/

Oh, is this ClojureScript?

drop or possibly never support?

cljs.test was mentioned

yep. Does it handle ns differently?

Ah, yes. :all is not available in ClojureScript.

No idea why though.

Wow. Didn't expect incompatibility on this level. Thanks!

http://cljs.github.io/api/cljs.core/#ns

It most likely is an issue with bundle size — but you could ask on #clojurescript for details.

https://groups.google.com/d/msg/clojurescript/SzYK08Oduxo/MxLUjg50gQwJ

As a “workaround”, you could do (:require [app.main :as a]) and use a/foo, a/bar. It’s an extra two characters on every occurrence, so just a little bit more onerous than the naked case.

I agree though that sometimes for tests it’s nice to be able to just bring everything in.

@masta please consider unpinning your message.

How do you guys do Profile Clojure projects? I have tried JVisualVM bur it gives me some cryptic info. Please advice.

Can you share some more info? What’s the cryptic info look like, what are you trying to measure?

https://imgur.com/a/sPlHqKl This is what I mean. Nothing resembles my actual code.

Are you using code from the namespaces importer.integrity and clj_xml_validation?

Meaning, is your code in those two namespaces?

yes

I’m not an expert on this, nor do I know if there’s a better way to do profiling on Clojure, but with a little effort this output is readable: clj_xml_validation.core$validator_from_schemas.invokeStatic is equivalent to a call to function (clj-xml-validation.core/validator-from-schemas ...)

importer.integrity$differing_contexts_for_global_ids$iter_4304__4308$fn__4309$fn__4314.invoke is a little bit trickier, as it probably involves some anonumous function inside importer.integrity/differing-contexts-for-global-ids.

The top one, clojure.lang.Util.equiv is the = function, IIUC.

thanks I will have a closer look!

Do you know any other tools?

The hot spots can be confusing because you're not seeing a tree of method calls. Look in the Threads tab or Thread CPU time (can't remember if both of them have the method call tree).

Another issue which I have run into with profiling in Clojure is that laziness can give you misleading results. i.e. If I construct a large lazy sequence in an inefficient manner, then I will not see the CPU spike at construction time (where the problem is), but whenever the list is actually evaluated and used

Hi guys, ever since I've upgraded from AWS Java SDK V1 to V2, I've been getting about 80 lines of warnings about version ranges. From reading [1] I understand that this issue is not going to be resolved soon, but is there anything I can do to suppress these messages for just these dependencies? [1] https://github.com/technomancy/leiningen/issues/2251