Data.HList.FakePrelude

The HList library

(C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke

Some very basic technology for faking dependent types in Haskell.

A heterogeneous apply operator

class Apply f a where

simpler/weaker version where type information only propagates forward with this one. applyAB defined below, is more complicated / verbose to define, but it offers better type inference. Most uses have been converted to applyAB, so there is not much that can be done with Apply.

Minimal complete definition

apply

Associated Types

type ApplyR f a :: *

Methods

apply :: f -> a -> ApplyR f a

Instances

HLookupByHNat n l => Apply (FHLookupByHNat l) (Proxy HNat n)

Associated Types

type ApplyR (FHLookupByHNat l) (Proxy HNat n) :: *

Methods

apply :: FHLookupByHNat l -> Proxy HNat n -> ApplyR (FHLookupByHNat l) (Proxy HNat n)

Apply (FHUProj sel ns) (HList l, Proxy HNat (HSucc n)) => Apply (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool False, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

Apply (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool True, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

((~) * ch (Proxy Bool (HBoolEQ sel (KMember n ns))), Apply (ch, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)) => Apply (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: FHUProj sel ns -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

Apply (FHUProj sel ns) (HList ([] *), n)

Associated Types

type ApplyR (FHUProj sel ns) (HList [*], n) :: *

Methods

apply :: FHUProj sel ns -> (HList [*], n) -> ApplyR (FHUProj sel ns) (HList [*], n)

Polymorphic functions are not first-class in haskell. An example of this is:

f op = (op (1 :: Double), op (1 :: Int))

RankNTypes

One solution is to enable `-XRankNTypes` and then write a type signature which might be `f :: (forall a. Num a => a -> a)`. This does not work in the context of HList, since we want to use functions that do not necessarily fall into the pattern of (forall a. c a => a -> a).

MultipleArguments

Another solution is to rewrite op to look like

f op1 op2 = (op1 (1:: Double), op2 (1 :: Int))

In some sense this approach works (see HZip), but the result is constrained to as many function applications as you are willing to write (ex. a function that works for records of six entries would look like hBuild f f f f f f).

Defunctionalization

Therefore the selected solution is to write an instance of ApplyAB for a data type that takes the place of the original function. In other words,

data Fn = Fn
instance ApplyAB Fn a b where applyAB Fn a = actual_fn a

Normally you would have been able to pass around the definition actual_fn.

Type inference / Local functional dependencies

Note that class ApplyAB has three parameters and no functional dependencies. Instances should be written in the style:

instance (int ~ Int, double ~ Double) => ApplyAB Fn int double
 where applyAB _ = fromIntegral

rather than the more natural

instance ApplyAB Fn Int Double

The first instance allows types to be inferred as if we had class ApplyAB a b c | a -> b c, while the second instance only matches if ghc already knows that it needs ApplyAB Fn Int Double. Since applyAB Fn :: Int -> Double has a monomorphic type, this trimmed down example does not really make sense because applyAB (fromIntegral :: Int -> Double) is exactly the same. Nontheless, the other uses of ApplyAB follow this pattern, and the benefits are seen when the type of applyAB Fn has at least one type variable.

Additional explanation can be found in local functional dependencies

AmbiguousTypes

Note that ghc only allows AllowAmbiguousTypes when a type signature is provided. Thus expressions such as:

data AddJust = AddJust
instance (y ~ Maybe x) => ApplyAB AddJust x y where
   applyAB _ x = Just x

twoJustsBad = hMap AddJust . hMap AddJust -- ambiguous type

Are not accepted without a type signature that references the intermediate "b":

twoJusts :: forall r a b c. (HMapCxt r AddJust a b, HMapCxt r AddJust b c) =>
       r a -> r c
twoJusts a = hMap AddJust (hMap AddJust a :: r b)

An apply class with functional dependencies

class ApplyAB' f a b | f a -> b, f b -> a

Or with equivalent type families

class (GetB f a ~ b, GetA f b ~ a) => ApplyAB' f a b

would not require an annotation for twoJusts. However, not all instances of ApplyAB will satisfy those functional dependencies, and thus the number of classes would proliferate. Furthermore, inference does not have to be in one direction only, as the example of HMap shows.

class ApplyAB f a b where

No constraints on result and argument types

Minimal complete definition

applyAB

Methods

applyAB :: f -> a -> b

Instances

(~) * (Tagged k t x) tx => ApplyAB HUntag tx x

Methods

applyAB :: HUntag -> tx -> x

((~) * f1 (a -> b -> c), (~) * f2 (b -> a -> c)) => ApplyAB HFlip f1 f2

Methods

applyAB :: HFlip -> f1 -> f2

((~) * y y', (~) * fg (x -> y, y' -> z), (~) * r (x -> z)) => ApplyAB Comp fg r

Methods

applyAB :: Comp -> fg -> r

((~) * String string, Show a) => ApplyAB HShow a string

Methods

applyAB :: HShow -> a -> string

((~) * String string, Read a) => ApplyAB HRead string a

Methods

applyAB :: HRead -> string -> a

((~) * io (IO ()), Show x) => ApplyAB HPrint x io

Methods

applyAB :: HPrint -> x -> io

((~) * aa (a, a), Semigroup a) => ApplyAB UncurrySappend aa a

Methods

applyAB :: UncurrySappend -> aa -> a

((~) * aa (a, a), Monoid a) => ApplyAB UncurryMappend aa a

Methods

applyAB :: UncurryMappend -> aa -> a

((~) * x (Proxy * y), Monoid y) => ApplyAB ConstMempty x y

Methods

applyAB :: ConstMempty -> x -> y

(~) * hJustA (HJust a) => ApplyAB HFromJust hJustA a

Methods

applyAB :: HFromJust -> hJustA -> a

((~) * x (e, HList l), (~) * y (HList ((:) * e l))) => ApplyAB FHCons x y

Methods

applyAB :: FHCons -> x -> y

(~) * tx (Tagged k t x) => ApplyAB TaggedFn x tx

Methods

applyAB :: TaggedFn -> x -> tx

((~) * x (Tagged k l v), (~) * y (HList ((:) * (Label k l) ((:) * v ([] *))))) => ApplyAB TaggedToKW x y

Methods

applyAB :: TaggedToKW -> x -> y

(HZip3 a b c, (~) * x (HList a, HList b), (~) * y (HList c)) => ApplyAB HZipF x y

Methods

applyAB :: HZipF -> x -> y

((~) * x (Tagged k t (Maybe e), [Variant v]), (~) * y [Variant ((:) * (Tagged k t e) v)], MkVariant k t e ((:) * (Tagged k t e) v)) => ApplyAB HMaybiedToVariantFs x y

Methods

applyAB :: HMaybiedToVariantFs -> x -> y

(~) * y (Tagged k t (Maybe e)) => ApplyAB ConstTaggedNothing x y

Methods

applyAB :: ConstTaggedNothing -> x -> y

((~) * mx (Maybe x), (~) * my (Maybe y), HCast y x) => ApplyAB HCastF mx my

Methods

applyAB :: HCastF -> mx -> my

((~) * ee (e, e), Eq e, (~) * bool Bool) => ApplyAB UncurryEq ee bool

Methods

applyAB :: UncurryEq -> ee -> bool

((~) * ux (RecordU x), (~) * hx (HList x), RecordUToRecord x) => ApplyAB BoxF ux hx

Methods

applyAB :: BoxF -> ux -> hx

((~) * hx (HList x), (~) * ux (RecordU x), RecordToRecordU x) => ApplyAB UnboxF hx ux

Methods

applyAB :: UnboxF -> hx -> ux

(~) * e' e => ApplyAB HRmTag (e, t) e'

Methods

applyAB :: HRmTag -> (e, t) -> e'

((~) * y (ReadP x), Read x) => ApplyAB ReadElement (Proxy * x) y

Methods

applyAB :: ReadElement -> Proxy * x -> y

(Read v, ShowLabel k l, (~) * x (Tagged k l v), (~) * (ReadP x) y) => ApplyAB ReadComponent (Proxy * x) y

Methods

applyAB :: ReadComponent -> Proxy * x -> y

(~) * hJustA (HJust a) => ApplyAB (HJust t) a hJustA

HJust () is a placeholder for a function that applies the HJust constructor

Methods

applyAB :: HJust t -> a -> hJustA

(ApplyAB f (x, y) z, (~) * mz (m z), (~) * mxy (m x, m y), Applicative m) => ApplyAB (LiftA2 f) mxy mz

Methods

applyAB :: LiftA2 f -> mxy -> mz

((~) * x (t a), (~) * y (t b), Functor t, ApplyAB f a b) => ApplyAB (HFmap f) x y

Methods

applyAB :: HFmap f -> x -> y

(Monad m, ApplyAB f x fx, (~) * fx (m ()), (~) * pair (x, m ()), ApplyAB f x (m ())) => ApplyAB (HSeq f) pair fx

Methods

applyAB :: HSeq f -> pair -> fx

((~) * hxs (HList xs), (~) * hxxs (HList ((:) * x xs))) => ApplyAB (FHCons2 x) hxs hxxs

Methods

applyAB :: FHCons2 x -> hxs -> hxxs

(~) * et (e, t) => ApplyAB (HAddTag t) e et

Methods

applyAB :: HAddTag t -> e -> et

((~) * l [e'], ApplyAB f e e', (~) * el (e, l)) => ApplyAB (Mapcar f) el l

Methods

applyAB :: Mapcar f -> el -> l

(HMapCxt HList f a b, (~) * as (HList a), (~) * bs (HList b)) => ApplyAB (HMapL f) as bs

Methods

applyAB :: HMapL f -> as -> bs

(HMapCxt r f a b, (~) * as (r a), (~) * bs (r b)) => ApplyAB (HMap f) as bs

Methods

applyAB :: HMap f -> as -> bs

(HMapCxt Record f x y, (~) * rx (Record x), (~) * ry (Record y)) => ApplyAB (HMapR f) rx ry

Methods

applyAB :: HMapR f -> rx -> ry

((~) * vx (Variant x), (~) * vy (Variant y), HMapAux Variant (HFmap f) x y, SameLength * * x y) => ApplyAB (HMapV f) vx vy

apply a function to all values that could be in the variant.

Methods

applyAB :: HMapV f -> vx -> vy

(Data b, (~) * x (t, c (b -> r)), (~) * y (c r)) => ApplyAB (GunfoldK c) x y

Methods

applyAB :: GunfoldK c -> x -> y

(Data d, (~) * (c (d -> b), d) x, (~) * (c b) y) => ApplyAB (GfoldlK c) x y

Methods

applyAB :: GfoldlK c -> x -> y

ApplyAB f e e' => ApplyAB (MapCar f) (e, HList l) (HList ((:) * e' l))

Methods

applyAB :: MapCar f -> (e, HList l) -> HList ((* ': e') l)

((~) * x' x, (~) * y' y) => ApplyAB (x' -> y') x y

note this function will only be available at a single type (that is, hMap succ will only work on HList that contain only one type)

Methods

applyAB :: (x' -> y') -> x -> y

(ApplyAB f a b, ApplyAB g b c) => ApplyAB (HComp g f) a c

Methods

applyAB :: HComp g f -> a -> c

(FunCxt k1 cxt b, (~) * (FunApp k2 geta b) a) => ApplyAB (Fun' k1 k2 cxt geta) a b

Methods

applyAB :: Fun' k1 k2 cxt geta -> a -> b

(FunCxt k1 cxt a, (~) * (FunApp k2 getb a) b) => ApplyAB (Fun k1 k2 cxt getb) a b

Methods

applyAB :: Fun k1 k2 cxt getb -> a -> b

Fun can be used instead of writing a new instance of ApplyAB. Refer to the definition/source for the the most concise explanation. A more wordy explanation is given below:

A type signature needs to be provided on Fun to make it work. Depending on the kind of the parameters to Fun, a number of different results happen.

ex1

A list of kind [* -> Constraint] produces those constraints on the argument type:

>>> :set -XDataKinds
>>> let plus1f x = if x < 5 then x+1 else 5
>>> let plus1 = Fun plus1f :: Fun '[Num, Ord] '()
>>> :t applyAB plus1
applyAB plus1 :: (Num b, Ord b) => b -> b

>>> let xs = [1 .. 8]
>>> map (applyAB plus1) xs == map plus1f xs
True

Also note the use of '() to signal that the result type is the same as the argument type.

A single constraint can also be supplied:

>>> let succ1 = Fun succ :: Fun Enum '()
>>> :t applyAB succ1
applyAB succ1 :: Enum b => b -> b

>>> let just = Fun Just :: Fun '[] Maybe
>>> :t applyAB just
applyAB just :: a -> Maybe a

data Fun (cxt :: k1) (getb :: k2)

Constructors

Fun (forall a. FunCxt cxt a => a -> FunApp getb a)

Instances

(FunCxt k1 cxt a, (~) * (FunApp k2 getb a) b) => ApplyAB (Fun k1 k2 cxt getb) a b

Methods

applyAB :: Fun k1 k2 cxt getb -> a -> b

data Fun' (cxt :: k1) (geta :: k2)

see Fun. The only difference here is that the argument type is calculated from the result type.

>>> let rd = Fun' read :: Fun' Read String
>>> :t applyAB rd
applyAB rd :: Read b => [Char] -> b

>>> let fromJust' = Fun' (\(Just a) -> a) :: Fun' '[] Maybe
>>> :t applyAB fromJust'
applyAB fromJust' :: Maybe b -> b

Note this use of Fun' means we don't have to get the b out of Maybe b,

Constructors

Fun' (forall b. FunCxt cxt b => FunApp geta b -> b)

Instances

(FunCxt k1 cxt b, (~) * (FunApp k2 geta b) a) => ApplyAB (Fun' k1 k2 cxt geta) a b

Methods

applyAB :: Fun' k1 k2 cxt geta -> a -> b

type family FunApp (fns :: k) a

Instances

type FunApp * fn a

type FunApp * fn a = fn

type FunApp () fn a

type FunApp () fn a = a

type FunApp (* -> *) fn a

type FunApp (* -> *) fn a = fn a

type family FunCxt (cxts :: k) a :: Constraint

Instances

type FunCxt * cxt a

type FunCxt * cxt a = (~) * cxt a

type FunCxt () cxt a

type FunCxt () cxt a = ()

type FunCxt [k] ([] k) a

type FunCxt [k] ([] k) a = ()

type FunCxt [* -> Constraint] ((:) (* -> Constraint) x xs) a

type FunCxt [* -> Constraint] ((:) (* -> Constraint) x xs) a = (x a, FunCxt [* -> Constraint] xs a)

type FunCxt (* -> Constraint) cxt a

type FunCxt (* -> Constraint) cxt a = cxt a

Simple useful instances of Apply

data HPrint

print. An alternative implementation could be:

>>> let hPrint = Fun print :: Fun Show (IO ())

This produces:

>>> :t applyAB hPrint
applyAB hPrint :: Show a => a -> IO ()

Constructors

HPrint

Instances

((~) * io (IO ()), Show x) => ApplyAB HPrint x io

Methods

applyAB :: HPrint -> x -> io

data HRead

read

>>> applyAB HRead "5.0" :: Double
5.0

Constructors

HRead

Instances

((~) * String string, Read a) => ApplyAB HRead string a

Methods

applyAB :: HRead -> string -> a

data HShow

show

Constructors

HShow

Instances

((~) * String string, Show a) => ApplyAB HShow a string

Methods

applyAB :: HShow -> a -> string

data HComp g f

Compose two instances of ApplyAB

>>> applyAB (HComp HRead HShow) (5::Double) :: Double
5.0

Constructors

HComp g f

g . f

Instances

(ApplyAB f a b, ApplyAB g b c) => ApplyAB (HComp g f) a c

Methods

applyAB :: HComp g f -> a -> c

data Comp

app Comp (f,g) = g . f. Works like:

>>> applyAB Comp (succ, pred) 'a'
'a'

>>> applyAB Comp (toEnum :: Int -> Char, fromEnum) 10
10

Note that defaulting will sometimes give you the wrong thing

used to work (with associated types calculating result/argument types)
>>> applyAB Comp (fromEnum, toEnum) 'a'
*** Exception: Prelude.Enum.().toEnum: bad argument

Constructors

Comp

Instances

((~) * y y', (~) * fg (x -> y, y' -> z), (~) * r (x -> z)) => ApplyAB Comp fg r

Methods

applyAB :: Comp -> fg -> r

newtype HSeq x

((a,b) -> f a >> b)

Constructors

HSeq x

Instances

(Monad m, ApplyAB f x fx, (~) * fx (m ()), (~) * pair (x, m ()), ApplyAB f x (m ())) => ApplyAB (HSeq f) pair fx

Methods

applyAB :: HSeq f -> pair -> fx

data HFlip

flip

Constructors

HFlip

Instances

((~) * f1 (a -> b -> c), (~) * f2 (b -> a -> c)) => ApplyAB HFlip f1 f2

Methods

applyAB :: HFlip -> f1 -> f2

newtype HFmap f

fmap

Constructors

HFmap f

Instances

((~) * x (t a), (~) * y (t b), Functor t, ApplyAB f a b) => ApplyAB (HFmap f) x y

Methods

applyAB :: HFmap f -> x -> y

newtype LiftA2 f

liftA2

Constructors

LiftA2 f

Instances

(ApplyAB f (x, y) z, (~) * mz (m z), (~) * mxy (m x, m y), Applicative m) => ApplyAB (LiftA2 f) mxy mz

Methods

applyAB :: LiftA2 f -> mxy -> mz

data HUntag

untag

Constructors

HUntag

Instances

(~) * (Tagged k t x) tx => ApplyAB HUntag tx x

Methods

applyAB :: HUntag -> tx -> x

Proxy

see Data.Proxy

data Label l

A special Proxy for record labels, polykinded

Constructors

Label

Instances

(HasField k l (Record r) u, HasFieldPath needJust ls u v) => HasFieldPath needJust ((:) * (Label k l) ls) (Record r) v

Methods

hLookupByLabelPath1 :: Proxy Bool needJust -> Label [*] ((* ': Label k l) ls) -> Record r -> v

(HasField k l (Variant r) (Maybe u), HasFieldPath True ls u (Maybe v)) => HasFieldPath needJust ((:) * (Label k l) ls) (Variant r) (Maybe v)

Methods

hLookupByLabelPath1 :: Proxy Bool needJust -> Label [*] ((* ': Label k l) ls) -> Variant r -> Maybe v

(~) * (Label k t) (Label Symbol t') => SameLabels * Symbol (Label k t) t'

HEqBy * k HLeFn x y b => HEqBy * * HLeFn (Label k x) (Label k y) b

(~) * (Label k2 t) (Label k1 t') => SameLabels * * (Label k2 t) (Label k1 t')

(~) * (Label k2 t) (Label k1 t') => SameLabels * * (Label k2 t) (Tagged k1 t' a)

(~) * (Label k t) (Label * (Lbl ix ns n)) => SameLabels * * (Label k t) (Lbl ix ns n)

((~) * lv (Tagged k l v), HUnzip (Proxy [*]) ls vs lvs) => HUnzip (Proxy [*]) ((:) * (Label k l) ls) ((:) * v vs) ((:) * lv lvs)

Methods

hUnzip :: Proxy [*] ((* ': lv) lvs) -> (Proxy [*] ((* ': Label k l) ls), Proxy [*] ((* ': v) vs))

Show desc => Show (Label * (Lbl x ns desc))

Methods

showsPrec :: Int -> Label * (Lbl x ns desc) -> ShowS

show :: Label * (Lbl x ns desc) -> String

showList :: [Label * (Lbl x ns desc)] -> ShowS

HExtend (Label * (Lbl n ns desc)) (Proxy [Symbol] ((:) Symbol x xs))

Mixing two label kinds means we have to include Label:

>>> let r = label3 .*. label6 .*. emptyProxy
>>> :t r
r :: Proxy '[Label (Lbl 'HZero () ()), Label "6"]

Associated Types

type HExtendR (Label * (Lbl n ns desc)) (Proxy [Symbol] ((Symbol ': x) xs)) :: *

Methods

(.*.) :: Label * (Lbl n ns desc) -> Proxy [Symbol] ((Symbol ': x) xs) -> HExtendR (Label * (Lbl n ns desc)) (Proxy [Symbol] ((Symbol ': x) xs))

HExtend (Label * (Lbl n ns desc)) (Proxy [*] ((:) * (Lbl n' ns' desc') xs))

If possible, Label is left off:

>>> let q = label3 .*. label3 .*. emptyProxy
>>> :t q
q :: Proxy '[Lbl 'HZero () (), Lbl 'HZero () ()]

Associated Types

type HExtendR (Label * (Lbl n ns desc)) (Proxy [*] ((* ': Lbl n' ns' desc') xs)) :: *

Methods

(.*.) :: Label * (Lbl n ns desc) -> Proxy [*] ((* ': Lbl n' ns' desc') xs) -> HExtendR (Label * (Lbl n ns desc)) (Proxy [*] ((* ': Lbl n' ns' desc') xs))

HExtend (Label k x) (Proxy [*] ([] *))

to keep types shorter, .*. used with Proxy avoids producing a Proxy :: Proxy '[Label x,Label y,Label z] if Proxy :: Proxy '[x,y,z] is not a kind error (as it is when mixing Label6 and Label3 labels).

ghc-7.6 does not accept Proxy ('[] :: [k]) so for now require k ~ *

Associated Types

type HExtendR (Label k x) (Proxy [*] [*]) :: *

Methods

(.*.) :: Label k x -> Proxy [*] [*] -> HExtendR (Label k x) (Proxy [*] [*])

ToSym * (a b c) x => EnsureLabel (a b c) (Label Symbol x)

get the Label out of a LabeledTo (ie. `foobar when using HListPP).

Methods

toLabel :: a b c -> Label Symbol x

EnsureLabel (Proxy k x) (Label k x)

Methods

toLabel :: Proxy k x -> Label k x

EnsureLabel (Label k x) (Label k x)

Methods

toLabel :: Label k x -> Label k x

(Labelable k1 x r s t a b, (~) * j (p a (f b)), (~) * k2 (p (r s) (f (r t))), (~) LabeledOpticType ty (LabelableTy r), LabeledOpticP ty p, LabeledOpticF ty f, LabeledOpticTo k1 ty x ((->) LiftedRep LiftedRep), LabelablePath xs i j) => LabelablePath ((:) * (Label k1 x) xs) i k2

Methods

hLens'Path :: Label [*] ((* ': Label k1 x) xs) -> i -> k2

type UnLabel a proxy ((:) * (Label a x) xs)

type UnLabel a proxy ((:) * (Label a x) xs) = (:) a x (UnLabel a proxy xs)

type ZipTagged * ((:) * (Label k t) ts) ((:) * v vs)

type ZipTagged * ((:) * (Label k t) ts) ((:) * v vs) = (:) * (Tagged k t v) (ZipTagged * ts vs)

type HExtendR (Label * (Lbl n ns desc)) (Proxy [*] ((:) * (Lbl n' ns' desc') xs))

type HExtendR (Label * (Lbl n ns desc)) (Proxy [*] ((:) * (Lbl n' ns' desc') xs)) = Proxy [*] ((:) * (Lbl n ns desc) ((:) * (Lbl n' ns' desc') xs))

type HExtendR (Label * (Lbl n ns desc)) (Proxy [Symbol] ((:) Symbol x xs))

type HExtendR (Label * (Lbl n ns desc)) (Proxy [Symbol] ((:) Symbol x xs)) = Proxy [*] ((:) * (Label * (Lbl n ns desc)) (MapLabel Symbol ((:) Symbol x xs)))

type HExtendR (Label Nat y) (Proxy [Symbol] ((:) Symbol x xs))

type HExtendR (Label Nat y) (Proxy [Symbol] ((:) Symbol x xs)) = Proxy [*] ((:) * (Label Nat y) (MapLabel Symbol ((:) Symbol x xs)))

type HExtendR (Label Nat y) (Proxy [*] ((:) * x xs))

type HExtendR (Label Nat y) (Proxy [*] ((:) * x xs)) = Proxy [*] ((:) * (Label Nat y) (MapLabel * ((:) * x xs)))

type HExtendR (Label Nat y) (Proxy [Nat] ((:) Nat x xs))

type HExtendR (Label Nat y) (Proxy [Nat] ((:) Nat x xs)) = Proxy [Nat] ((:) Nat y ((:) Nat x xs))

type HExtendR (Label Symbol y) (Proxy [Nat] ((:) Nat x xs))

type HExtendR (Label Symbol y) (Proxy [Nat] ((:) Nat x xs)) = Proxy [*] ((:) * (Label Symbol y) (MapLabel Nat ((:) Nat x xs)))

type HExtendR (Label Symbol y) (Proxy [*] ((:) * x xs))

type HExtendR (Label Symbol y) (Proxy [*] ((:) * x xs)) = Proxy [*] ((:) * (Label Symbol y) (MapLabel * ((:) * x xs)))

type HExtendR (Label Symbol y) (Proxy [Symbol] ((:) Symbol x xs))

type HExtendR (Label Symbol y) (Proxy [Symbol] ((:) Symbol x xs)) = Proxy [Symbol] ((:) Symbol y ((:) Symbol x xs))

type HExtendR (Label k x) (Proxy [*] ([] *))

type HExtendR (Label k x) (Proxy [*] ([] *)) = Proxy [k] ((:) k x ([] k))

type LabelsOf ((:) * (Label k l) r)

type LabelsOf ((:) * (Label k l) r) = (:) * (Label k l) (LabelsOf r)

labelToProxy :: Label l -> Proxy l

class ShowLabel l where

Minimal complete definition

showLabel

Methods

showLabel :: Label l -> String

Instances

Show desc => ShowLabel * (Lbl x ns desc)

Equality on labels (descriptions are ignored) Use generic instance

Show label

Methods

showLabel :: Label (Lbl x ns desc) l -> String

Booleans

GHC already lifts booleans, defined as

data Bool = True | False

to types: Bool becomes kind and True and False (also denoted by 'True and 'False) become nullary type constructors.

The above line is equivalent to

data HTrue
data HFalse

class HBool x
instance HBool HTrue
instance HBool HFalse

Value-level proxies

hTrue :: Proxy True

hFalse :: Proxy False

Conjunction

type family HAnd (t1 :: Bool) (t2 :: Bool) :: Bool

Instances

type HAnd False t

type HAnd False t = False

type HAnd True t

type HAnd True t = t

hAnd :: Proxy t1 -> Proxy t2 -> Proxy (HAnd t1 t2)

demote to values

Disjunction

type family HOr (t1 :: Bool) (t2 :: Bool) :: Bool

Instances

type HOr False t

type HOr False t = t

type HOr True t

type HOr True t = True

hOr :: Proxy t1 -> Proxy t2 -> Proxy (HOr t1 t2)

demote to values

Compare with the original code based on functional dependencies:

class (HBool t, HBool t', HBool t'') => HOr t t' t'' | t t' -> t''
 where
  hOr :: t -> t' -> t''

instance HOr HFalse HFalse HFalse
 where
  hOr _ _ = hFalse

instance HOr HTrue HFalse HTrue
 where
  hOr _ _ = hTrue

instance HOr HFalse HTrue HTrue
 where
  hOr _ _ = hTrue

instance HOr HTrue HTrue HTrue
 where
  hOr _ _ = hTrue

type family HNot (x :: Bool) :: Bool

Instances

type HNot False

type HNot False = True

type HNot True

type HNot True = False

class HNotFD (b :: Bool) (nb :: Bool) | b -> nb, nb -> b

as compared with HNot this version is injective

Instances

HNotFD False True

HNotFD True False

hNot :: HNotFD a notA => Proxy a -> Proxy notA

class HCond (t :: Bool) x y z | t x y -> z where

Minimal complete definition

hCond

Methods

hCond :: Proxy t -> x -> y -> z

Instances

HCond False x y y

Methods

hCond :: Proxy Bool False -> x -> y -> y

HCond True x y x

Methods

hCond :: Proxy Bool True -> x -> y -> x

Boolean equivalence

type family HBoolEQ (t1 :: Bool) (t2 :: Bool) :: Bool

Instances

type HBoolEQ False False

type HBoolEQ False False = True

type HBoolEQ False True

type HBoolEQ False True = False

type HBoolEQ True False

type HBoolEQ True False = False

type HBoolEQ True True

type HBoolEQ True True = True

Naturals

data HNat

The data type to be lifted to the type level

Constructors

HZero

HSucc HNat

Instances

(~) [*] xxs ([] *) => HLengthEq1 HNat xxs HZero

(HLengthEq xs n, (~) [*] xxs ((:) * x xs)) => HLengthEq1 HNat xxs (HSucc n)

(~) HNat zero HZero => HLengthEq2 HNat ([] *) zero

HFindMany k ([] k) r ([] HNat)

(HLengthEq xs n, (~) HNat sn (HSucc n)) => HLengthEq2 HNat ((:) * x xs) sn

(HFind k l r n, HFindMany k ls r ns) => HFindMany k ((:) k l ls) r ((:) HNat n ns)

HNats2Integrals ([] HNat)

Methods

hNats2Integrals :: Integral i => Proxy [HNat] [HNat] -> [i]

(~) Bool (HLe x y) b => HEqBy * HNat HLeFn x y b

HLookupByHNat n l => Apply (FHLookupByHNat l) (Proxy HNat n)

Associated Types

type ApplyR (FHLookupByHNat l) (Proxy HNat n) :: *

Methods

apply :: FHLookupByHNat l -> Proxy HNat n -> ApplyR (FHLookupByHNat l) (Proxy HNat n)

Apply (FHUProj sel ns) (HList l, Proxy HNat (HSucc n)) => Apply (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool False, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

Apply (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool True, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

((~) * ch (Proxy Bool (HBoolEQ sel (KMember n ns))), Apply (ch, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)) => Apply (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: FHUProj sel ns -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

(HNats2Integrals ns, HNat2Integral n) => HNats2Integrals ((:) HNat n ns)

Methods

hNats2Integrals :: Integral i => Proxy [HNat] ((HNat ': n) ns) -> [i]

(HNat2Integral n, (~) * (HLookupByHNatR n u) le, (~) * le (Tagged k l e), IArray UArray e, (~) * e (GetElemTy u)) => HLookupByHNatUS1 (Left HNat HNat t) n u us le

Methods

hLookupByHNatUS1 :: Proxy (Either HNat HNat) (Left HNat HNat t) -> Proxy HNat n -> RecordU u -> HList us -> le

HLookupByHNatUS t us e => HLookupByHNatUS1 (Right HNat HNat t) n u us e

Methods

hLookupByHNatUS1 :: Proxy (Either HNat HNat) (Right HNat HNat t) -> Proxy HNat n -> RecordU u -> HList us -> e

type KMember n ([] HNat)

type KMember n ([] HNat) = False

type KMember n ((:) HNat n1 l)

type KMember n ((:) HNat n1 l) = HOr (HNatEq n n1) (KMember n l)

type ApplyR (FHLookupByHNat l) (Proxy HNat n)

type ApplyR (FHLookupByHNat l) (Proxy HNat n) = HLookupByHNatR n l

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = ApplyR (FHUProj sel ns) (HList l, Proxy HNat (HSucc n))

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = HJust (e, (HList l, Proxy HNat (HSucc n)))

type ApplyR (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = ApplyR (Proxy Bool (HBoolEQ sel (KMember n ns)), FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type HNats ((:) * (Proxy HNat n) l)

type HNats ((:) * (Proxy HNat n) l) = (:) HNat n (HNats l)

hZero :: Proxy HZero

hSucc :: Proxy (n :: HNat) -> Proxy (HSucc n)

hPred :: Proxy (HSucc n) -> Proxy n

class HNat2Integral (n :: HNat) where

Minimal complete definition

hNat2Integral

Methods

hNat2Integral :: Integral i => Proxy n -> i

Instances

KnownNat (HNat2Nat n) => HNat2Integral n

Methods

hNat2Integral :: Integral i => Proxy HNat n -> i

type family HNat2Nat (n :: HNat) :: Nat

Instances

type HNat2Nat HZero

type HNat2Nat HZero = 0

type HNat2Nat (HSucc n)

type HNat2Nat (HSucc n) = (+) 1 (HNat2Nat n)

class HNats2Integrals (ns :: [HNat]) where

Minimal complete definition

hNats2Integrals

Methods

hNats2Integrals :: Integral i => Proxy ns -> [i]

Instances

HNats2Integrals ([] HNat)

Methods

hNats2Integrals :: Integral i => Proxy [HNat] [HNat] -> [i]

(HNats2Integrals ns, HNat2Integral n) => HNats2Integrals ((:) HNat n ns)

Methods

hNats2Integrals :: Integral i => Proxy [HNat] ((HNat ': n) ns) -> [i]

type family HNatEq (t1 :: HNat) (t2 :: HNat) :: Bool

Equality on natural numbers (eventually to be subsumed by the universal polykinded HEq)

Instances

type HNatEq HZero HZero

type HNatEq HZero HZero = True

type HNatEq HZero (HSucc n)

type HNatEq HZero (HSucc n) = False

type HNatEq (HSucc n) HZero

type HNatEq (HSucc n) HZero = False

type HNatEq (HSucc n) (HSucc n')

type HNatEq (HSucc n) (HSucc n') = HNatEq n n'

type family HLt (x :: HNat) (y :: HNat) :: Bool

Less than

Instances

type HLt HZero HZero

type HLt HZero HZero = False

type HLt HZero (HSucc n)

type HLt HZero (HSucc n) = True

type HLt (HSucc n) HZero

type HLt (HSucc n) HZero = False

type HLt (HSucc n) (HSucc n')

type HLt (HSucc n) (HSucc n') = HLt n n'

hLt :: Proxy x -> Proxy y -> Proxy (HLt x y)

type family HLe (x :: HNat) (y :: HNat) :: Bool

Less than or equal to

Instances

type HLe HZero HZero

type HLe HZero HZero = True

type HLe (HSucc x) y

type HLe (HSucc x) y = HLt x y

hLe :: Proxy x -> Proxy y -> Proxy (HLe x y)

type family HDiv2 (x :: HNat) :: HNat

HDiv2 x behaves like x div 2

Instances

type HDiv2 HZero

type HDiv2 HZero = HZero

type HDiv2 (HSucc HZero)

type HDiv2 (HSucc HZero) = HZero

type HDiv2 (HSucc (HSucc a))

type HDiv2 (HSucc (HSucc a)) = HSucc (HDiv2 a)

Maybies

We cannot use lifted Maybe since the latter are not populated

data HNothing

Constructors

HNothing

Instances

Show HNothing

Methods

showsPrec :: Int -> HNothing -> ShowS

show :: HNothing -> String

showList :: [HNothing] -> ShowS

HUnfoldFD p HNothing ([] *)

Methods

hUnfold' :: p -> HNothing -> HList [*]

FromHJust l => FromHJust ((:) * HNothing l)

Associated Types

type FromHJustR ((* ': HNothing) l :: [*]) :: [*]

Methods

fromHJust :: HList ((* ': HNothing) l) -> HList (FromHJustR ((* ': HNothing) l))

type HUnfoldR p HNothing

type HUnfoldR p HNothing = [] *

type FromHJustR ((:) * HNothing l)

type FromHJustR ((:) * HNothing l) = FromHJustR l

newtype HJust x

Constructors

HJust x

Instances

(Apply p s, HUnfoldFD p (ApplyR p s) z) => HUnfoldFD p (HJust (e, s)) ((:) * e z)

Methods

hUnfold' :: p -> HJust (e, s) -> HList ((* ': e) z)

Show x => Show (HJust x)

Methods

showsPrec :: Int -> HJust x -> ShowS

show :: HJust x -> String

showList :: [HJust x] -> ShowS

(~) * hJustA (HJust a) => ApplyAB (HJust t) a hJustA

HJust () is a placeholder for a function that applies the HJust constructor

Methods

applyAB :: HJust t -> a -> hJustA

FromHJust l => FromHJust ((:) * (HJust e) l)

Associated Types

type FromHJustR ((* ': HJust e) l :: [*]) :: [*]

Methods

fromHJust :: HList ((* ': HJust e) l) -> HList (FromHJustR ((* ': HJust e) l))

type HUnfoldR p (HJust (e, s))

type HUnfoldR p (HJust (e, s)) = (:) * e (HUnfoldR p (ApplyR p s))

type FromHJustR ((:) * (HJust e) l)

type FromHJustR ((:) * (HJust e) l) = (:) * e (FromHJustR l)

Polykinded Equality for types

class HEq (x :: k) (y :: k) (b :: Bool) | x y -> b

We have to use Functional dependencies for now, for the sake of the generic equality.

type HEqK (x :: k1) (y :: k2) (b :: Bool) = HEq (Proxy x) (Proxy y) b

Equality for types that may have different kinds. This definition allows operations on Record [Tagged "x" a, Tagged 2 b] to work as expected.

hEq :: HEq x y b => x -> y -> Proxy b

class HEqByFn f => HEqBy (f :: t) (x :: k) (y :: k) (b :: Bool) | f x y -> b

this class generalizes HEq by allowing the choice of f to allow equating only part of x and y

Instances

(~) Bool ((<=?) x y) b => HEqBy * Nat HLeFn x y b

only in ghc >= 7.7

(HEq Ordering (CmpSymbol x y) GT nb, (~) Bool (HNot nb) b) => HEqBy * Symbol HLeFn x y b

only in ghc >= 7.7

>>> let b1 = Proxy :: HEqBy HLeFn "x" "y" b => Proxy b
>>> :t b1
b1 :: Proxy 'True

>>> let b2 = Proxy :: HEqBy HLeFn "x" "x" b => Proxy b
>>> :t b2
b2 :: Proxy 'True

>>> let b3 = Proxy :: HEqBy HLeFn "y" "x" b => Proxy b
>>> :t b3
b3 :: Proxy 'False

(~) Bool (HLe x y) b => HEqBy * HNat HLeFn x y b

HEqBy k2 k1 f y x b => HEqBy * k1 (HDown k2 f) x y b

(HEqBy k2 k1 le y x b1, (~) Bool (HNot b1) b2) => HEqBy * k1 (HNeq k2 le) x y b2

((~) * txv (Tagged k2 x v), (~) * tyw (Tagged k1 y w), HEq * v w b) => HEqBy * * EqTagValue txv tyw b

HEqBy * k HLeFn x y b => HEqBy * * HLeFn (Proxy k x) (Proxy k y) b

HEqBy * k HLeFn x y b => HEqBy * * HLeFn (Label k x) (Label k y) b

HEqBy * k HLeFn x y b => HEqBy * * HLeFn (Tagged k x v) (Tagged k y w) b

(HEqBy * HNat HLeFn n m b, (~) * ns ns') => HEqBy * * HLeFn (Lbl n ns desc) (Lbl m ns' desc') b

Data.HList.Label3 labels can only be compared if they belong to the same namespace.

class HEqByFn f

Every instance of this class should have an instance of HEqBy

Instances

HEqByFn * HLeFn

HEqByFn * EqTagValue

HEqByFn k a => HEqByFn * (HNeq k a)

HEqByFn k a => HEqByFn * (HDown k a)

Arity

type Arity f n = (ArityFwd f n, ArityRev f n)

class ArityFwd (f :: *) (n :: HNat) | f -> n

calculate the number of arguments a function can take

class ArityRev (f :: *) (n :: HNat)

given the number of arguments a function can take, make sure the function type actually matches

Instances

ArityRev f HZero

((~) * xf (x -> f), ArityRev f n) => ArityRev xf (HSucc n)

Staged equality

Type-safe cast -- no longer need. We use a a ~ b

Cast

class HCast x y where

Named after cast, which behaves the same at runtime. One difference is that there is a HCast instance for every type, while Typeable instances can be missing sometimes.

Minimal complete definition

hCast

Methods

hCast :: x -> Maybe y

Instances

(HEq * x y b, HCast1 b x y) => HCast x y

Methods

hCast :: x -> Maybe y

class HCast1 (b :: Bool) x y where

helper for HCast

Minimal complete definition

hCast1

Methods

hCast1 :: Proxy b -> x -> Maybe y

Instances

HCast1 False x y

Methods

hCast1 :: Proxy Bool False -> x -> Maybe y

(~) * x y => HCast1 True x y

Methods

hCast1 :: Proxy Bool True -> x -> Maybe y

Error messages

class Fail (x :: k)

A class without instances for explicit failure.

Note that with ghc>=8.0, `x :: TypeError` which is formatted properly. Otherwise x is made of nested (left-associated) promoted tuples. For example:

(x ~ '( '( '("the", Int), "is wrong") ) ) :: ((,) Symbol *, Symbol)

Therefore code that works across ghc-7.6 through ghc-8.0 needs to use ErrText, ErrShowType, :<>:, :$$: to construct the type x.

Instances

TypeError Constraint x => Fail ErrorMessage x

type ErrText x = Text x

use the alias ErrText to prevent conflicts with Data.Text

GHC.TypeLits.:<>: and GHC.TypeLits.:$$: are re-exported

type ErrShowType x = ShowType x

Error messages used elsewhere

type FieldNotFound key collection = (ErrText "key" :<>: ErrShowType key) :$$: (ErrText "could not be found in" :<>: ErrShowType collection)

type ExcessFieldFound key collection = (ErrText "found field" :<>: ErrShowType key) :$$: (ErrText "when it should be absent from" :<>: ErrShowType collection)

type HNatIndexTooLarge (nat :: HNat) (r :: [k] -> *) (xs :: [k]) = ((ErrText "0-based index" :<>: ErrShowType (HNat2Nat nat)) :<>: ErrText "is too large for collection") :$$: ErrShowType (r xs)

type ExtraField x = ErrText "extra field" :<>: ErrShowType x

type TypeablePolyK (a :: k) = Typeable a

Constraining Lists

Length

class SameLength' (es1 :: [k]) (es2 :: [m])

Ensure two lists have the same length. We do case analysis on the first one (hence the type must be known to the type checker). In contrast, the second list may be a type variable.

Instances

(~) [m] es2 ([] m) => SameLength' k m ([] k) es2

(SameLength' k m xs ys, (~) [m] es2 ((:) m y ys)) => SameLength' k m ((:) k x xs) es2

class (SameLength' x y, SameLength' y x) => SameLength (x :: [k]) (y :: [m]) where

symmetrical version of SameLength'. Written as a class instead of

type SameLength a b = (SameLength' a b, SameLength' b a)

since ghc expands type synonyms, but not classes (and it seems to have the same result)

Methods

sameLength :: (r x `p` f (q y)) -> r x `p` f (q y)

SameLength x y => Equality (r x) (q y) (r x) (q y)

used like simple, except it restricts the type-level lists involved to have the same length, without fixing the type of container or the elements in the list.

Instances

(SameLength' k m x y, SameLength' m k y x) => SameLength k m x y

Methods

sameLength :: p (r x) (f (q y)) -> p (r x) (f (q y))

asLengthOf :: SameLength x y => r x -> s y -> r x

asTypeOf

type family SameLengths (xs :: [[k]]) :: Constraint

Instances

type SameLengths k ([] [k])

type SameLengths k ([] [k]) = ()

type SameLengths k ((:) [k] x ([] [k]))

type SameLengths k ((:) [k] x ([] [k])) = ()

type SameLengths k ((:) [k] x ((:) [k] y ys))

type SameLengths k ((:) [k] x ((:) [k] y ys)) = (SameLength k k x y, SameLengths k ((:) [k] y ys))

Labels

class SameLabels (x :: k) (y :: m)

Instances

SameLabels * m (Label Symbol t) s => SameLabels Symbol m t s

(~) * (Label k t) (Label Symbol t') => SameLabels * Symbol (Label k t) t'

SameLabels * m (Label k t) s => SameLabels * m (Tagged k t a) s

SameLabels [k1] [k2] ([] k1) ([] k2)

SameLabels [k] [a] ([] k) ((:) a x xs)

(~) * (Label k2 t) (Label k1 t') => SameLabels * * (Label k2 t) (Label k1 t')

(~) * (Label k2 t) (Label k1 t') => SameLabels * * (Label k2 t) (Tagged k1 t' a)

(~) * (Label k t) (Label * (Lbl ix ns n)) => SameLabels * * (Label k t) (Lbl ix ns n)

SameLabels [a] [k] ((:) a x xs) ([] k)

(SameLabels a2 a1 x y, SameLabels [a2] [a1] xs ys) => SameLabels [a2] [a1] ((:) a2 x xs) ((:) a1 y ys)

sameLabels :: SameLabels x y => p (r x) (f (q y)) -> p (r x) (f (q y))

sameLabels constrains the type of an optic, such that the labels (t in Tagged t a) are the same. x or y may have more elements than the other, in which case the elements at the end of the longer list do not have their labels constrained.

see also sameLength

A list has only Tagged values

class HAllTaggedLV (ps :: [*])

The Record, Variant, TIP, TIC type constructors only make sense when they are applied to an instance of this class

Instances

HAllTaggedLV ([] *)

(HAllTaggedLV xs, (~) * x (Tagged k t v)) => HAllTaggedLV ((:) * x xs)

type family ZipTagged (ts :: [k]) (vs :: [*]) :: [*]

see Data.HList.Record.zipTagged

Instances

type ZipTagged k ([] k) ([] *)

type ZipTagged k ([] k) ([] *) = [] *

type ZipTagged Symbol ((:) Symbol t ts) ((:) * v vs)

type ZipTagged Symbol ((:) Symbol t ts) ((:) * v vs) = (:) * (Tagged Symbol t v) (ZipTagged Symbol ts vs)

type ZipTagged * ((:) * (Label k t) ts) ((:) * v vs)

type ZipTagged * ((:) * (Label k t) ts) ((:) * v vs) = (:) * (Tagged k t v) (ZipTagged * ts vs)

type ZipTagged * ((:) * (Lbl ix ns n) ts) ((:) * v vs)

type ZipTagged * ((:) * (Lbl ix ns n) ts) ((:) * v vs) = (:) * (Tagged * (Lbl ix ns n) v) (ZipTagged * ts vs)

re-exports

module Data.Proxy

module Data.Tagged

class Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

• mappend mempty x = x

• mappend x mempty = x

• mappend x (mappend y z) = mappend (mappend x y) z

• mconcat = foldr mappend mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering

Since: 2.1

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid ()

Since: 2.1

Methods

mempty :: ()

mappend :: () -> () -> ()

mconcat :: [()] -> ()

Monoid All

Since: 2.1

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Since: 2.1

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid Doc

Methods

mempty :: Doc

mappend :: Doc -> Doc -> Doc

mconcat :: [Doc] -> Doc

Monoid [a]

Since: 2.1

Methods

mempty :: [a]

mappend :: [a] -> [a] -> [a]

mconcat :: [[a]] -> [a]

Monoid a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there used to be no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Since: 2.1

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (IO a)

Since: 4.9.0.0

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

(Ord a, Bounded a) => Monoid (Min a)

Since: 4.9.0.0

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Ord a, Bounded a) => Monoid (Max a)

Since: 4.9.0.0

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Monoid m => Monoid (WrappedMonoid m)

Since: 4.9.0.0

Methods

mempty :: WrappedMonoid m

mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Semigroup a => Monoid (Option a)

Since: 4.9.0.0

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid a => Monoid (Identity a)

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

Monoid a => Monoid (Dual a)

Since: 2.1

Methods

mempty :: Dual a

mappend :: Dual a -> Dual a -> Dual a

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Since: 2.1

Methods

mempty :: Endo a

mappend :: Endo a -> Endo a -> Endo a

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Sum a)

Since: 2.1

Methods

mempty :: Sum a

mappend :: Sum a -> Sum a -> Sum a

mconcat :: [Sum a] -> Sum a

Num a => Monoid (Product a)

Since: 2.1

Methods

mempty :: Product a

mappend :: Product a -> Product a -> Product a

mconcat :: [Product a] -> Product a

Monoid (First a)

Since: 2.1

Methods

mempty :: First a

mappend :: First a -> First a -> First a

mconcat :: [First a] -> First a

Monoid (Last a)

Since: 2.1

Methods

mempty :: Last a

mappend :: Last a -> Last a -> Last a

mconcat :: [Last a] -> Last a

Monoid (Seq a)

Methods

mempty :: Seq a

mappend :: Seq a -> Seq a -> Seq a

mconcat :: [Seq a] -> Seq a

Monoid (Predicate a)

Methods

mempty :: Predicate a

mappend :: Predicate a -> Predicate a -> Predicate a

mconcat :: [Predicate a] -> Predicate a

Monoid (Comparison a)

Methods

mempty :: Comparison a

mappend :: Comparison a -> Comparison a -> Comparison a

mconcat :: [Comparison a] -> Comparison a

Monoid (Equivalence a)

Methods

mempty :: Equivalence a

mappend :: Equivalence a -> Equivalence a -> Equivalence a

mconcat :: [Equivalence a] -> Equivalence a

Monoid (Doc a)

Methods

mempty :: Doc a

mappend :: Doc a -> Doc a -> Doc a

mconcat :: [Doc a] -> Doc a

(HProxies a, HMapCxt HList ConstMempty (AddProxy [*] a) a, HZip HList a a aa, HMapCxt HList UncurryMappend aa a) => Monoid (HList a)

Analogous to the Monoid instance for tuples

>>> import Data.Monoid
>>> mempty :: HList '[(), All, [Int]]
H[(),All {getAll = True},[]]

>>> mappend (hBuild "a") (hBuild "b") :: HList '[String]
H["ab"]

Methods

mempty :: HList a

mappend :: HList a -> HList a -> HList a

mconcat :: [HList a] -> HList a

Monoid (HList r) => Monoid (Record r)

Methods

mempty :: Record r

mappend :: Record r -> Record r -> Record r

mconcat :: [Record r] -> Record r

(Monoid x, Monoid (Variant ((:) * a b))) => Monoid (Variant ((:) * (Tagged k t x) ((:) * a b)))

Methods

mempty :: Variant ((* ': Tagged k t x) ((* ': a) b))

mappend :: Variant ((* ': Tagged k t x) ((* ': a) b)) -> Variant ((* ': Tagged k t x) ((* ': a) b)) -> Variant ((* ': Tagged k t x) ((* ': a) b))

mconcat :: [Variant ((* ': Tagged k t x) ((* ': a) b))] -> Variant ((* ': Tagged k t x) ((* ': a) b))

(Unvariant ((:) * (Tagged k t x) ([] *)) x, Monoid x) => Monoid (Variant ((:) * (Tagged k t x) ([] *)))

Methods

mempty :: Variant ((* ': Tagged k t x) [*])

mappend :: Variant ((* ': Tagged k t x) [*]) -> Variant ((* ': Tagged k t x) [*]) -> Variant ((* ': Tagged k t x) [*])

mconcat :: [Variant ((* ': Tagged k t x) [*])] -> Variant ((* ': Tagged k t x) [*])

Monoid (HList a) => Monoid (TIP a)

Methods

mempty :: TIP a

mappend :: TIP a -> TIP a -> TIP a

mconcat :: [TIP a] -> TIP a

Monoid (Variant l) => Monoid (TIC l)

Methods

mempty :: TIC l

mappend :: TIC l -> TIC l -> TIC l

mconcat :: [TIC l] -> TIC l

Monoid b => Monoid (a -> b)

Since: 2.1

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

(Monoid a, Monoid b) => Monoid (a, b)

Since: 2.1

Methods

mempty :: (a, b)

mappend :: (a, b) -> (a, b) -> (a, b)

mconcat :: [(a, b)] -> (a, b)

Monoid (Proxy k s)

Since: 4.7.0.0

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

Monoid a => Monoid (Op a b)

Methods

mempty :: Op a b

mappend :: Op a b -> Op a b -> Op a b

mconcat :: [Op a b] -> Op a b

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

Since: 2.1

Methods

mempty :: (a, b, c)

mappend :: (a, b, c) -> (a, b, c) -> (a, b, c)

mconcat :: [(a, b, c)] -> (a, b, c)

Alternative f => Monoid (Alt * f a)

Since: 4.8.0.0

Methods

mempty :: Alt * f a

mappend :: Alt * f a -> Alt * f a -> Alt * f a

mconcat :: [Alt * f a] -> Alt * f a

ArrowPlus p => Monoid (Tambara p a b)

Methods

mempty :: Tambara p a b

mappend :: Tambara p a b -> Tambara p a b -> Tambara p a b

mconcat :: [Tambara p a b] -> Tambara p a b

(Semigroup a, Monoid a) => Monoid (Tagged k s a)

Methods

mempty :: Tagged k s a

mappend :: Tagged k s a -> Tagged k s a -> Tagged k s a

mconcat :: [Tagged k s a] -> Tagged k s a

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)

Since: 2.1

Methods

mempty :: (a, b, c, d)

mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

mconcat :: [(a, b, c, d)] -> (a, b, c, d)

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

Since: 2.1

Methods

mempty :: (a, b, c, d, e)

mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e)

type family Any k0 :: k0 where ...

The type constructor Any is type to which you can unsafely coerce any lifted type, and back. More concretely, for a lifted type t and value x :: t, -- unsafeCoerce (unsafeCoerce x :: Any) :: t is equivalent to x.