scalaz

I have heard that iteratees are lazy, but how lazy exactly are they? Alternatively, can iteratees be fused with a postprocessing function, so that an intermediate data structure does not have to be built? Can I in my iteratee for example build a 1 million item Stream[Option[String]] from a java.io.BufferedReader , and then subsequently filter out the None s, in a compositional way, without requiring the entire Stream to be held in memory? And at the same time guarantee that I don't blow the stack? Or something like that - it doesn't have to use a Stream . I'm currently using Scalaz 6 but if

I am learning Scalaz and I have a project that already makes use of Scalaz7. Following this question I would like to use the function sequence[T](l: List[Option[T]]): Option[List[T]] (not that it is hard to write it myself). But the aforementioned question mentions Scalaz6. Where to find the sequence function in Scalaz7? It's defined in the scalaz.Traverse type class, where it looks like this: def sequence[G[_]:Applicative,A](fga: F[G[A]]): G[F[A]] = traversal[G].run[G[A], A](fga)(ga => ga) scalaz.syntax.TraverseOps provides a version that gets pimped onto List , since List has a Traverse

If I have: import scala.concurrent._ import scalaz._, Scalaz._ type Z = List[String] type F[α] = Future[α] type WT[α] = WriterT[F, Z, α] implicit val z: Monoid[Z] = new Monoid[Z] { def zero = Nil def append (f1: Z, f2: => Z) = f1 ::: f2 } implicit val f: Monad[F] = scalaz.std.scalaFuture.futureInstance I can write code like this: def fooA (): WT[Int] = WriterT.put[F, Z, Int] (f.point (18))(z.zero) def fooB (): WT[Int] = WriterT.put[F, Z, Int] (f.point (42))(z.zero) def fooLog (msg: String): WT[Unit] = WriterT.put[F, Z, Unit] (f.point (()))(msg :: Nil)) def foo (): WT[Int] = for { _: Unit <-

In Eric Torreborre's blogpost on the paper Essence of the Iterator Pattern , he describes how the cartesian product of a traverse is also a traverse. Can anyone show me an example of this using the scalaz library as I can't figure it out. Let's say the problem is that, for a List[Int] I want to provide both of: The Int sum of the elements in the list A List[String] the elements of which are created by appending the "Z" to the String representation of the Int s My understanding is that I can do this using traverse but in such a way as to only actually traverse my structure once, unlike this

Can somebody give an example how to use ScalaZ Free monad ? For example, if I have a simple State function and want to apply it 10,000 times, I'd get StackOverflowError: def setS(i: Int) :State[List[Int], Unit] = State { l => ( i::l, () ) } val state = (1 to 10000).foldLeft( put(Nil :List[Int]) ) { case (st, i) => st.flatMap(_ => setS(i)) } state(Nil) As I understand, Free monad can help avoid this. How would I re-write this piece of code using Free monad to not cause stack overflow ? Travis Brown As I say in a comment above, lifting the State computations into StateT[Free.Trampoline, S, A]

I started out with something like this: def nonEmpty[A] = (msg: String) => (a: Option[A]) => a.toSuccess(msg) val postal: Option[String] = request.param("postal") val country: Option[String] = request.param("country") val params = (postal |> nonEmpty[String]("no postal" )).toValidationNel |@| (country |> nonEmpty[String]("no country")).toValidationNel params { (postal, country) => ... } Now I thought it would be nice to reduce the boilerplate for better readability and for not having to explain to more junior team members what .toValidateNel and |@| mean. The first thought was List but then