category-theory

Hask is usually thought to be the category whose objects are types and morphisms are functions. However, I've seen Conor McBride (@pigworker) warn against the use of Hask multiple times ( 1 , 2 , 3 ): I would discourage talk of "the Hask Category" because it subconsciously conditions you against looking for other categorical structure in Haskell programming. Note, I dislike the use of "Hask" as the name of the "category of Haskell types and functions": I fear that labelling one category as the Haskell category has the unfortunate side-effect of blinding us to the wealth of other categorical

In Haskell, we use the term "section" to indicate a partially applied function used in infix position. For instance, for a function foo :: a -> b -> c and values x :: a and y :: b , we have the two sections s1 = (x `foo`) :: b -> c == \b -> foo x b and s2 = (`foo` y) :: a -> c == \a -> foo a y In category theory, however, a section g of f is defined as a right inverse of f (so that f . g == id ). I don't see an obvious connection between the two definitions. For instance, s1 is clearly not an inverse of foo , at least not in Hask . I suppose s1 doesn't even have to have an inverse in Hask . Is

https://wiki.haskell.org/Hask : Consider: undef1 = undefined :: a -> b undef2 = \_ -> undefined Note that these are not the same value: seq undef1 () = undefined seq undef2 () = () This might be a problem, because undef1 . id = undef2 . In order to make Hask a category, we define two functions f and g as the same morphism if f x = g x for all x . Thus undef1 and undef2 are different values , but the same morphism in Hask . What does it mean or how can I check, that: undef1 and undef2 are different values, but the same morphism? In Haskell, we have this idea that every expression can be

This answer from a Category Theory perspective includes the following statement: ...the truth is that there's no real distinction between co and contravariant functor, because every functor is just a covariant functor. ... More in details a contravariant functor F from a category C to a category D is nothing more than a (covariant) functor of type F : C op →D, from the opposite category of C to the category D. On the other hand, Haskell's Functor and Contravariant merely require fmap and contramap , respectively, to be defined for an instance. This suggests that, from the perspective of

Recently I've finally started to feel like I understand catamorphisms. I wrote some about them in a recent answer , but briefly I would say a catamorphism for a type abstracts over the process of recursively traversing a value of that type, with the pattern matches on that type reified into one function for each constructor the type has. While I would welcome any corrections on this point or on the longer version in the answer of mine linked above, I think I have this more or less down and that is not the subject of this question, just some background. Once I realized that the functions you

While musing what more useful standard class to suggest to this one class Coordinate c where createCoordinate :: x -> y -> c x y getFirst :: c x y -> x getSecond :: c x y -> y addCoordinates :: (Num x, Num y) => c x y -> c x y -> c x y it occured me that instead of something VectorSpace -y or R2 , a rather more general beast might lurk here: a Type -> Type -> Type whose two contained types can both be extracted. Hm, perhaps they can be extract ed ? Turns out neither the comonad nor bifunctors package contains something called Bicomonad . Question is, would such a class even make sense,