category-theory

Is there a list of them with examples accessible to a person without extensive category theory knowledge? Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire(PDF) should help as well. The notation will get a bit hairy, but reading it a few times you should be able to knock down that list of yours. Also, take a look at the recursion schemes (archived) blog post , the blogger plans on presenting each individually soon, so check back to it regularly --I guess. Edward Kmett recently posted a Field Guide to recursion schemes , perhaps it helps? Start with learning about

Scalaz provides a method named fold for various ADTs such as Boolean , Option[_] , Validation[_, _] , Either[_, _] etc. This method basically takes functions corresponding to all possible cases for that given ADT. In other words, a pattern match shown below: x match { case Case1(a, b, c) => f(a, b, c) case Case2(a, b) => g(a, b) . . case CaseN => z } is equivalent to: x.fold(f, g, ..., z) Some examples: scala> (9 == 8).fold("foo", "bar") res0: java.lang.String = bar scala> 5.some.fold(2 *, 2) res1: Int = 10 scala> 5.left[String].fold(2 +, "[" +) res2: Any = 7 scala> 5.fail[String].fold(2 +, "[

I have defined an F-Algebra , as per Bartosz Milewski's articles ( one , two ): (This is not to say my code is an exact embodiment of Bartosz's ideas, it's merely my limited understanding of them, and any faults are mine alone.) module Algebra where data Expr a = Branch [a] | Leaf Int instance Functor Expr where fmap f (Branch xs) = Branch (fmap f xs) fmap _ (Leaf i ) = Leaf i newtype Fix a = Fix { unFix :: a (Fix a) } branch = Fix . Branch leaf = Fix . Leaf -- | This is an example algebra. evalSum (Branch xs) = sum xs evalSum (Leaf i ) = i cata f = f . fmap (cata f) . unFix I can now do

This question already has an answer here: Why Functor class has no return function? 4 answers Reading this Wikibook about Haskell and Category Theory basics , I learn about Functors: A functor is essentially a transformation between categories, so given categories C and D, a functor F : C -> D maps any object A in C to F(A), in D. maps morphisms f : A -> B in C to F(f) : F(A) -> F(B) in D. ... which sounds all nice. Later an example is provided: Let's have a sample instance, too: instance Functor Maybe where fmap f (Just x) = Just (f x) fmap _ Nothing = Nothing Here's the key part: the type

Apparently, every Arrow is a Strong profunctor. Indeed ^>> and >>^ correspond to lmap and rmap . And first' and second' are just the same as first and second . Similarly every ArrowChoice is also Choice . What profunctors lack compared to arrows is the ability to compose them. If we add composition, will we get an arrow? In other words, if a (strong) profunctor is also a category , is it already an arrow? If not, what's missing? What profunctors lack compared to arrows is the ability to compose them. If we add composition, will we get an arrow? MONOIDS This is exactly the question tackled in

Consider the following signature of foldMap foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m This is very similar to "bind", just with the arguments swapped: (>>=) :: Monad m => m a -> (a -> m b) -> m b It seems to me that there therefore must be some sort of relationship between Foldable , Monoid and Monad , but I can't find it in the superclasses. Presumably I can transform one or two of these into the other but I'm not sure how. Could that relationship be detailed? ThreeFx Monoid and Monad Wow, this is actually one of the rare times we can use the quote: A monad is just a monoid in

I know what a monad is. I think I have correctly wrapped my mind around what a comonad is. (Or rather, what one is seems simple enough; the tricky part is comprehending what's useful about this...) My question is: Can something be a monad and a comonad? I foresee two possible answers: Yes, this is common and widely useful. No, they do such different jobs that there would be no reason to want something to be both. So, which is it? Philip JF Yes. Turning some comments into an answer: newtype Identity a = Identity {runIdenity :: a} deriving Functor instance Monad Identity where return = Identity