Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.HList.FakePrelude

Contents

re-exports

Description

The HList library

Some very basic technology for faking dependent types in Haskell.

Synopsis

data ErrorMessage
- = ErrorMessage :<>: ErrorMessage
- | ErrorMessage :$$: ErrorMessage
type family ZipTagged (ts :: [k]) (vs :: [*]) :: [*]
class HAllTaggedLV (ps :: [*])
class SameLabels (x :: k) (y :: m)
type family SameLengths (xs :: [[k]]) :: Constraint
class (SameLength' x y, SameLength' y x) => SameLength (x :: [k]) (y :: [m]) where
- sameLength :: (r x `p` f (q y)) -> r x `p` f (q y)
class SameLength' (es1 :: [k]) (es2 :: [m])
type TypeablePolyK (a :: k) = Typeable a
type ExtraField x = ErrText "extra field" :<>: ErrShowType x
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 ExcessFieldFound key collection = (ErrText "found field" :<>: ErrShowType key) :$$: (ErrText "when it should be absent from" :<>: ErrShowType collection)
type FieldNotFound key collection = (ErrText "key" :<>: ErrShowType key) :$$: (ErrText "could not be found in" :<>: ErrShowType collection)
type ErrShowType x = ShowType x
type ErrText x = Text x
class Fail (x :: k)
class HCast1 (b :: Bool) x y where
- hCast1 :: Proxy b -> x -> Maybe y
class HCast x y where
- hCast :: x -> Maybe y
class ArityRev (f :: *) (n :: HNat)
class ArityFwd (f :: *) (n :: HNat) | f -> n
type Arity f n = (ArityFwd f n, ArityRev f n)
class HEqByFn f
class HEqByFn f => HEqBy (f :: t) (x :: k) (y :: k) (b :: Bool) | f x y -> b
type HEqK (x :: k1) (y :: k2) (b :: Bool) = HEq (Proxy x) (Proxy y) b
class HEq (x :: k) (y :: k) (b :: Bool) | x y -> b
newtype HJust x = HJust x
data HNothing = HNothing
type family HDiv2 (x :: HNat) :: HNat
type family HLe (x :: HNat) (y :: HNat) :: Bool
type family HLt (x :: HNat) (y :: HNat) :: Bool
type family HNatEq (t1 :: HNat) (t2 :: HNat) :: Bool
class HNats2Integrals (ns :: [HNat]) where
- hNats2Integrals :: Integral i => Proxy ns -> [i]
type family HNat2Nat (n :: HNat) :: Nat
class HNat2Integral (n :: HNat) where
- hNat2Integral :: Integral i => Proxy n -> i
data HNat
- = HZero
- | HSucc HNat
type family HBoolEQ (t1 :: Bool) (t2 :: Bool) :: Bool
class HCond (t :: Bool) x y z | t x y -> z where
- hCond :: Proxy t -> x -> y -> z
class HNotFD (b :: Bool) (nb :: Bool) | b -> nb, nb -> b
type family HNot (x :: Bool) :: Bool
type family HOr (t1 :: Bool) (t2 :: Bool) :: Bool
type family HAnd (t1 :: Bool) (t2 :: Bool) :: Bool
class ShowLabel l where
- showLabel :: Label l -> String
data Label l = Label
data HUntag = HUntag
newtype LiftA2 f = LiftA2 f
newtype HFmap f = HFmap f
data HFlip = HFlip
newtype HSeq x = HSeq x
data Comp = Comp
data HComp g f = HComp g f
data HShow = HShow
data HRead = HRead
data HPrint = HPrint
type family FunCxt (cxts :: k) a :: Constraint
type family FunApp (fns :: k) a
data Fun' (cxt :: k1) (geta :: k2) = Fun' (forall b. FunCxt cxt b => FunApp geta b -> b)
data Fun (cxt :: k1) (getb :: k2) = Fun (forall a. FunCxt cxt a => a -> FunApp getb a)
class ApplyAB f a b where
- applyAB :: f -> a -> b
class Apply f a where
- type ApplyR f a :: *
- apply :: f -> a -> ApplyR f a
labelToProxy :: Label l -> Proxy l
hTrue :: Proxy True
hFalse :: Proxy False
hAnd :: Proxy t1 -> Proxy t2 -> Proxy (HAnd t1 t2)
hOr :: Proxy t1 -> Proxy t2 -> Proxy (HOr t1 t2)
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
sameLabels :: SameLabels x y => p (r x) (f (q y)) -> p (r x) (f (q y))
module Data.Proxy
module Data.Tagged
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
type family Any :: k where ...

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

Instances details

(TypeError x :: Constraint) => Fail (x :: ErrorMessage) Source #
Instance details Defined in Data.HList.FakePrelude

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

see Data.HList.Record.zipTagged

Instances

Instances details

type ZipTagged ('[] :: [k]) ('[] :: [Type]) Source #
Instance details Defined in Data.HList.FakePrelude type ZipTagged ('[] :: [k]) ('[] :: [Type]) = '[] :: [Type]
type ZipTagged (t ': ts :: [Symbol]) (v ': vs) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Data.HList.Label3 type ZipTagged (Lbl ix ns n ': ts :: [Type]) (v ': vs) = Tagged (Lbl ix ns n) v ': ZipTagged ts vs

class HAllTaggedLV (ps :: [*]) Source #

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

Instances

Instances details

