Most discussion is on Typelevel Discord: https://discord.gg/bSQBZA3Ced
hm, that reminds me of this conversation the other day: https://gitter.im/functional-streams-for-scala/fs2?at=5e849fd48bb4966bc49bf03b
Hi all. New to fs2 and having a question. Why fs2.Stream does not implement
Traverse like other Collection classes? Say I have the same situation in https://stackoverflow.com/questions/53806418/chaining-a-number-of-transitions-with-the-state-monad
But the question is, fs2.Stream has no
traverse, so the answer does not work in my situation
You'll notice that most effect types lack such an instance, any
IO monad can't because it represents a non-referentially transparent computation
Stream has /analogous/ operations to traverse, like
evalMap and others, but the "leave stream" part needs to go through the .compile step
It's possible that
Stream for F=Pure could have such an instance
but any general
F couldn't
btw with Stream you can have stateful computations that don't require the use of
StateT, but there is nothing wrong with doing what you're doing at first, so definitely keep exploring :)
genuine question
@Daenyth in fairness, the same can be said of
compile.list :P
but it's at least used in a monomorphic context
the traverse instance means that code could be calling traverse not knowing F=Stream and assuming finite-ness
and it kind of depends on your philosophical stance whether returning
Nothing for a method impl satisfies the contract or not
Well just like this piece of code, https://scastie.scala-lang.org/Nuz2i83yTnWs0IPtOUhPBg, I just have no idea what the
evalMap is... Any advice?
takes an element, wraps it in
F[_], then evaluates the F to get the element back
All your StateT are using
pure so it might be easier to skip the T and just use State
if you just have three stateT computations, you can
Stream.eval(first) ++ Stream.eval(second) ++ Stream.eval(third) but then why are you using Stream? Could just have first >> second >> third
in the code you have, you could make it work with
evalMap(identity) btw (rather than pure)
if you want a slightly more meaningful example
try writing a
Int => StateT that takes an Int and inc/decr by that int
then you can do
Stream(1, -1, 2, 1, -1).evalMap(yourFunction) and see
or, in case you want to follow the example in stack overflow,
List.fill(5)(yourStateT).sequence becomes Stream.repeatEval(yourStateT).take(5)
(or equivalently
Stream.eval(yourStateT).repeat.take(5)
The only solution I can figure out is like https://scastie.scala-lang.org/6eIjulhSRfqJRotHerKNaA
Which should do
runS over and over again
to re-use or steal