Data.Thorn.Functor

The module Data.Thorn.Functor.

Functors

Thorn generates functors from various kinds of datatypes.

Quite surprisingly, it still works for any arities, co/contra/free/fixed-variances, partially applied types, type synonyms, and mutual recursions.

autofmap :: TypeQ -> ExpQ

autofmap t generates an fmap of the type t.

autofmaptype :: TypeQ -> TypeQ

autofmaptype t provides the type of $(autofmap t).

autofmapdec :: String -> TypeQ -> DecsQ

autofmapdec s t provides a declaration of an fmap for the type t with the name s, with a type signature.

autofunctorize :: TypeQ -> DecsQ

autofunctorize t provides instance delcarations of the type t, for the suitable functor classes : Functor, Contravariant, Bifunctor, or Profunctor. Multiple classes can be suitable for t, when one of the variances of t is Free.

Variance

data Variance

Variance is a variance of a parameter of a functor.

Constructors

Co

Covariance, one of a normal functor.

Contra

Contravariance, the dual of covariance.

Free

Free-variance, or invariance, being supposed to satisfy either covariance or contravariance.

Fixed

Fixed-variance, or nonvariance, being supposed to satisfy both covariance and contravariance.

Instances

Read Variance

Show Variance

Monoid Variance

v1 mappend v2 means to be supposed to satisfy both v1 and v2.

autovariance :: TypeQ -> ExpQ

autovariance t provides the variances of the type t.

Examples

Basic

It's a piece of cake.

 testtuple :: (Int,String)
 testtuple = $(autofmap [t|(,)|]) (+1) ('h':) (100,"ello") -- (101,"hello")
 
 testeither :: Either Int String
 testeither = $(autofmap [t|Either|]) (+1) ('a':) (Left 100) -- Left 101
 
 testfunction :: String
 testfunction = $(autofmap [t|(->)|]) ('h':) (++"!") (++", world") "ello" -- "hello, world!"
 
 testlist :: [Int]
 testlist = $(autofmap [t|[]|]) (+10) [1..5] -- [11..15]

Functions

You can nest functions.

 data FunFun a b = FunFun ((b -> a) -> b)
 
 varfunfun :: [Variance]
 varfunfun = $(autovariance [t|FunFun|]) -- [Contra,Co]
 
 autofunctorize [t|FunFun|]
 -- instance Profunctor FunFun where
 --     dimap = ...

Partial Application

It works for partially applied types.

 testpartial :: (Int,Int,Int)
 testpartial = $(autofmap $[t|(,,) Int|]) (+10) (+20) (1,1,1) -- (1,11,21)

You can use type variants T0, T1, ..., T9 to represent any type.

 testpartial' :: (String,Int,Int)
 testpartial' = $(autofmap $[t|(,,) T0|]) (+10) (+20) ("hello",1,1) -- ("hello",11,21)

Type Synonyms

Interestingly, it works for type synonyms.

 type a :<- b = b -> a
 varnuf :: [Variance]
 varnuf = $(autovariance [t|(:<-)|]) -- [Co,Contra]
 $(autofmapdec "fmapnuf" [t|(:<-)|])

Variances

It works for free-variance and fixed-variance. See how autofunctorize works for free-variance.

 data What a b c = What1 c (a -> c) | What2 a
 
 varwhat :: [Variance]
 varwhat = $(autovariance [t|What|]) -- [Fixed,Free,Co]
 
 autofunctorize [t|What T0|]
 -- instance Bifunctor (What a) where
 --     bimap = ...
 -- instance Profunctor (What a) where
 --     dimap = ...

Recursive Types

It works for recursive datatypes.

 data List a = Nil | a :* (List a) deriving Show
 
 autofunctorize [t|List|]
 -- instance Functor List where
 --     fmap = ...
 
 fromNormalList :: [a] -> List a
 fromNormalList [] = Nil
 fromNormalList (a : as) = a :* fromNormalList as
 toNormalList :: List a -> [a]
 toNormalList Nil = []
 toNormalList (a :* as) = a : toNormalList as
 
 testlist :: [Int]
 testlist = toNormalList $ fmap (+10) (fromNormalList [1..5]) -- [11..15]

It also works for mutually recursive datatypes.

 data Rose a = Rose a (Forest a) deriving Show
 data Forest a = Forest [Rose a] deriving Show
 
 autofunctorize [t|Rose|]
 -- instance Functor Rose where
 --     fmap = ...
 
 gorose :: Int -> Rose Int
 gorose 0 = Rose 0 (Forest [])
 gorose n = Rose n (Forest (replicate 2 (gorose (n-1))))
 testrose :: Rose Int
 testrose = fmap (+10) (gorose 2)
 -- Rose 12 (Forest [Rose 11 (Forest [Rose 10 (Forest []),Rose 10 (Forest [])]),Rose 11 (Forest [Rose 10 (Forest []),Rose 10 (Forest [])])])