Unsequence Monad function within Haskell

by

You can’t have an unsequence :: (Monad m) => m [a] -> [m a]. The problem lies with lists: you can’t be sure how may elements you are going to get with a list, and that complicates any reasonable definition of unsequence.

Interestingly, if you were absolutely, 100% sure that the list inside the monad is infinite, you could write something like:

unsequenceInfinite :: (Monad m) => m [a] -> [m a]
unsequenceInfinite x = fmap head x : unsequenceInfinite (fmap tail x)

And it would work!

Also imagine that we have a Pair functor lying around. We can write unsequencePair as

unsequencePair :: (Monad m) => m (Pair a) -> Pair (m a)
unsequencePair x = Pair (fmap firstPairElement x) (fmap secondPairElement x)

In general, it turns out you can only define unsequence for functors with the property that you can always “zip” together two values without losing information. Infinite lists (in Haskell, one possible type for them is Cofree Identity) are an example. The Pair functor is another. But not conventional lists, or functors like Maybe or Either.

In the distributive package, there is a typeclass called Distributive that encapsulates this property. Your unsequence is called distribute there.

More Related Contents:

  1. Using return vs. not using return in the list monad
  2. Haskell Monad – How does Monad on list work?
  3. Haskell finding mean of cubes of odd members Any ideas? [closed]
  4. Histogram in Haskell [closed]
  5. What is Haskell’s Stream Fusion
  6. Cartesian product of infinite lists in Haskell
  7. Decrementing ranges in Haskell
  8. Zip with default value instead of dropping values?
  9. Replace individual list elements in Haskell?
  10. Using Haskell’s map function to calculate the sum of a list
  11. Need to partition a list into lists based on breaks in ascending order of elements (Haskell)
  12. Merging two lists in Haskell
  13. Is there a function to flatten a nested list of elements?
  14. Understanding a recursively defined list (fibs in terms of zipWith)
  15. Removing duplicates from a list in Haskell without elem
  16. Removing syntactic sugar: List comprehension in Haskell
  17. Counting unique elements in a list
  18. Recursive Prolog predicate for reverse / palindrome
  19. Grouping a list into lists of n elements in Haskell
  20. Why are difference lists more efficient than regular concatenation in Haskell?
  21. Prolog: Filtering a list?
  22. How to generate all the permutations of elements in a list one at a time in Lisp?
  23. Scala list concatenation, ::: vs ++
  24. Segregating Lists in Prolog
  25. What are free monads?
  26. Python: find a list within members of another list(in order)
  27. How to handle side effect with Applicative?
  28. How to convert a java.util.List to a Scala list
  29. How to add variable key/value pair to list object?
  30. Prolog, find minimum in a list

Leave a Comment