Data.HList.FakePrelude

The HList library

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

Some very basic technology for faking dependent types in Haskell.

Documentation

data ErrorMessage

A description of a custom type error.

Constructors

ErrorMessage :<>: ErrorMessage infixl 6

Put two pieces of error message next to each other.

ErrorMessage :$$: ErrorMessage infixl 5

Stack two pieces of error message on top of each other.

Instances

(TypeError x :: Constraint) => Fail (x :: ErrorMessage)

Defined in Data.HList.FakePrelude

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

Constructors

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

Instances

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

Defined in Data.HList.FakePrelude

Methods

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

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

class HNats2Integrals (ns :: [HNat]) where

Methods

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

Instances

HNats2Integrals ('[] :: [HNat])

Defined in Data.HList.FakePrelude

Methods

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

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

Defined in Data.HList.FakePrelude

Methods

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

type TypeablePolyK (a :: k) = Typeable a

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.

Instances

HEq (x :: k) (x :: k) 'True

Defined in Data.HList.TypeEqO

'False ~ b => HEq (x :: k) (y :: k) b

Defined in Data.HList.TypeEqO

class ShowLabel l where

Methods

showLabel :: Label l -> String

Instances

KnownNat x => ShowLabel (x :: Nat)

Defined in Data.HList.Label6

Methods

showLabel :: Label x -> String

KnownSymbol x => ShowLabel (x :: Symbol)

Defined in Data.HList.Label6

Methods

showLabel :: Label x -> String

Typeable x => ShowLabel (x :: Type)

Equality on labels

Show label

Defined in Data.HList.Label5

Methods

showLabel :: Label x -> String

Show desc => ShowLabel (Lbl x ns desc :: Type)

Equality on labels (descriptions are ignored) Use generic instance

Show label

Defined in Data.HList.Label3

Methods

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

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

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

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 ('[] :: [Type])

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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.

Associated Types

type ApplyR f a :: *

Methods

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

Instances

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

Defined in Data.HList.HArray

Associated Types

type ApplyR (FHLookupByHNat l) (Proxy n)

Methods

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

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

Defined in Data.HList.HArray

Associated Types

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

Methods

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

Apply (FHUProj sel ns) (HList ('[] :: [Type]), n)

Defined in Data.HList.HArray

Associated Types

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

Methods

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

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

Defined in Data.HList.HArray

Associated Types

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

Methods

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

Apply (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n)

Defined in Data.HList.HArray

Associated Types

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

Methods

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

class ApplyAB f a b where

No constraints on result and argument types

Methods

applyAB :: f -> a -> b

Instances

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: Comp -> fg -> r

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HFlip -> f1 -> f2

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HPrint -> x -> io

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HRead -> string -> a

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HShow -> a -> string

Tagged t x ~ tx => ApplyAB HUntag tx x

Defined in Data.HList.FakePrelude

Methods

applyAB :: HUntag -> tx -> x

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

Defined in Data.HList.HList

Methods

applyAB :: ConstMempty -> x -> y

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

Defined in Data.HList.HList

Methods

applyAB :: FHCons -> x -> y

hJustA ~ HJust a => ApplyAB HFromJust hJustA a

Defined in Data.HList.HList

Methods

applyAB :: HFromJust -> hJustA -> a

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

Defined in Data.HList.HList

Methods

applyAB :: UncurryMappend -> aa -> a

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

Defined in Data.HList.HList

Methods

applyAB :: UncurrySappend -> aa -> a

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

Defined in Data.HList.HZip

Methods

applyAB :: HZipF -> x -> y

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

Defined in Data.HList.Keyword

Methods

applyAB :: TaggedToKW -> x -> y

tx ~ Tagged t x => ApplyAB TaggedFn x tx

Defined in Data.HList.Record

Methods

applyAB :: TaggedFn -> x -> tx

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

Defined in Data.HList.RecordU

Methods

applyAB :: BoxF -> ux -> hx

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

Defined in Data.HList.RecordU

Methods

applyAB :: UnboxF -> hx -> ux

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

Defined in Data.HList.Variant

Methods

applyAB :: ConstTaggedNothing -> x -> y

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

Defined in Data.HList.Variant

Methods

applyAB :: HCastF -> mx -> my

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

Defined in Data.HList.Variant

Methods

applyAB :: HMaybiedToVariantFs -> x -> y

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

Defined in Data.HList.Variant

Methods

applyAB :: UncurryEq -> ee -> bool

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

Defined in Data.HList.HList

Methods

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

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

Defined in Data.HList.HList

Methods

applyAB :: ReadElement -> Proxy x -> y

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

Defined in Data.HList.Record

Methods

applyAB :: ReadComponent -> Proxy x -> y

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

Defined in Data.HList.Data

Methods

applyAB :: GfoldlK c -> x -> y

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

Defined in Data.HList.Data

Methods

applyAB :: GunfoldK c -> x -> y

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HFmap f -> x -> y

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

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HJust t -> a -> hJustA

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HSeq f -> pair -> fx

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: LiftA2 f -> mxy -> mz

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

Defined in Data.HList.HList

Methods

applyAB :: FHCons2 x -> hxs -> hxxs

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

Defined in Data.HList.HList

Methods

applyAB :: HAddTag t -> e -> et

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

Defined in Data.HList.HList

Methods

applyAB :: HMap f -> as -> bs

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

Defined in Data.HList.HList

Methods

applyAB :: HMapL f -> as -> bs

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

Defined in Data.HList.HList

Methods

applyAB :: Mapcar f -> el -> l

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

Defined in Data.HList.Record

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.

Defined in Data.HList.Variant

Methods

applyAB :: HMapV f -> vx -> vy

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

Defined in Data.HList.HList

Methods

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

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

Defined in Data.HList.FakePrelude

Methods

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

(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)

Defined in Data.HList.FakePrelude

Methods

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

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

Defined in Data.HList.FakePrelude

Methods

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

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

Defined in Data.HList.FakePrelude

Methods

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

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

Instances

type FunCxt (cxt :: ()) a

should there be so many ways to write no constraint?

Defined in Data.HList.FakePrelude

type FunCxt (cxt :: ()) a = ()

type FunCxt (cxt :: Type) a

Defined in Data.HList.FakePrelude

type FunCxt (cxt :: Type) a = cxt ~ a

type FunCxt ('[] :: [k]) a

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

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

type FunCxt (cxt :: Type -> Constraint) a

Defined in Data.HList.FakePrelude

type FunCxt (cxt :: Type -> Constraint) a = cxt a

type family FunApp (fns :: k) a

Instances

type FunApp (fn :: ()) a

Defined in Data.HList.FakePrelude

type FunApp (fn :: ()) a = a

type FunApp (fn :: Type) a

Defined in Data.HList.FakePrelude

type FunApp (fn :: Type) a = fn

type FunApp (fn :: Type -> Type) a

Defined in Data.HList.FakePrelude

type FunApp (fn :: Type -> Type) a = fn a

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 cxt b, FunApp geta b ~ a) => ApplyAB (Fun' cxt geta) a b

Defined in Data.HList.FakePrelude

Methods

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

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HRead -> string -> a

data HShow

show

Constructors

HShow

Instances

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HSeq f -> pair -> fx

newtype HJust x

Constructors

HJust x

Instances

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

Defined in Data.HList.HList

Methods

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

Show x => Show (HJust x)

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: HJust t -> a -> hJustA

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

Defined in Data.HList.HList

Associated Types

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

Methods

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

type HUnfoldR p (HJust (e, s))

Defined in Data.HList.HList

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

type FromHJustR (HJust e ': l)

Defined in Data.HList.HList

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

data HFlip

flip

Constructors

HFlip

Instances

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

Methods

applyAB :: LiftA2 f -> mxy -> mz

data HUntag

untag

Constructors

HUntag

Instances

Tagged t x ~ tx => ApplyAB HUntag tx x

Defined in Data.HList.FakePrelude

Methods

applyAB :: HUntag -> tx -> x

data Label l

A special Proxy for record labels, polykinded

Constructors

Label

Instances

HEqBy HLeFn x y b => HEqBy HLeFn (Label x :: Type) (Label y :: Type) b

Defined in Data.HList.HSort

Label t ~ Label t' => SameLabels (Label t :: Type) (t' :: Symbol)

Defined in Data.HList.FakePrelude

Label t ~ Label t' => SameLabels (Label t :: Type) (Label t' :: Type)

Defined in Data.HList.FakePrelude

Label t ~ Label (Lbl ix ns n) => SameLabels (Label t :: Type) (Lbl ix ns n :: Type)

Defined in Data.HList.Label3

Label t ~ Label t' => SameLabels (Label t :: Type) (Tagged t' a :: Type)

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.Dredge

Methods

hLookupByLabelPath1 :: Proxy needJust -> Label (Label l ': ls) -> Record r -> v

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

Defined in Data.HList.Dredge

Methods

hLookupByLabelPath1 :: Proxy needJust -> Label (Label l ': ls) -> Variant r -> Maybe v

(lv ~ Tagged l v, HUnzip (Proxy :: [Type] -> Type) ls vs lvs) => HUnzip (Proxy :: [Type] -> Type) (Label l ': ls) (v ': vs) (lv ': lvs)

Defined in Data.HList.HListPrelude

Methods

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

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

Defined in Data.HList.Label3

Methods

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

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

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

IsKeyFN (Label s -> a -> b) 'True

labels that impose no restriction on the type of the (single) argument which follows

>>> let testF (_ :: Label "a") (a :: Int) () = a+1
>>> kw (hBuild testF) (Label :: Label "a") 5 ()
6

Defined in Data.HList.Keyword

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label6

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

>>> let labelX = Label :: Label "x"
>>> let labelY = Label :: Label "y"
>>> let p = labelX .*. labelY .*. emptyProxy
>>> :t p
p :: Proxy '["x", "y"]

Defined in Data.HList.Label6

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label y) (Proxy (x ': xs))

Mixing two label kinds means we have to include Label:

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

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label y) (Proxy (x ': xs))

Methods

(.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs))

HExtend (Label (Lbl n ns desc)) (Proxy (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"]

Defined in Data.HList.Label3

Associated Types

type HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs))

Methods

(.*.) :: Label (Lbl n ns desc) -> Proxy (x ': xs) -> HExtendR (Label (Lbl n ns desc)) (Proxy (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 () ()]

Defined in Data.HList.Label3

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 x) (Proxy ('[] :: [Type]))

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 ~ *

Defined in Data.HList.HListPrelude

Associated Types

type HExtendR (Label x) (Proxy '[])

Methods

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

EnsureLabel (Label x) (Label x)

Defined in Data.HList.Labelable

Methods

toLabel :: Label x -> Label x

EnsureLabel (Proxy x) (Label x)

Defined in Data.HList.Labelable

Methods

toLabel :: Proxy x -> Label x

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

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

Defined in Data.HList.Labelable

Methods

toLabel :: a b c -> Label x

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

Defined in Data.HList.Dredge

Methods

hLens'Path :: Label (Label x ': xs) -> i -> k2

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

Defined in Data.HList.Record

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

type ZipTagged (Label t ': ts :: [Type]) (v ': vs)

Defined in Data.HList.FakePrelude

type ZipTagged (Label t ': ts :: [Type]) (v ': vs) = Tagged t v ': ZipTagged ts vs

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label6

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (y ': (x ': xs))

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (Label y ': MapLabel (x ': xs))

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (Label y ': MapLabel (x ': xs))

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (Label y ': MapLabel (x ': xs))

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label6

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (y ': (x ': xs))

type HExtendR (Label y) (Proxy (x ': xs))

Defined in Data.HList.Label3

type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (Label y ': MapLabel (x ': xs))

type HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs))

Defined in Data.HList.Label3

type HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs)) = Proxy (Label (Lbl n ns desc) ': MapLabel (x ': xs))

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

