[Haskell-beginners] Are functors in Haskell always injective?

[Dimitri DeFigueiredo]

Oops! Sorry for the typos! Fixing that below.

Hi All,

My understanding is that a functor in Haskell is made of two "maps".
One that maps objects to objects that in Hask means types into types 
(i.e. a type constructor)
And one that maps arrows into arrows, i.e. fmap.

My understanding is that a functor F in category theory is required to 
preserve the domain and codomain of arrows, but it doesn't have to be 
injective. In other words, two objects X and Y of category C (i.e. two 
types in Hask) can be mapped into the same object Z (same type) in 
category D. As long as the "homomorphism" law holds:

F(f:X->Y) = F(f):F(X)->F(Y)

However, I don't think there is any way this mapping of types cannot be 
injective in Haskell. It seems that a type constructor, when called with 
two distinct type will always yield another two *distinct* types. (E.g. 
Int and Double yield Maybe Int and Maybe Double) So, it seems that 
Functors in Haskell are actually more restrictive than functors can be 
in general. Is this observation correct or did I misunderstand something?


Thanks!


Dimitri

Em 05/07/14 02:42, Dimitri DeFigueiredo escreveu:
> Hi All,
>
> My understanding is that a functor in Haskell is made of two "maps".
> One that maps objects to objects that in Hask means types into types 
> (i.e. a type constructor)
> And one that maps arrows into arrows, i.e. fmap.
>
> My understanding is that a functor F in category theory is required to 
> preserve the domain and codomain of arrows, but it doesn't have to be 
> injective. In other words, two objects X and Y of category C (i.e. two 
> types in Hask) can be mapped into the same object Z (same type) in 
> category Z. As long as the "homomorphism" law holds:
>
> F(f:X->Y) = F(f):F(X)->F(Y)
>
> However, I don't think there is any way this mapping of types cannot 
> be injective in Haskell. It seems that a type constructor, when called 
> with two distinct type will always yield another two *distinct* types. 
> (E.g. Int and Fload yield Maybe Int and Maybe) So, it seems that 
> Functors in Haskell are actually more restrictive than functors can be 
> in general. Is this observation correct or did I misunderstand something?
>
>
> Thanks!
>
>
> Dimitri
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20140705/b46e1846/attachment.html>