The collections library does backflips to accommodate subtyping: when you use map on a specific collection type (list, map, etc.), you’ll (usually) get the same type back. It manages this through the use of an extremely complex inheritance hierarchy together with type classes like CanBuildFrom. It gets the job done (at least arguably), but the … Read more
This is probably not the answer you’re looking, but I just noticed Validation has the following methods /** Run a disjunction function and back to validation again. Alias for `@\/` */ def disjunctioned[EE, AA](k: (E \/ A) => (EE \/ AA)): Validation[EE, AA] = k(disjunction).validation /** Run a disjunction function and back to validation again. … Read more
As discussed in the Scalaz group, the problem seems to be that ap would accumulate errors whereas (pseudo-)monadic composition would only operate on the value part of Validation. Therefore, one cannot be expressed in terms of the other and thus no monad instance exists for Validation.
I assume, scalaz 7.0.x and the following imports (look at answer history for scalaz 6.x): import scalaz._ import Scalaz._ The state type is defined as State[S, A] where S is type of the state and A is the type of the value being decorated. The basic syntax to create a state value makes use of … Read more
I eventually solved this using an ambiguity-based solution that doesn’t require prioritizing using inheritance. Here is my attempt at generalizing this. We use the type Not[A] to construct negative type classes: import scala.language.higherKinds trait Not[A] trait Monoid[_] // or import scalaz._, Scalaz._ type NotMonoid[A] = Not[Monoid[A]] trait Functor[_[_]] // or import scalaz._, Scalaz._ type NotFunctor[M[_]] … Read more
In Practice No, it can not be done, at least not in a meaningful way. Consider this Haskell code action :: Int -> IO String action n = print n >> getLine This takes n first, prints it (IO performed here), then reads a line from the user. Assume we had an hypothetical transform :: … Read more
Fairly straightforward Scalaz solution (not very general) You can use a semigroup instance to wrap up a lot of the details: import scalaz._, Scalaz._ case class Foo(a: Option[String], b: Option[String], c: Option[String]) implicit object fooSemigroup extends Semigroup[Foo] { def fromFoo(f: Foo) = (f.a.fst, f.b.fst, f.c.fst) def toFoo(t: (FirstOption[String], FirstOption[String], FirstOption[String])) = Foo(t._1.value, t._2.value, t._3.value) def … Read more
Having two monads is both not enough (for M) and more than enough (for N)—which adds up to not enough, of course—but if M has a Traverse instance and N has an Applicative instance, you can use sequence. For example: import scalaz._, Scalaz._ def foo[A](xs: List[Option[A]]): Option[List[A]] = xs.sequence This has the semantics you want. … Read more