category-theory

While reading the description of Functors on this blog: https://hseeberger.wordpress.com/2010/11/25/introduction-to-category-theory-in-scala/ there is a generic definition of Functor and a more specific one: trait GenericFunctor[->>[_, _], ->>>[_, _], F[_]] { def fmap[A, B](f: A ->> B): F[A] ->>> F[B] } trait Functor[F[_]] extends GenericFunctor[Function, Function, F] { final def fmap[A, B](as: F[A])(f: A => B): F[B] = fmap(f)(as) } Clearly this means Functors can be used with other higher-kinded types besides Function objects. Could someone please give an example or explain how or why or in

As far as I understand, recursive data types from Haskell correspond to initial algebras of endofunctors from the Hask category [ 1 , 2 ]. For example: Natural numbers, data Nat = Zero | Succ Nat , correspond to the initial algebra of the endofunctor F(-) = 1 + (-) . Lists, data List a = Nil | Cons a (List a) , correspond to the initial algebra of the endofunctor F(A, -) = 1 + A × (-) . However, it's not clear to me what the endofunctor corresponding to the rose trees should be: data Rose a = Node a (List (Rose a)) What confuses me is that there are two recursions: one for the rose tree and

There is a nice Free Alternative in the great free package, which lifts a Functor to a left-distributive Alternative. That is, the claim is that: runAlt :: Alternative g => (forall x. f x -> g x) -> Alt f a -> g a is an Alternative homomorphism , with liftAlt . And, indeed, it is one, but only for left-distributive Alternative instances. Of course, in reality, very few Alternative instances are actually left-distributive. Most of the alternative instances that actually matter (parsers, MaybeT f for most Monad f, etc.) are not left-distributive. This fact can be shown by an example where runAlt

In the `` Kan Extensions for Program Optimisation '' by Ralf Hinze there is the definition of List type based on right Kan extension of the forgetful functor from the category of monoids along itself (section 7.4). The paper gives Haskell implementation as follows: newtype List a = Abstr { apply :: forall z . (Monoid z) => (a -> z) -> z } I was able to define usual nil and cons constructors: nil :: List a nil = Abstr (\f -> mempty) cons :: a -> List a -> List a cons x (Abstr app) = Abstr (\f -> mappend (f x) (app f)) With the following instance of Monoid class for Maybe functor, I managed to

In order to prove that for instance the Category laws hold for some operations on a data type, how do one decide how to define equality? Considering the following type for representing boolean expressions: data Exp = ETrue | EFalse | EAnd Exp Exp deriving (Eq) Is it feasible trying to prove that Exp forms a Category with identity ETrue and operator: (<&>) = EAnd without redefining the Eq instance? Using the default instance of Eq the left-identity law breaks, i.e: ETrue <&> e == e evaluates to False . However, defining an eval function : eval ETrue = True eval EFalse = False eval (EAnd e1 e2)

In Adjoint functors determine monad transformers, but where's lift? , Simon C has shown us the construction... newtype Three u f m a = Three { getThree :: u (m (f a)) } ... which, as the answers there discuss, can be given an instance Adjunction f u => MonadTrans (Three u f) ( adjunctions provides it as AdjointT ). Any Hask/Hask adjunction thus leads to a monad transformer; in particular, StateT s arises in this manner from the currying adjunction between (,) s and (->) s . My follow-up question is: does this construction generalise to other monad transformers? Is there a way to derive, say,