@LukaJCB Yeah that's my go-to right now since it iterates only once. I know I probably don't have to worry about it RE: turning it into a
List first, but it just gives me the heebie jeebies to think about even the possibility of it being more inefficient than it needs to (even if it'll likely get JITted, my brain doesn't fully internalize that)
Can someone give me an intuition of what
.compile does for a stream? It seems like in code examples we see things like s.compile.drain or s.compile.last or something; when I see a method name like .compile I think that it may be optimizing the stream somehow (by inspecting the object graph) - but if that were the case, it sort of seems like drain or last would need to come before compile in that chain, and compile would turn the Stream[F, O] into an F[O] or something.
The namespacing technique works better for auto-complete than a naming convention based technique (e.g. suffixing or prefixing all Stream to F methods with some common string)
let me know if you're interested in knowing more
basically in FP there is this technique of design through algebras (I'm talking here in the most general sense, even more general than tagless final)
and it basically works like this
you have a type (say
Option), some introduction forms (ways of getting "into" the algebra, for example Option.empty, and .some), some combinators (building building programs in your algebra from smaller programs, like Option.map, Option.flatMap, Option.getOrElse etc) , and potentially some laws (eg. anyOption.flatMap(Option.empty) == Option.empty)
makes sense so far?
but the question is
what does it mean to "run" programs in Option?
do you have an idea there?
"running" an algebraic programs amount to transforming the carrier type (
Option), into a different type (say B)
the shape of this transformation depends on the shape of the language, and in the case of
Option is basically getOrElse (sometimes such a thing is also called fold)
the trasformation functions is called an eliminator, in the context of an algebra
so to recap, in an algebra
- you have a type
- you have introduction forms, that take types and convert to the algebra type
- you have combinators, which are the meat of it, and allow you to build programs compositionally
- you have laws, potentially
- you have elimination forms, which transform the algebra type to another type, and correspond to our notion of "running"
now, this pattern is very very general, and appears in many forms, and can be also abstracted over in many forms (like tagless final)
unsurprisingly,
Stream also follows this pattern
Stream is the type
emit, eval and co. are the introduction forms (take types that aren't stream, and convert them to stream)
then you have the myriad of combinators, like
++ flatMap, concurrently etc
and finally the elimination forms
for an effectful Stream, the elimination form is a transformation from Stream to IO
the name
compile is meant to evoke this translation process
in which the Stream language gets compiled down to the IO language
the most general way is
compile.fold, from which many others can be derived, compile.drain, compile.toVector, compile.foldMonoid etc
we have used
compile as a namespace, but I hope the name itself makes a bit more sense now
it used to be called
run in previous versions, but I find compile more evocative
does that make any sense?
IO is a very special form of algebra
so,
delay cannot be simply seen as taking an A and transforming it into IO