HAllTaggedLV ('[] :: [Type]) Source #
Instance details Defined in Data.HList.FakePrelude
(HAllTaggedLV xs, x ~ Tagged t v) => HAllTaggedLV (x ': xs) Source #
Instance details Defined in Data.HList.FakePrelude

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

Instances

Instances details

SameLabels (Label t) s => SameLabels (t :: Symbol) (s :: m) Source #
Instance details Defined in Data.HList.FakePrelude
Label t ~ Label t' => SameLabels (Label t :: Type) (t' :: Symbol) Source #
Instance details Defined in Data.HList.FakePrelude
Label t ~ Label t' => SameLabels (Label t :: Type) (Label t' :: Type) Source #
Instance details Defined in Data.HList.FakePrelude
Label t ~ Label (Lbl ix ns n) => SameLabels (Label t :: Type) (Lbl ix ns n :: Type) Source #
Instance details Defined in Data.HList.Label3
Label t ~ Label t' => SameLabels (Label t :: Type) (Tagged t' a :: Type) Source #
Instance details Defined in Data.HList.FakePrelude
SameLabels (Label t) s => SameLabels (Tagged t a :: Type) (s :: m) Source #
Instance details Defined in Data.HList.FakePrelude
SameLabels ('[] :: [k1]) ('[] :: [k2]) Source #
Instance details Defined in Data.HList.FakePrelude
SameLabels ('[] :: [k]) (x ': xs :: [a]) Source #
Instance details Defined in Data.HList.FakePrelude
SameLabels (x ': xs :: [a]) ('[] :: [k]) Source #
Instance details Defined in Data.HList.FakePrelude
(SameLabels x y, SameLabels xs ys) => SameLabels (x ': xs :: [a1]) (y ': ys :: [a2]) Source #
Instance details Defined in Data.HList.FakePrelude

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

Instances

Instances details