Defined in Data.HList.Label3

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 x) (Proxy ('[] :: [Type]))

Defined in Data.HList.HListPrelude

type HExtendR (Label x) (Proxy ('[] :: [Type])) = Proxy '[x]

type LabelsOf (Label l ': r)

Defined in Data.HList.Record

type LabelsOf (Label l ': r) = Label l ': LabelsOf r

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

Instances

type HAnd 'False t

Defined in Data.HList.FakePrelude

type HAnd 'False t = 'False

type HAnd 'True t

Defined in Data.HList.FakePrelude

type HAnd 'True t = t

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

Instances

type HOr 'False t

Defined in Data.HList.FakePrelude

type HOr 'False t = t

type HOr 'True t

Defined in Data.HList.FakePrelude

type HOr 'True t = 'True

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

Instances

type HNot 'False

Defined in Data.HList.FakePrelude

type HNot 'False = 'True

type HNot 'True

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

HNotFD 'True 'False

Defined in Data.HList.FakePrelude

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

Methods

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

Instances

HCond 'False x y y

Defined in Data.HList.FakePrelude

Methods

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

HCond 'True x y x

Defined in Data.HList.FakePrelude

Methods

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

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

Instances

type HBoolEQ 'False 'False

Defined in Data.HList.FakePrelude

type HBoolEQ 'False 'False = 'True

type HBoolEQ 'False 'True

Defined in Data.HList.FakePrelude

type HBoolEQ 'False 'True = 'False

type HBoolEQ 'True 'False

Defined in Data.HList.FakePrelude

type HBoolEQ 'True 'False = 'False

type HBoolEQ 'True 'True

Defined in Data.HList.FakePrelude

type HBoolEQ 'True 'True = 'True

data HNat

The data type to be lifted to the type level

Constructors

HZero

HSucc HNat

Instances

xxs ~ ('[] :: [Type]) => HLengthEq1 xxs 'HZero

Defined in Data.HList.HList

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

Defined in Data.HList.HSort

(HLengthEq xs n, xxs ~ (x ': xs)) => HLengthEq1 xxs ('HSucc n :: HNat)

Defined in Data.HList.HList

zero ~ 'HZero => HLengthEq2 ('[] :: [Type]) (zero :: HNat)

Defined in Data.HList.HList

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

Defined in Data.HList.RecordU

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

Defined in Data.HList.HList

(HFind l r n, HFindMany ls r ns) => HFindMany (l ': ls :: [k]) (r :: [k]) (n ': ns)

Defined in Data.HList.RecordU

HNats2Integrals ('[] :: [HNat])

Defined in Data.HList.FakePrelude

Methods

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

HTypes2HNats ('[] :: [Type]) (l :: [Type]) ('[] :: [HNat])

And lift to the list of types

Defined in Data.HList.HTypeIndexed

(HType2HNat e l n, HTypes2HNats es l ns) => HTypes2HNats (e ': es :: [Type]) (l :: [Type]) (n ': ns)

Defined in Data.HList.HTypeIndexed

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

Defined in Data.HList.HArray

Associated Types

type ApplyR (FHLookupByHNat l) (Proxy n)

Methods

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

HNat2Integral n => Show (Proxy n)

Defined in Data.HList.TypeEqO

Methods

showsPrec :: Int -> Proxy n -> ShowS

show :: Proxy n -> String

showList :: [Proxy n] -> ShowS

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

Defined in Data.HList.HArray

Associated Types

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

Methods

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

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

Defined in Data.HList.HArray

Associated Types

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

Methods

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

Apply (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n)

Defined in Data.HList.HArray

Associated Types

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

Methods

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

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

Defined in Data.HList.FakePrelude

Methods

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

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

Defined in Data.HList.RecordU

Methods

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

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

Defined in Data.HList.RecordU

Methods

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

type KMember n ('[] :: [HNat])

Defined in Data.HList.HArray

type KMember n ('[] :: [HNat]) = 'False

type KMember n (n1 ': l)

Defined in Data.HList.HArray

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

type ApplyR (FHLookupByHNat l) (Proxy n)

Defined in Data.HList.HArray

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

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

Defined in Data.HList.HArray

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

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

Defined in Data.HList.HArray

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

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

Defined in Data.HList.HArray

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

type HNats (Proxy n ': l)

Defined in Data.HList.HList

type HNats (Proxy n ': l) = n ': HNats l

class HNat2Integral (n :: HNat) where

Methods

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

Instances

KnownNat (HNat2Nat n) => HNat2Integral n

Defined in Data.HList.FakePrelude

Methods

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

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

Instances

type HNat2Nat 'HZero

Defined in Data.HList.FakePrelude

type HNat2Nat 'HZero = 0

type HNat2Nat ('HSucc n)

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

type HNatEq 'HZero 'HZero = 'True

type HNatEq 'HZero ('HSucc n)

Defined in Data.HList.FakePrelude

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

type HNatEq ('HSucc n) 'HZero

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

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

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

Less than

Instances

type HLt 'HZero 'HZero

Defined in Data.HList.FakePrelude

type HLt 'HZero 'HZero = 'False

type HLt 'HZero ('HSucc n)

Defined in Data.HList.FakePrelude

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

type HLt ('HSucc n) 'HZero

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

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

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

Less than or equal to

Instances

type HLe 'HZero 'HZero

Defined in Data.HList.FakePrelude

type HLe 'HZero 'HZero = 'True

type HLe ('HSucc x) y

Defined in Data.HList.FakePrelude

type HLe ('HSucc x) y = HLt x y

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

HDiv2 x behaves like x div 2

Instances

type HDiv2 'HZero

Defined in Data.HList.FakePrelude

type HDiv2 'HZero = 'HZero

type HDiv2 ('HSucc ('HSucc a))

Defined in Data.HList.FakePrelude

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

type HDiv2 ('HSucc 'HZero)

Defined in Data.HList.FakePrelude

type HDiv2 ('HSucc 'HZero) = 'HZero

data HNothing

Constructors

HNothing

Instances

Show HNothing

Defined in Data.HList.FakePrelude

Methods

showsPrec :: Int -> HNothing -> ShowS

show :: HNothing -> String

showList :: [HNothing] -> ShowS

HUnfoldFD p HNothing ('[] :: [Type])

Defined in Data.HList.HList

Methods

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

FromHJust l => FromHJust (HNothing ': l)

Defined in Data.HList.HList

Associated Types

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

Methods

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

type HUnfoldR p HNothing

Defined in Data.HList.HList

type HUnfoldR p HNothing = '[] :: [Type]

type FromHJustR (HNothing ': l)

Defined in Data.HList.HList

type FromHJustR (HNothing ': l) = FromHJustR l

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.

class HEqByFn f

Every instance of this class should have an instance of HEqBy

Instances

HEqByFn HLeFn

Defined in Data.HList.HSort

HEqByFn EqTagValue

Defined in Data.HList.RecordU

HEqByFn a => HEqByFn (HDown a :: Type)

Defined in Data.HList.HSort

HEqByFn a => HEqByFn (HNeq a :: Type)

Defined in Data.HList.HSort

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

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

Defined in Data.HList.HSort

(HEq (CmpSymbol x y) 'GT nb, HNot nb ~ b) => HEqBy HLeFn (x :: Symbol) (y :: Symbol) 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

Defined in Data.HList.HSort

(txv ~ Tagged x v, tyw ~ Tagged y w, HEq v w b) => HEqBy EqTagValue (txv :: Type) (tyw :: Type) b

Defined in Data.HList.RecordU

(x <=? y) ~ b => HEqBy HLeFn (x :: k) (y :: k) b

only in ghc >= 7.7

Defined in Data.HList.HSort

HEqBy HLeFn x y b => HEqBy HLeFn (Label x :: Type) (Label y :: Type) b

Defined in Data.HList.HSort

HEqBy HLeFn x y b => HEqBy HLeFn (Proxy x :: Type) (Proxy y :: Type) b

Defined in Data.HList.HSort

(HEqBy HLeFn n m b, ns ~ ns') => HEqBy HLeFn (Lbl n ns desc :: Type) (Lbl m ns' desc' :: Type) b

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

Defined in Data.HList.HSort

HEqBy HLeFn x y b => HEqBy HLeFn (Tagged x v :: Type) (Tagged y w :: Type) b

Defined in Data.HList.HSort

HEqBy f y x b => HEqBy (HDown f :: Type) (x :: k2) (y :: k2) b

Defined in Data.HList.HSort

(HEqBy le y x b1, HNot b1 ~ b2) => HEqBy (HNeq le :: Type) (x :: k2) (y :: k2) b2

Defined in Data.HList.HSort

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

calculate the number of arguments a function can take

Instances

hZero ~ 'HZero => ArityFwd f hZero

Defined in Data.HList.TypeEqO

Arity f n => ArityFwd (x -> f) ('HSucc n)

Defined in Data.HList.TypeEqO

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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.

Methods

hCast :: x -> Maybe y

Instances

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

Defined in Data.HList.FakePrelude

Methods

hCast :: x -> Maybe y

class HCast1 (b :: Bool) x y where

helper for HCast

Methods

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

Instances

HCast1 'False x y

Defined in Data.HList.FakePrelude

Methods

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

x ~ y => HCast1 'True x y

Defined in Data.HList.FakePrelude

Methods

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

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 x :: Constraint) => Fail (x :: ErrorMessage)

Defined in Data.HList.FakePrelude

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

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)

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

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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)

Minimal complete definition

Nothing

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' x y, SameLength' y x) => SameLength (x :: [k]) (y :: [m])

Defined in Data.HList.FakePrelude

Methods

sameLength :: forall {k1} {k2} {k3} p (r :: [k0] -> k1) (f :: k3 -> k2) (q :: [m0] -> k3). p (r x) (f (q y)) -> p (r x) (f (q y))

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

Instances

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

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

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

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

Defined in Data.HList.FakePrelude

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

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

Instances

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

Defined in Data.HList.FakePrelude

Label t ~ Label t' => SameLabels (Label t :: Type) (t' :: Symbol)

Defined in Data.HList.FakePrelude

Label t ~ Label t' => SameLabels (Label t :: Type) (Label t' :: Type)

Defined in Data.HList.FakePrelude

Label t ~ Label (Lbl ix ns n) => SameLabels (Label t :: Type) (Lbl ix ns n :: Type)

Defined in Data.HList.Label3

Label t ~ Label t' => SameLabels (Label t :: Type) (Tagged t' a :: Type)

Defined in Data.HList.FakePrelude

SameLabels (Label t) s => SameLabels (Tagged t a :: Type) (s :: m)

Defined in Data.HList.FakePrelude

SameLabels ('[] :: [k1]) ('[] :: [k2])

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

Defined in Data.HList.FakePrelude

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

see Data.HList.Record.zipTagged

Instances

type ZipTagged ('[] :: [k]) ('[] :: [Type])

Defined in Data.HList.FakePrelude

type ZipTagged ('[] :: [k]) ('[] :: [Type]) = '[] :: [Type]

type ZipTagged (t ': ts :: [Symbol]) (v ': vs)

Defined in Data.HList.FakePrelude

type ZipTagged (t ': ts :: [Symbol]) (v ': vs) = Tagged t v ': ZipTagged ts vs

type ZipTagged (Label t ': ts :: [Type]) (v ': vs)

Defined in Data.HList.FakePrelude

type ZipTagged (Label t ': ts :: [Type]) (v ': vs) = Tagged t v ': ZipTagged ts vs

type ZipTagged (Lbl ix ns n ': ts :: [Type]) (v ': vs)

Defined in Data.HList.Label3

type ZipTagged (Lbl ix ns n ': ts :: [Type]) (v ': vs) = Tagged (Lbl ix ns n) v ': ZipTagged ts vs

labelToProxy :: Label l -> Proxy l

hTrue :: Proxy True

hFalse :: Proxy False

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

demote to values

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

demote to values

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

hZero :: Proxy HZero

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

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

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

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

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

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

asTypeOf

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

re-exports

module Data.Proxy

module Data.Tagged

class Semigroup a => Monoid a where

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

Right identity

x <> mempty = x

Left identity

mempty <> x = x

Associativity

x <> (y <> z) = (x <> y) <> z (Semigroup law)

Concatenation

mconcat = foldr (<>) mempty

You can alternatively define mconcat instead of mempty, in which case the laws are:

Unit

mconcat (pure x) = x

Multiplication

mconcat (join xss) = mconcat (fmap mconcat xss)

Subclass

mconcat (toList xs) = sconcat xs

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.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty | mconcat

Methods

mempty :: a

Identity of mappend

>>> "Hello world" <> mempty
"Hello world"

mappend :: a -> a -> a

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

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.

>>> mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"

Instances

Monoid All

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid Ordering

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

mempty :: Doc

mappend :: Doc -> Doc -> Doc

mconcat :: [Doc] -> Doc

Monoid ()

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: ()

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

mconcat :: [()] -> ()

(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"]

Defined in Data.HList.HList

Methods

mempty :: HList a

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

mconcat :: [HList a] -> HList a

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

Defined in Data.HList.Record

Methods

mempty :: Record r

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

mconcat :: [Record r] -> Record r

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

Defined in Data.HList.TIC

Methods

mempty :: TIC l

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

mconcat :: [TIC l] -> TIC l

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

Defined in Data.HList.TIP

Methods

mempty :: TIP a

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

mconcat :: [TIP a] -> TIP a

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

Defined in Data.HList.Variant

Methods

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

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

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

(Unvariant '[Tagged t x] x, Monoid x) => Monoid (Variant '[Tagged t x])

Defined in Data.HList.Variant

Methods

mempty :: Variant '[Tagged t x]

mappend :: Variant '[Tagged t x] -> Variant '[Tagged t x] -> Variant '[Tagged t x]

mconcat :: [Variant '[Tagged t x]] -> Variant '[Tagged t x]

Monoid a => Monoid (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

mempty :: Identity a

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

mconcat :: [Identity a] -> Identity a

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

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Max a

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

mconcat :: [Max a] -> Max a

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

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Min a

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

mconcat :: [Min a] -> Min a

Monoid m => Monoid (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: WrappedMonoid m

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

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Monoid a => Monoid (Dual a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Dual a

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

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Endo a

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

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Product a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Product a

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

mconcat :: [Product a] -> Product a

Num a => Monoid (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Sum a

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

mconcat :: [Sum a] -> Sum a

(Generic a, Monoid (Rep a ())) => Monoid (Generically a)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

mempty :: Generically a

mappend :: Generically a -> Generically a -> Generically a

mconcat :: [Generically a] -> Generically a

Monoid p => Monoid (Par1 p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: Par1 p

mappend :: Par1 p -> Par1 p -> Par1 p

mconcat :: [Par1 p] -> Par1 p

Monoid (Seq a)

Defined in Data.Sequence.Internal

Methods

mempty :: Seq a

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

mconcat :: [Seq a] -> Seq a

Monoid a => Monoid (IO a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mempty :: IO a

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

mconcat :: [IO a] -> IO a

Monoid (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

mempty :: Doc a

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

mconcat :: [Doc a] -> Doc a

Monoid a => Monoid (Q a)

Since: template-haskell-2.17.0.0

Defined in Language.Haskell.TH.Syntax

Methods

mempty :: Q a

mappend :: Q a -> Q a -> Q a

mconcat :: [Q a] -> Q a

Semigroup 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 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

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

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (a)

Since: base-4.15

Defined in GHC.Base

Methods

mempty :: (a)

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

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

Monoid [a]

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: [a]

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

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

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

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

mconcat :: [Proxy s] -> Proxy s

Monoid (U1 p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: U1 p

mappend :: U1 p -> U1 p -> U1 p

mconcat :: [U1 p] -> U1 p

Monoid a => Monoid (ST s a)

Since: base-4.11.0.0

Defined in GHC.ST

Methods

mempty :: ST s a

mappend :: ST s a -> ST s a -> ST s a

mconcat :: [ST s a] -> ST s a

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

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b)

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

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

Monoid b => Monoid (a -> b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: a -> b

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

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

Monoid a => Monoid (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

mempty :: Const a b

mappend :: Const a b -> Const a b -> Const a b

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

Alternative f => Monoid (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

mempty :: Alt f a

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

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

Monoid (f p) => Monoid (Rec1 f p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: Rec1 f p

mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p

mconcat :: [Rec1 f p] -> Rec1 f p

(Profunctor p, Arrow p, Semigroup b, Monoid b) => Monoid (Closure p a b)

Defined in Data.Profunctor.Closed

Methods

mempty :: Closure p a b

mappend :: Closure p a b -> Closure p a b -> Closure p a b

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

ArrowPlus p => Monoid (Tambara p a b)

Defined in Data.Profunctor.Strong

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 s a)

Defined in Data.Tagged

Methods

mempty :: Tagged s a

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

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

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

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b, c)

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

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

(Monoid (f a), Monoid (g a)) => Monoid (Product f g a)

Since: base-4.16.0.0

Defined in Data.Functor.Product

Methods

mempty :: Product f g a

mappend :: Product f g a -> Product f g a -> Product f g a

mconcat :: [Product f g a] -> Product f g a

(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: (f :*: g) p

mappend :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

mconcat :: [(f :*: g) p] -> (f :*: g) p

Monoid c => Monoid (K1 i c p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: K1 i c p

mappend :: K1 i c p -> K1 i c p -> K1 i c p

mconcat :: [K1 i c p] -> K1 i c p

Monoid r => Monoid (Forget r a b)

Via Monoid r => (a -> r)

Since: profunctors-5.6.2

Defined in Data.Profunctor.Types

Methods

mempty :: Forget r a b

mappend :: Forget r a b -> Forget r a b -> Forget r a b

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

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

Since: base-2.1

Defined in GHC.Base

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 (f (g a)) => Monoid (Compose f g a)

Since: base-4.16.0.0

Defined in Data.Functor.Compose

Methods

mempty :: Compose f g a

mappend :: Compose f g a -> Compose f g a -> Compose f g a

mconcat :: [Compose f g a] -> Compose f g a

Monoid (f (g p)) => Monoid ((f :.: g) p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: (f :.: g) p

mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

mconcat :: [(f :.: g) p] -> (f :.: g) p

Monoid (f p) => Monoid (M1 i c f p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: M1 i c f p

mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p

mconcat :: [M1 i c f p] -> M1 i c f p

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

Since: base-2.1

Defined in GHC.Base

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 :: k 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.