type SameLengths ('[] :: [[k]]) Source #
Instance details Defined in Data.HList.FakePrelude type SameLengths ('[] :: [[k]]) = ()
type SameLengths (x ': (y ': ys) :: [[k]]) Source #
Instance details Defined in Data.HList.FakePrelude type SameLengths (x ': (y ': ys) :: [[k]]) = (SameLength x y, SameLengths (y ': ys))
type SameLengths ('[x] :: [[k]]) Source #
Instance details Defined in Data.HList.FakePrelude type SameLengths ('[x] :: [[k]]) = ()

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

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) Source #

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

Instances details

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

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

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

Instances details

es2 ~ ('[] :: [m]) => SameLength' ('[] :: [k]) (es2 :: [m]) Source #
Instance details Defined in Data.HList.FakePrelude
(SameLength' xs ys, es2 ~ (y ': ys)) => SameLength' (x ': xs :: [k]) (es2 :: [m]) Source #
Instance details Defined in Data.HList.FakePrelude

type TypeablePolyK (a :: k) = Typeable a Source #

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

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

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

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

type ErrShowType x = ShowType x Source #

type ErrText x = Text x Source #

use the alias ErrText to prevent conflicts with Data.Text

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

class Fail (x :: k) Source #

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

Instances details

(TypeError x :: Constraint) => Fail (x :: ErrorMessage) Source #
Instance details Defined in Data.HList.FakePrelude

class HCast1 (b :: Bool) x y where Source #

helper for HCast

Methods

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

Instances

Instances details

HCast1 'False x y Source #
Instance details Defined in Data.HList.FakePrelude Methods hCast1 :: Proxy 'False -> x -> Maybe y Source #
x ~ y => HCast1 'True x y Source #
Instance details Defined in Data.HList.FakePrelude Methods hCast1 :: Proxy 'True -> x -> Maybe y Source #

class HCast x y where Source #

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 Source #

Instances

Instances details

(HEq x y b, HCast1 b x y) => HCast x y Source #
Instance details Defined in Data.HList.FakePrelude Methods hCast :: x -> Maybe y Source #

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

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

Instances

Instances details

ArityRev f 'HZero Source #
Instance details Defined in Data.HList.FakePrelude
(xf ~ (x -> f), ArityRev f n) => ArityRev xf ('HSucc n) Source #
Instance details Defined in Data.HList.FakePrelude

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

calculate the number of arguments a function can take

Instances

Instances details

hZero ~ 'HZero => ArityFwd f hZero Source #
Instance details Defined in Data.HList.TypeEqO
Arity f n => ArityFwd (x -> f) ('HSucc n) Source #
Instance details Defined in Data.HList.TypeEqO

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

class HEqByFn f Source #

Every instance of this class should have an instance of HEqBy

Instances

Instances details

HEqByFn HLeFn Source #
Instance details Defined in Data.HList.HSort
HEqByFn EqTagValue Source #
Instance details Defined in Data.HList.RecordU
HEqByFn a => HEqByFn (HDown a :: Type) Source #
Instance details Defined in Data.HList.HSort
HEqByFn a => HEqByFn (HNeq a :: Type) Source #
Instance details Defined in Data.HList.HSort

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

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

Instances

Instances details

HLe x y ~ b => HEqBy HLeFn (x :: HNat) (y :: HNat) b Source #
Instance details Defined in Data.HList.HSort
(HEq (CmpSymbol x y) 'GT nb, HNot nb ~ b) => HEqBy HLeFn (x :: Symbol) (y :: Symbol) b Source #	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
Instance details Defined in Data.HList.HSort
(txv ~ Tagged x v, tyw ~ Tagged y w, HEq v w b) => HEqBy EqTagValue (txv :: Type) (tyw :: Type) b Source #
Instance details Defined in Data.HList.RecordU
(x <=? y) ~ b => HEqBy HLeFn (x :: k) (y :: k) b Source #	only in ghc >= 7.7
Instance details Defined in Data.HList.HSort
HEqBy HLeFn x y b => HEqBy HLeFn (Label x :: Type) (Label y :: Type) b Source #
Instance details Defined in Data.HList.HSort
HEqBy HLeFn x y b => HEqBy HLeFn (Proxy x :: Type) (Proxy y :: Type) b Source #
Instance details 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 Source #	Data.HList.Label3 labels can only be compared if they belong to the same namespace.
Instance details Defined in Data.HList.HSort
HEqBy HLeFn x y b => HEqBy HLeFn (Tagged x v :: Type) (Tagged y w :: Type) b Source #
Instance details Defined in Data.HList.HSort
HEqBy f y x b => HEqBy (HDown f :: Type) (x :: k2) (y :: k2) b Source #
Instance details Defined in Data.HList.HSort
(HEqBy le y x b1, HNot b1 ~ b2) => HEqBy (HNeq le :: Type) (x :: k2) (y :: k2) b2 Source #
Instance details Defined in Data.HList.HSort

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

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 HEq (x :: k) (y :: k) (b :: Bool) | x y -> b Source #

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

Instances

Instances details

HEq (x :: k) (x :: k) 'True Source #
Instance details Defined in Data.HList.TypeEqO
'False ~ b => HEq (x :: k) (y :: k) b Source #
Instance details Defined in Data.HList.TypeEqO

newtype HJust x Source #

Constructors

HJust x

Instances

Instances details

(Apply p s, HUnfoldFD p (ApplyR p s) z) => HUnfoldFD p (HJust (e, s)) (e ': z) Source #
Instance details Defined in Data.HList.HList Methods hUnfold' :: p -> HJust (e, s) -> HList (e ': z) Source #
Show x => Show (HJust x) Source #
Instance details 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 Source #	`HJust ()` is a placeholder for a function that applies the `HJust` constructor
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HJust t -> a -> hJustA Source #
FromHJust l => FromHJust (HJust e ': l) Source #
Instance details Defined in Data.HList.HList Associated Types type FromHJustR (HJust e ': l) :: [Type] Source # Methods fromHJust :: HList (HJust e ': l) -> HList (FromHJustR (HJust e ': l)) Source #
type HUnfoldR p (HJust (e, s)) Source #
Instance details Defined in Data.HList.HList type HUnfoldR p (HJust (e, s)) = e ': HUnfoldR p (ApplyR p s)
type FromHJustR (HJust e ': l) Source #
Instance details Defined in Data.HList.HList type FromHJustR (HJust e ': l) = e ': FromHJustR l

data HNothing Source #

Constructors

HNothing

Instances

Instances details

Show HNothing Source #
Instance details Defined in Data.HList.FakePrelude Methods showsPrec :: Int -> HNothing -> ShowS # show :: HNothing -> String # showList :: [HNothing] -> ShowS #
HUnfoldFD p HNothing ('[] :: [Type]) Source #
Instance details Defined in Data.HList.HList Methods hUnfold' :: p -> HNothing -> HList '[] Source #
FromHJust l => FromHJust (HNothing ': l) Source #
Instance details Defined in Data.HList.HList Associated Types type FromHJustR (HNothing ': l) :: [Type] Source # Methods fromHJust :: HList (HNothing ': l) -> HList (FromHJustR (HNothing ': l)) Source #
type HUnfoldR p HNothing Source #
Instance details Defined in Data.HList.HList type HUnfoldR p HNothing = '[] :: [Type]
type FromHJustR (HNothing ': l) Source #
Instance details Defined in Data.HList.HList type FromHJustR (HNothing ': l) = FromHJustR l

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

HDiv2 x behaves like x div 2

Instances

Instances details

type HDiv2 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HDiv2 'HZero = 'HZero
type HDiv2 ('HSucc ('HSucc a)) Source #
Instance details Defined in Data.HList.FakePrelude type HDiv2 ('HSucc ('HSucc a)) = 'HSucc (HDiv2 a)
type HDiv2 ('HSucc 'HZero) Source #
Instance details Defined in Data.HList.FakePrelude type HDiv2 ('HSucc 'HZero) = 'HZero

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

Less than or equal to

Instances

Instances details

type HLe 'HZero 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HLe 'HZero 'HZero = 'True
type HLe ('HSucc x) y Source #
Instance details Defined in Data.HList.FakePrelude type HLe ('HSucc x) y = HLt x y

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

Less than

Instances

Instances details

type HLt 'HZero 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HLt 'HZero 'HZero = 'False
type HLt 'HZero ('HSucc n) Source #
Instance details Defined in Data.HList.FakePrelude type HLt 'HZero ('HSucc n) = 'True
type HLt ('HSucc n) 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HLt ('HSucc n) 'HZero = 'False
type HLt ('HSucc n) ('HSucc n') Source #
Instance details Defined in Data.HList.FakePrelude type HLt ('HSucc n) ('HSucc n') = HLt n n'

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

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

Instances

Instances details

type HNatEq 'HZero 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HNatEq 'HZero 'HZero = 'True
type HNatEq 'HZero ('HSucc n) Source #
Instance details Defined in Data.HList.FakePrelude type HNatEq 'HZero ('HSucc n) = 'False
type HNatEq ('HSucc n) 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HNatEq ('HSucc n) 'HZero = 'False
type HNatEq ('HSucc n) ('HSucc n') Source #
Instance details Defined in Data.HList.FakePrelude type HNatEq ('HSucc n) ('HSucc n') = HNatEq n n'

class HNats2Integrals (ns :: [HNat]) where Source #

Methods

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

Instances

Instances details

HNats2Integrals ('[] :: [HNat]) Source #
Instance details Defined in Data.HList.FakePrelude Methods hNats2Integrals :: Integral i => Proxy '[] -> [i] Source #
(HNats2Integrals ns, HNat2Integral n) => HNats2Integrals (n ': ns) Source #
Instance details Defined in Data.HList.FakePrelude Methods hNats2Integrals :: Integral i => Proxy (n ': ns) -> [i] Source #

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

Instances

Instances details

type HNat2Nat 'HZero Source #
Instance details Defined in Data.HList.FakePrelude type HNat2Nat 'HZero = 0
type HNat2Nat ('HSucc n) Source #
Instance details Defined in Data.HList.FakePrelude type HNat2Nat ('HSucc n) = 1 + HNat2Nat n

class HNat2Integral (n :: HNat) where Source #

Methods

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

Instances

Instances details

KnownNat (HNat2Nat n) => HNat2Integral n Source #
Instance details Defined in Data.HList.FakePrelude Methods hNat2Integral :: Integral i => Proxy n -> i Source #

data HNat Source #

The data type to be lifted to the type level

Constructors

HZero
HSucc HNat

Instances

Instances details

xxs ~ ('[] :: [Type]) => HLengthEq1 xxs 'HZero Source #
Instance details Defined in Data.HList.HList
HLe x y ~ b => HEqBy HLeFn (x :: HNat) (y :: HNat) b Source #
Instance details Defined in Data.HList.HSort
(HLengthEq xs n, xxs ~ (x ': xs)) => HLengthEq1 xxs ('HSucc n :: HNat) Source #
Instance details Defined in Data.HList.HList
zero ~ 'HZero => HLengthEq2 ('[] :: [Type]) (zero :: HNat) Source #
Instance details Defined in Data.HList.HList
HFindMany ('[] :: [k]) (r :: [k]) ('[] :: [HNat]) Source #
Instance details Defined in Data.HList.RecordU
(HLengthEq xs n, sn ~ 'HSucc n) => HLengthEq2 (x ': xs) (sn :: HNat) Source #
Instance details Defined in Data.HList.HList
(HFind l r n, HFindMany ls r ns) => HFindMany (l ': ls :: [k]) (r :: [k]) (n ': ns) Source #
Instance details Defined in Data.HList.RecordU
HNats2Integrals ('[] :: [HNat]) Source #
Instance details Defined in Data.HList.FakePrelude Methods hNats2Integrals :: Integral i => Proxy '[] -> [i] Source #
HTypes2HNats ('[] :: [Type]) (l :: [Type]) ('[] :: [HNat]) Source #	And lift to the list of types
Instance details Defined in Data.HList.HTypeIndexed
(HType2HNat e l n, HTypes2HNats es l ns) => HTypes2HNats (e ': es :: [Type]) (l :: [Type]) (n ': ns) Source #
Instance details Defined in Data.HList.HTypeIndexed
HLookupByHNat n l => Apply (FHLookupByHNat l) (Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (FHLookupByHNat l) (Proxy n) Source # Methods apply :: FHLookupByHNat l -> Proxy n -> ApplyR (FHLookupByHNat l) (Proxy n) Source #
HNat2Integral n => Show (Proxy n) Source #
Instance details 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) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: FHUProj sel ns -> (HList (e ': l), Proxy n) -> ApplyR (FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Apply (FHUProj sel ns) (HList l, Proxy ('HSucc n)) => Apply (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: (Proxy 'False, FHUProj sel ns) -> (HList (e ': l), Proxy n) -> ApplyR (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Apply (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: (Proxy 'True, FHUProj sel ns) -> (HList (e ': l), Proxy n) -> ApplyR (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
(HNats2Integrals ns, HNat2Integral n) => HNats2Integrals (n ': ns) Source #
Instance details Defined in Data.HList.FakePrelude Methods hNats2Integrals :: Integral i => Proxy (n ': ns) -> [i] Source #
(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 Source #
Instance details Defined in Data.HList.RecordU Methods hLookupByHNatUS1 :: Proxy ('Left t) -> Proxy n -> RecordU u -> HList us -> le Source #
HLookupByHNatUS t us e => HLookupByHNatUS1 ('Right t :: Either HNat HNat) n u us e Source #
Instance details Defined in Data.HList.RecordU Methods hLookupByHNatUS1 :: Proxy ('Right t) -> Proxy n -> RecordU u -> HList us -> e Source #
type KMember n ('[] :: [HNat]) Source #
Instance details Defined in Data.HList.HArray type KMember n ('[] :: [HNat]) = 'False
type KMember n (n1 ': l) Source #
Instance details Defined in Data.HList.HArray type KMember n (n1 ': l) = HOr (HNatEq n n1) (KMember n l)
type ApplyR (FHLookupByHNat l) (Proxy n) Source #
Instance details Defined in Data.HList.HArray type ApplyR (FHLookupByHNat l) (Proxy n) = HLookupByHNatR n l
type ApplyR (FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Data.HList.HList type HNats (Proxy n ': l) = n ': HNats l

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

Instances

Instances details

type HBoolEQ 'False 'False Source #
Instance details Defined in Data.HList.FakePrelude type HBoolEQ 'False 'False = 'True
type HBoolEQ 'False 'True Source #
Instance details Defined in Data.HList.FakePrelude type HBoolEQ 'False 'True = 'False
type HBoolEQ 'True 'False Source #
Instance details Defined in Data.HList.FakePrelude type HBoolEQ 'True 'False = 'False
type HBoolEQ 'True 'True Source #
Instance details Defined in Data.HList.FakePrelude type HBoolEQ 'True 'True = 'True

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

Methods

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

Instances

Instances details

HCond 'False x y y Source #
Instance details Defined in Data.HList.FakePrelude Methods hCond :: Proxy 'False -> x -> y -> y Source #
HCond 'True x y x Source #
Instance details Defined in Data.HList.FakePrelude Methods hCond :: Proxy 'True -> x -> y -> x Source #

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

as compared with HNot this version is injective

Instances

Instances details

HNotFD 'False 'True Source #
Instance details Defined in Data.HList.FakePrelude
HNotFD 'True 'False Source #
Instance details Defined in Data.HList.FakePrelude

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

Instances

Instances details

type HNot 'False Source #
Instance details Defined in Data.HList.FakePrelude type HNot 'False = 'True
type HNot 'True Source #
Instance details Defined in Data.HList.FakePrelude type HNot 'True = 'False

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

Instances

Instances details

type HOr 'False t Source #
Instance details Defined in Data.HList.FakePrelude type HOr 'False t = t
type HOr 'True t Source #
Instance details Defined in Data.HList.FakePrelude type HOr 'True t = 'True

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

Instances

Instances details

type HAnd 'False t Source #
Instance details Defined in Data.HList.FakePrelude type HAnd 'False t = 'False
type HAnd 'True t Source #
Instance details Defined in Data.HList.FakePrelude type HAnd 'True t = t

class ShowLabel l where Source #

Methods

showLabel :: Label l -> String Source #

Instances

Instances details

KnownNat x => ShowLabel (x :: Nat) Source #
Instance details Defined in Data.HList.Label6 Methods showLabel :: Label x -> String Source #
KnownSymbol x => ShowLabel (x :: Symbol) Source #
Instance details Defined in Data.HList.Label6 Methods showLabel :: Label x -> String Source #
Typeable x => ShowLabel (x :: Type) Source #	Equality on labels Show label
Instance details Defined in Data.HList.Label5 Methods showLabel :: Label x -> String Source #
Show desc => ShowLabel (Lbl x ns desc :: Type) Source #	Equality on labels (descriptions are ignored) Use generic instance Show label
Instance details Defined in Data.HList.Label3 Methods showLabel :: Label (Lbl x ns desc) -> String Source #

data Label l Source #

A special Proxy for record labels, polykinded

Constructors

Label

Instances

Instances details

HEqBy HLeFn x y b => HEqBy HLeFn (Label x :: Type) (Label y :: Type) b Source #
Instance details Defined in Data.HList.HSort
Label t ~ Label t' => SameLabels (Label t :: Type) (t' :: Symbol) Source #
Instance details Defined in Data.HList.FakePrelude
Label t ~ Label t' => SameLabels (Label t :: Type) (Label t' :: Type) Source #
Instance details Defined in Data.HList.FakePrelude
Label t ~ Label (Lbl ix ns n) => SameLabels (Label t :: Type) (Lbl ix ns n :: Type) Source #
Instance details Defined in Data.HList.Label3
Label t ~ Label t' => SameLabels (Label t :: Type) (Tagged t' a :: Type) Source #
Instance details Defined in Data.HList.FakePrelude
(HasField l (Record r) u, HasFieldPath needJust ls u v) => HasFieldPath needJust (Label l ': ls) (Record r) v Source #
Instance details Defined in Data.HList.Dredge Methods hLookupByLabelPath1 :: Proxy needJust -> Label (Label l ': ls) -> Record r -> v Source #
(HasField l (Variant r) (Maybe u), HasFieldPath 'True ls u (Maybe v)) => HasFieldPath needJust (Label l ': ls) (Variant r) (Maybe v) Source #
Instance details Defined in Data.HList.Dredge Methods hLookupByLabelPath1 :: Proxy needJust -> Label (Label l ': ls) -> Variant r -> Maybe v Source #
(lv ~ Tagged l v, HUnzip (Proxy :: [Type] -> Type) ls vs lvs) => HUnzip (Proxy :: [Type] -> Type) (Label l ': ls) (v ': vs) (lv ': lvs) Source #
Instance details Defined in Data.HList.HListPrelude Methods hUnzip :: Proxy (lv ': lvs) -> (Proxy (Label l ': ls), Proxy (v ': vs)) Source #
Show desc => Show (Label (Lbl x ns desc)) Source #
Instance details 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 Source #	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
Instance details Defined in Data.HList.Keyword
HExtend (Label y) (Proxy (x ': xs)) Source #
Instance details Defined in Data.HList.Label6 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label y) (Proxy (x ': xs)) Source #
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label y) (Proxy (x ': xs)) Source #
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label y) (Proxy (x ': xs)) Source #
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label y) (Proxy (x ': xs)) Source #	`>>>` `let labelX = Label :: Label "x"``>>>` `let labelY = Label :: Label "y"``>>>` *`let p = labelX .. labelY .. emptyProxy``>>>` `:t p`*p :: Proxy '["x", "y"]
Instance details Defined in Data.HList.Label6 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label y) (Proxy (x ': xs)) Source #	Mixing two label kinds means we have to include `Label`: `>>>` *`let s = label6 .. label3 .. emptyProxy``>>>` `:t s`*s :: Proxy '[Label "6", Label (Lbl 'HZero () ())]
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label y) (Proxy (x ': xs)) Source # Methods (.*.) :: Label y -> Proxy (x ': xs) -> HExtendR (Label y) (Proxy (x ': xs)) Source #
HExtend (Label (Lbl n ns desc)) (Proxy (x ': xs)) Source #	Mixing two label kinds means we have to include `Label`: `>>>` *`let r = label3 .. label6 .. emptyProxy``>>>` `:t r`*r :: Proxy '[Label (Lbl 'HZero () ()), Label "6"]
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs)) Source # Methods (.*.) :: Label (Lbl n ns desc) -> Proxy (x ': xs) -> HExtendR (Label (Lbl n ns desc)) (Proxy (x ': xs)) Source #
HExtend (Label (Lbl n ns desc)) (Proxy (Lbl n' ns' desc' ': xs)) Source #	If possible, Label is left off: `>>>` *`let q = label3 .. label3 .. emptyProxy``>>>` `:t q`*q :: Proxy '[Lbl 'HZero () (), Lbl 'HZero () ()]
Instance details Defined in Data.HList.Label3 Associated Types type HExtendR (Label (Lbl n ns desc)) (Proxy (Lbl n' ns' desc' ': xs)) Source # Methods (.*.) :: Label (Lbl n ns desc) -> Proxy (Lbl n' ns' desc' ': xs) -> HExtendR (Label (Lbl n ns desc)) (Proxy (Lbl n' ns' desc' ': xs)) Source #
HExtend (Label x) (Proxy ('[] :: [Type])) Source #	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 ~ `
Instance details Defined in Data.HList.HListPrelude Associated Types type HExtendR (Label x) (Proxy '[]) Source # Methods (.*.) :: Label x -> Proxy '[] -> HExtendR (Label x) (Proxy '[]) Source #
EnsureLabel (Label x) (Label x) Source #
Instance details Defined in Data.HList.Labelable Methods toLabel :: Label x -> Label x Source #
EnsureLabel (Proxy x) (Label x) Source #
Instance details Defined in Data.HList.Labelable Methods toLabel :: Proxy x -> Label x Source #
ToSym (a b c) x => EnsureLabel (a b c) (Label x) Source #	get the Label out of a `LabeledTo` (ie. `foobar when using HListPP).
Instance details Defined in Data.HList.Labelable Methods toLabel :: a b c -> Label x Source #
(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 Source #
Instance details Defined in Data.HList.Dredge Methods hLens'Path :: Label (Label x ': xs) -> i -> k2 Source #
type UnLabel (proxy :: a) (Label x ': xs) Source #
Instance details Defined in Data.HList.Record type UnLabel (proxy :: a) (Label x ': xs) = x ': UnLabel proxy xs
type ZipTagged (Label t ': ts :: [Type]) (v ': vs) Source #
Instance details 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)) Source #
Instance details Defined in Data.HList.Label6 type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (y ': (x ': xs))
type HExtendR (Label y) (Proxy (x ': xs)) Source #
Instance details 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)) Source #
Instance details 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)) Source #
Instance details 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)) Source #
Instance details Defined in Data.HList.Label6 type HExtendR (Label y) (Proxy (x ': xs)) = Proxy (y ': (x ': xs))
type HExtendR (Label y) (Proxy (x ': xs)) Source #
Instance details 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)) Source #
Instance details 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)) Source #
Instance details 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])) Source #
Instance details Defined in Data.HList.HListPrelude type HExtendR (Label x) (Proxy ('[] :: [Type])) = Proxy '[x]
type LabelsOf (Label l ': r) Source #
Instance details Defined in Data.HList.Record type LabelsOf (Label l ': r) = Label l ': LabelsOf r

data HUntag Source #

untag

Constructors

HUntag

Instances

Instances details

Tagged t x ~ tx => ApplyAB HUntag tx x Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HUntag -> tx -> x Source #

newtype LiftA2 f Source #

liftA2

Constructors

LiftA2 f

Instances

Instances details

(ApplyAB f (x, y) z, mz ~ m z, mxy ~ (m x, m y), Applicative m) => ApplyAB (LiftA2 f) mxy mz Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: LiftA2 f -> mxy -> mz Source #

newtype HFmap f Source #

fmap

Constructors

HFmap f

Instances

Instances details

(x ~ t a, y ~ t b, Functor t, ApplyAB f a b) => ApplyAB (HFmap f) x y Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HFmap f -> x -> y Source #

data HFlip Source #

flip

Constructors

HFlip

Instances

Instances details

(f1 ~ (a -> b -> c), f2 ~ (b -> a -> c)) => ApplyAB HFlip f1 f2 Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HFlip -> f1 -> f2 Source #

newtype HSeq x Source #

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

Constructors

HSeq x

Instances

Instances details

(Monad m, ApplyAB f x fx, fx ~ m (), pair ~ (x, m ()), ApplyAB f x (m ())) => ApplyAB (HSeq f) pair fx Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HSeq f -> pair -> fx Source #

data Comp Source #

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

Instances details

(y ~ y', fg ~ (x -> y, y' -> z), r ~ (x -> z)) => ApplyAB Comp fg r Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Comp -> fg -> r Source #

data HComp g f Source #

Compose two instances of ApplyAB

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

Constructors

HComp g f

g . f

Instances

Instances details

(ApplyAB f a b, ApplyAB g b c) => ApplyAB (HComp g f) a c Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HComp g f -> a -> c Source #

data HShow Source #

show

Constructors

HShow

Instances

Instances details

(String ~ string, Show a) => ApplyAB HShow a string Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HShow -> a -> string Source #

data HRead Source #

read

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

Constructors

HRead

Instances

Instances details

(String ~ string, Read a) => ApplyAB HRead string a Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HRead -> string -> a Source #

data HPrint Source #

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

Instances details

(io ~ IO (), Show x) => ApplyAB HPrint x io Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HPrint -> x -> io Source #

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

Instances

Instances details

type FunCxt (cxt :: ()) a Source #	should there be so many ways to write no constraint?
Instance details Defined in Data.HList.FakePrelude type FunCxt (cxt :: ()) a = ()
type FunCxt (cxt :: Type) a Source #
Instance details Defined in Data.HList.FakePrelude type FunCxt (cxt :: Type) a = cxt ~ a
type FunCxt ('[] :: [k]) a Source #
Instance details Defined in Data.HList.FakePrelude type FunCxt ('[] :: [k]) a = ()
type FunCxt (x ': xs :: [Type -> Constraint]) a Source #
Instance details Defined in Data.HList.FakePrelude type FunCxt (x ': xs :: [Type -> Constraint]) a = (x a, FunCxt xs a)
type FunCxt (cxt :: Type -> Constraint) a Source #
Instance details Defined in Data.HList.FakePrelude type FunCxt (cxt :: Type -> Constraint) a = cxt a

type family FunApp (fns :: k) a Source #

Instances

Instances details

type FunApp (fn :: ()) a Source #
Instance details Defined in Data.HList.FakePrelude type FunApp (fn :: ()) a = a
type FunApp (fn :: Type) a Source #
Instance details Defined in Data.HList.FakePrelude type FunApp (fn :: Type) a = fn
type FunApp (fn :: Type -> Type) a Source #
Instance details Defined in Data.HList.FakePrelude type FunApp (fn :: Type -> Type) a = fn a

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

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

Instances details

(FunCxt cxt b, FunApp geta b ~ a) => ApplyAB (Fun' cxt geta) a b Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Fun' cxt geta -> a -> b Source #

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

Constructors

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

Instances

Instances details

(FunCxt cxt a, FunApp getb a ~ b) => ApplyAB (Fun cxt getb) a b Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Fun cxt getb -> a -> b Source #

class ApplyAB f a b where Source #

No constraints on result and argument types

Methods

applyAB :: f -> a -> b Source #

Instances

Instances details

(y ~ y', fg ~ (x -> y, y' -> z), r ~ (x -> z)) => ApplyAB Comp fg r Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Comp -> fg -> r Source #
(f1 ~ (a -> b -> c), f2 ~ (b -> a -> c)) => ApplyAB HFlip f1 f2 Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HFlip -> f1 -> f2 Source #
(io ~ IO (), Show x) => ApplyAB HPrint x io Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HPrint -> x -> io Source #
(String ~ string, Read a) => ApplyAB HRead string a Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HRead -> string -> a Source #
(String ~ string, Show a) => ApplyAB HShow a string Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HShow -> a -> string Source #
Tagged t x ~ tx => ApplyAB HUntag tx x Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HUntag -> tx -> x Source #
(x ~ Proxy y, Monoid y) => ApplyAB ConstMempty x y Source #
Instance details Defined in Data.HList.HList Methods applyAB :: ConstMempty -> x -> y Source #
(x ~ (e, HList l), y ~ HList (e ': l)) => ApplyAB FHCons x y Source #
Instance details Defined in Data.HList.HList Methods applyAB :: FHCons -> x -> y Source #
hJustA ~ HJust a => ApplyAB HFromJust hJustA a Source #
Instance details Defined in Data.HList.HList Methods applyAB :: HFromJust -> hJustA -> a Source #
(aa ~ (a, a), Monoid a) => ApplyAB UncurryMappend aa a Source #
Instance details Defined in Data.HList.HList Methods applyAB :: UncurryMappend -> aa -> a Source #
(aa ~ (a, a), Semigroup a) => ApplyAB UncurrySappend aa a Source #
Instance details Defined in Data.HList.HList Methods applyAB :: UncurrySappend -> aa -> a Source #
(HZip3 a b c, x ~ (HList a, HList b), y ~ HList c) => ApplyAB HZipF x y Source #
Instance details Defined in Data.HList.HZip Methods applyAB :: HZipF -> x -> y Source #
(x ~ Tagged l v, y ~ HList '[Label l, v]) => ApplyAB TaggedToKW x y Source #
Instance details Defined in Data.HList.Keyword Methods applyAB :: TaggedToKW -> x -> y Source #
tx ~ Tagged t x => ApplyAB TaggedFn x tx Source #
Instance details Defined in Data.HList.Record Methods applyAB :: TaggedFn -> x -> tx Source #
(ux ~ RecordU x, hx ~ HList x, RecordUToRecord x) => ApplyAB BoxF ux hx Source #
Instance details Defined in Data.HList.RecordU Methods applyAB :: BoxF -> ux -> hx Source #
(hx ~ HList x, ux ~ RecordU x, RecordToRecordU x) => ApplyAB UnboxF hx ux Source #
Instance details Defined in Data.HList.RecordU Methods applyAB :: UnboxF -> hx -> ux Source #
y ~ Tagged t (Maybe e) => ApplyAB ConstTaggedNothing x y Source #
Instance details Defined in Data.HList.Variant Methods applyAB :: ConstTaggedNothing -> x -> y Source #
(mx ~ Maybe x, my ~ Maybe y, HCast y x) => ApplyAB HCastF mx my Source #
Instance details Defined in Data.HList.Variant Methods applyAB :: HCastF -> mx -> my Source #
(x ~ (Tagged t (Maybe e), [Variant v]), y ~ [Variant (Tagged t e ': v)], MkVariant t e (Tagged t e ': v)) => ApplyAB HMaybiedToVariantFs x y Source #
Instance details Defined in Data.HList.Variant Methods applyAB :: HMaybiedToVariantFs -> x -> y Source #
(ee ~ (e, e), Eq e, bool ~ Bool) => ApplyAB UncurryEq ee bool Source #
Instance details Defined in Data.HList.Variant Methods applyAB :: UncurryEq -> ee -> bool Source #
e' ~ e => ApplyAB HRmTag (e, t) e' Source #
Instance details Defined in Data.HList.HList Methods applyAB :: HRmTag -> (e, t) -> e' Source #
(y ~ ReadP x, Read x) => ApplyAB ReadElement (Proxy x) y Source #
Instance details Defined in Data.HList.HList Methods applyAB :: ReadElement -> Proxy x -> y Source #
(Read v, ShowLabel l, x ~ Tagged l v, ReadP x ~ y) => ApplyAB ReadComponent (Proxy x) y Source #
Instance details Defined in Data.HList.Record Methods applyAB :: ReadComponent -> Proxy x -> y Source #
(Data d, (c (d -> b), d) ~ x, c b ~ y) => ApplyAB (GfoldlK c) x y Source #
Instance details Defined in Data.HList.Data Methods applyAB :: GfoldlK c -> x -> y Source #
(Data b, x ~ (t, c (b -> r)), y ~ c r) => ApplyAB (GunfoldK c) x y Source #
Instance details Defined in Data.HList.Data Methods applyAB :: GunfoldK c -> x -> y Source #
(x ~ t a, y ~ t b, Functor t, ApplyAB f a b) => ApplyAB (HFmap f) x y Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HFmap f -> x -> y Source #
hJustA ~ HJust a => ApplyAB (HJust t) a hJustA Source #	`HJust ()` is a placeholder for a function that applies the `HJust` constructor
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HJust t -> a -> hJustA Source #
(Monad m, ApplyAB f x fx, fx ~ m (), pair ~ (x, m ()), ApplyAB f x (m ())) => ApplyAB (HSeq f) pair fx Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HSeq f -> pair -> fx Source #
(ApplyAB f (x, y) z, mz ~ m z, mxy ~ (m x, m y), Applicative m) => ApplyAB (LiftA2 f) mxy mz Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: LiftA2 f -> mxy -> mz Source #
(hxs ~ HList xs, hxxs ~ HList (x ': xs)) => ApplyAB (FHCons2 x) hxs hxxs Source #
Instance details Defined in Data.HList.HList Methods applyAB :: FHCons2 x -> hxs -> hxxs Source #
et ~ (e, t) => ApplyAB (HAddTag t) e et Source #
Instance details Defined in Data.HList.HList Methods applyAB :: HAddTag t -> e -> et Source #
(HMapCxt r f a b, as ~ r a, bs ~ r b) => ApplyAB (HMap f) as bs Source #
Instance details Defined in Data.HList.HList Methods applyAB :: HMap f -> as -> bs Source #
(HMapCxt HList f a b, as ~ HList a, bs ~ HList b) => ApplyAB (HMapL f) as bs Source #
Instance details Defined in Data.HList.HList Methods applyAB :: HMapL f -> as -> bs Source #
(l ~ [e'], ApplyAB f e e', el ~ (e, l)) => ApplyAB (Mapcar f) el l Source #
Instance details Defined in Data.HList.HList Methods applyAB :: Mapcar f -> el -> l Source #
(HMapCxt Record f x y, rx ~ Record x, ry ~ Record y) => ApplyAB (HMapR f) rx ry Source #
Instance details Defined in Data.HList.Record Methods applyAB :: HMapR f -> rx -> ry Source #
(vx ~ Variant x, vy ~ Variant y, HMapAux Variant (HFmap f) x y, SameLength x y) => ApplyAB (HMapV f) vx vy Source #	apply a function to all values that could be in the variant.
Instance details Defined in Data.HList.Variant Methods applyAB :: HMapV f -> vx -> vy Source #
ApplyAB f e e' => ApplyAB (MapCar f) (e, HList l) (HList (e' ': l)) Source #
Instance details Defined in Data.HList.HList Methods applyAB :: MapCar f -> (e, HList l) -> HList (e' ': l) Source #
(ApplyAB f a b, ApplyAB g b c) => ApplyAB (HComp g f) a c Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: HComp g f -> a -> c Source #
(x' ~ x, y' ~ y) => ApplyAB (x' -> y') x y Source #	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)
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: (x' -> y') -> x -> y Source #
(FunCxt cxt a, FunApp getb a ~ b) => ApplyAB (Fun cxt getb) a b Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Fun cxt getb -> a -> b Source #
(FunCxt cxt b, FunApp geta b ~ a) => ApplyAB (Fun' cxt geta) a b Source #
Instance details Defined in Data.HList.FakePrelude Methods applyAB :: Fun' cxt geta -> a -> b Source #

class Apply f a where Source #

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 :: * Source #

Methods

apply :: f -> a -> ApplyR f a Source #

Instances

Instances details

HLookupByHNat n l => Apply (FHLookupByHNat l) (Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (FHLookupByHNat l) (Proxy n) Source # Methods apply :: FHLookupByHNat l -> Proxy n -> ApplyR (FHLookupByHNat l) (Proxy n) Source #
(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) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: FHUProj sel ns -> (HList (e ': l), Proxy n) -> ApplyR (FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Apply (FHUProj sel ns) (HList ('[] :: [Type]), n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (FHUProj sel ns) (HList '[], n) Source # Methods apply :: FHUProj sel ns -> (HList '[], n) -> ApplyR (FHUProj sel ns) (HList '[], n) Source #
Apply (FHUProj sel ns) (HList l, Proxy ('HSucc n)) => Apply (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: (Proxy 'False, FHUProj sel ns) -> (HList (e ': l), Proxy n) -> ApplyR (Proxy 'False, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Apply (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source #
Instance details Defined in Data.HList.HArray Associated Types type ApplyR (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source # Methods apply :: (Proxy 'True, FHUProj sel ns) -> (HList (e ': l), Proxy n) -> ApplyR (Proxy 'True, FHUProj sel ns) (HList (e ': l), Proxy n) Source #

labelToProxy :: Label l -> Proxy l Source #

hTrue :: Proxy True Source #

hFalse :: Proxy False Source #

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

demote to values

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

demote to values

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

hZero :: Proxy HZero Source #

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

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

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

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

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

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

asTypeOf

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

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.

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

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

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

Instances details

Monoid All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid ()	Since: base-2.1
Instance details 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) Source #	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"]
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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))) Source #
Instance details 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]) Source #
Instance details 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 (Comparison a)	`mempty` on comparisons always returns `EQ`. Without newtypes this equals `pure (pure EQ)`. mempty :: Comparison a mempty = Comparison _ _ -> EQ
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Comparison a # mappend :: Comparison a -> Comparison a -> Comparison a # mconcat :: [Comparison a] -> Comparison a #
Monoid (Equivalence a)	`mempty` on equivalences always returns `True`. Without newtypes this equals `pure (pure True)`. mempty :: Equivalence a mempty = Equivalence _ _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Equivalence a # mappend :: Equivalence a -> Equivalence a -> Equivalence a # mconcat :: [Equivalence a] -> Equivalence a #
Monoid (Predicate a)	`mempty` on predicates always returns `True`. Without newtypes this equals `pure True`. mempty :: Predicate a mempty = _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Predicate a # mappend :: Predicate a -> Predicate a -> Predicate a # mconcat :: [Predicate a] -> Predicate a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
(Ord a, Bounded a) => Monoid (Max a)	Since: base-4.9.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Monoid p => Monoid (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
Monoid (Seq a)
Instance details 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
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid (Doc a)
Instance details 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
Instance details 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 `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details 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
Instance details Defined in GHC.Base Methods mempty :: (a) # mappend :: (a) -> (a) -> (a) # mconcat :: [(a)] -> (a) #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Op a b)	`mempty @(Op a b)` without newtypes is `mempty @(b->a)` = `_ -> mempty`. mempty :: Op a b mempty = Op _ -> mempty
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Op a b # mappend :: Op a b -> Op a b -> Op a b # mconcat :: [Op a b] -> Op a b #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details 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
Instance details 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
Instance details 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 b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details 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
Instance details 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 #
(Applicative f, Monoid a) => Monoid (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a # mappend :: Ap f a -> Ap f a -> Ap f a # mconcat :: [Ap f a] -> Ap f a #
Alternative f => Monoid (Alt f a)	Since: base-4.8.0.0
Instance details 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
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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.