Safe Haskell	None
Language	Haskell2010

Data.Row

Contents

Types and constraints
Record Construction
Variant construction
- Expansion
- Destruction
Labels

Description

This module includes a set of common functions for Records and Variants. It includes:

Common constructors, destructors, and querying functions

It specifically excludes:

Functions that have the same name for Records and Variants (e.g. focus, update, fromLabels, etc.)
Common clashes with the standard Prelude or other modules (e.g. map, sequence, zip, Map, etc.)

If these particular functions are needed, they should be brought in qualified from one of the Data.Row.*** modules directly.

Synopsis

data Label (s :: Symbol) = Label
class KnownSymbol (n :: Symbol)
type family AllUniqueLabels (r :: Row k) :: Constraint where ...
type WellBehaved ρ = (Forall ρ Unconstrained1, AllUniqueLabels ρ)
data Var (r :: Row *)
data Rec (r :: Row *)
data Row a
type Empty = R '[]
type (≈) a b = a ~ b
class (r .! l) ≈ a => HasType l a r
class Lacks (l :: Symbol) (r :: Row *)
type family (r :: Row k) .\ (l :: Symbol) :: Constraint where ...
type family (l :: Row k) .+ (r :: Row k) :: Row k where ...
type family (l :: Row k) .\/ (r :: Row k) where ...
type family (l :: Row k) .\\ (r :: Row k) :: Row k where ...
type family (l :: Row k) .// (r :: Row k) where ...
class BiForall (r1 :: Row k1) (r2 :: Row k2) (c :: k1 -> k2 -> Constraint)
class Forall (r :: Row k) (c :: k -> Constraint)
class Switch (v :: Row *) (r :: Row *) x | v x -> r, r x -> v where
- switch :: Var v -> Rec r -> x
- caseon :: Rec r -> Var v -> x
empty :: Rec Empty
type (.==) (l :: Symbol) (a :: k) = Extend l a Empty
(.==) :: KnownSymbol l => Label l -> a -> Rec (l .== a)
pattern (:==) :: forall l a. KnownSymbol l => Label l -> a -> Rec (l .== a)
type family (r :: Row k) .- (s :: Symbol) :: Row k where ...
(.-) :: KnownSymbol l => Rec r -> Label l -> Rec (r .- l)
type family (r :: Row k) .! (t :: Symbol) :: k where ...
(.!) :: KnownSymbol l => Rec r -> Label l -> r .! l
(.+) :: Rec l -> Rec r -> Rec (l .+ r)
type Disjoint l r = (WellBehaved l, WellBehaved r, Subset l (l .+ r), Subset r (l .+ r), ((l .+ r) .\\ l) ≈ r, ((l .+ r) .\\ r) ≈ l)
pattern (:+) :: forall l r. Disjoint l r => Rec l -> Rec r -> Rec (l .+ r)
(.//) :: Rec r -> Rec r' -> Rec (r .// r')
pattern IsJust :: forall l r. (AllUniqueLabels r, KnownSymbol l) => Label l -> (r .! l) -> Var r
diversify :: forall r' r. Var r -> Var (r .\/ r')
impossible :: Var Empty -> a
trial :: KnownSymbol l => Var r -> Label l -> Either (r .! l) (Var (r .- l))
trial' :: KnownSymbol l => Var r -> Label l -> Maybe (r .! l)
multiTrial :: forall x y. (AllUniqueLabels x, Forall (y .\\ x) Unconstrained1) => Var y -> Either (Var x) (Var (y .\\ x))
labels :: forall ρ c s. (IsString s, Forall ρ c) => [s]

Types and constraints

data Label (s :: Symbol) Source #

A label

Constructors

Label

Instances

x ≈ y => IsLabel x (Label y) Source #
Instance details Defined in Data.Row.Internal Methods fromLabel :: Label y #
Eq (Label s) Source #
Instance details Defined in Data.Row.Internal Methods (==) :: Label s -> Label s -> Bool # (/=) :: Label s -> Label s -> Bool #
KnownSymbol s => Show (Label s) Source #
Instance details Defined in Data.Row.Internal Methods showsPrec :: Int -> Label s -> ShowS # show :: Label s -> String # showList :: [Label s] -> ShowS #

class KnownSymbol (n :: Symbol) #

This class gives the string associated with a type-level symbol. There are instances of the class for every concrete literal: "hello", etc.

Since: base-4.7.0.0

Minimal complete definition

symbolSing

type family AllUniqueLabels (r :: Row k) :: Constraint where ... Source #

Are all of the labels in this Row unique?

Equations

AllUniqueLabels (R r) = AllUniqueLabelsR r

type WellBehaved ρ = (Forall ρ Unconstrained1, AllUniqueLabels ρ) Source #

A convenient way to provide common, easy constraints

data Var (r :: Row *) Source #

The variant type.

Instances

(AllUniqueLabels r, KnownSymbol name, (r .! name) ≈ a, r ≈ ((r .- name) .\/ (name .== a))) => AsConstructor' name (Var r) a Source #
Instance details Defined in Data.Row.Variants Methods _Ctor' :: Prism (Var r) (Var r) a a #
(AllUniqueLabels r, AllUniqueLabels r', KnownSymbol name, (r .! name) ≈ a, (r' .! name) ≈ b, r' ≈ ((r .- name) .\/ (name .== b))) => AsConstructor name (Var r) (Var r') a b Source #	Every possibility of a row-types based variant has an `AsConstructor` instance.
Instance details Defined in Data.Row.Variants Methods _Ctor :: Prism (Var r) (Var r') a b #
Forall r Eq => Eq (Var r) Source #
Instance details Defined in Data.Row.Variants Methods (==) :: Var r -> Var r -> Bool # (/=) :: Var r -> Var r -> Bool #
(Forall r Eq, Forall r Ord) => Ord (Var r) Source #
Instance details Defined in Data.Row.Variants Methods compare :: Var r -> Var r -> Ordering # (<) :: Var r -> Var r -> Bool # (<=) :: Var r -> Var r -> Bool # (>) :: Var r -> Var r -> Bool # (>=) :: Var r -> Var r -> Bool # max :: Var r -> Var r -> Var r # min :: Var r -> Var r -> Var r #
Forall r Show => Show (Var r) Source #
Instance details Defined in Data.Row.Variants Methods showsPrec :: Int -> Var r -> ShowS # show :: Var r -> String # showList :: [Var r] -> ShowS #
GenericVar r => Generic (Var r) Source #
Instance details Defined in Data.Row.Variants Associated Types type Rep (Var r) :: Type -> Type # Methods from :: Var r -> Rep (Var r) x # to :: Rep (Var r) x -> Var r #
Forall r NFData => NFData (Var r) Source #
Instance details Defined in Data.Row.Variants Methods rnf :: Var r -> () #
type Rep (Var r) Source #
Instance details Defined in Data.Row.Variants type Rep (Var r)

data Rec (r :: Row *) Source #

A record with row r.

Instances

(KnownSymbol name, (r .! name) ≈ a, r ~ Modify name a r) => HasField' name (Rec r) a Source #
Instance details Defined in Data.Row.Records Methods field' :: Lens (Rec r) (Rec r) a a #
(KnownSymbol name, (r' .! name) ≈ b, (r .! name) ≈ a, r' ~ Modify name b r, r ~ Modify name a r') => HasField name (Rec r) (Rec r') a b Source #	Every field in a row-types based record has a `HasField` instance.
Instance details Defined in Data.Row.Records Methods field :: Lens (Rec r) (Rec r') a b #
(Forall r Bounded, AllUniqueLabels r) => Bounded (Rec r) Source #
Instance details Defined in Data.Row.Records Methods minBound :: Rec r # maxBound :: Rec r #
Forall r Eq => Eq (Rec r) Source #
Instance details Defined in Data.Row.Records Methods (==) :: Rec r -> Rec r -> Bool # (/=) :: Rec r -> Rec r -> Bool #
(Forall r Eq, Forall r Ord) => Ord (Rec r) Source #
Instance details Defined in Data.Row.Records Methods compare :: Rec r -> Rec r -> Ordering # (<) :: Rec r -> Rec r -> Bool # (<=) :: Rec r -> Rec r -> Bool # (>) :: Rec r -> Rec r -> Bool # (>=) :: Rec r -> Rec r -> Bool # max :: Rec r -> Rec r -> Rec r # min :: Rec r -> Rec r -> Rec r #
Forall r Show => Show (Rec r) Source #
Instance details Defined in Data.Row.Records Methods showsPrec :: Int -> Rec r -> ShowS # show :: Rec r -> String # showList :: [Rec r] -> ShowS #
GenericRec r => Generic (Rec r) Source #
Instance details Defined in Data.Row.Records Associated Types type Rep (Rec r) :: Type -> Type # Methods from :: Rec r -> Rep (Rec r) x # to :: Rep (Rec r) x -> Rec r #
Forall r NFData => NFData (Rec r) Source #
Instance details Defined in Data.Row.Records Methods rnf :: Rec r -> () #
type Rep (Rec r) Source #
Instance details Defined in Data.Row.Records type Rep (Rec r)

data Row a Source #

The kind of rows. This type is only used as a datakind. A row is a typelevel entity telling us which symbols are associated with which types.

type Empty = R '[] Source #

Type level version of empty

type (≈) a b = a ~ b infix 4 Source #

A lower fixity operator for type equality

class (r .! l) ≈ a => HasType l a r Source #

Alias for (r .! l) ≈ a. It is a class rather than an alias, so that it can be partially applied.

Instances

(r .! l) ≈ a => HasType l (a :: k) (r :: Row k) Source #
Instance details Defined in Data.Row.Internal

class Lacks (l :: Symbol) (r :: Row *) Source #

Alias for .\. It is a class rather than an alias, so that it can be partially applied.

Instances

r .\ l => Lacks l r Source #
Instance details Defined in Data.Row.Internal

type family (r :: Row k) .\ (l :: Symbol) :: Constraint where ... infixl 4 Source #

Does the row lack (i.e. it does not have) the specified label?

Equations

(R r) .\ l = LacksR l r r

type family (l :: Row k) .+ (r :: Row k) :: Row k where ... infixl 6 Source #

Type level Row append

Equations

(R l) .+ (R r) = R (Merge l r)

type family (l :: Row k) .\/ (r :: Row k) where ... infixl 6 Source #

The minimum join of the two rows.

Equations

(R l) .\/ (R r) = R (MinJoinR l r)

type family (l :: Row k) .\\ (r :: Row k) :: Row k where ... infixl 6 Source #

Type level Row difference. That is, l .\\ r is the row remaining after removing any matching elements of r from l.

Equations

(R l) .\\ (R r) = R (Diff l r)

type family (l :: Row k) .// (r :: Row k) where ... infixl 6 Source #

The overwriting union, where the left row overwrites the types of the right row where the labels overlap.

Equations

(R l) .// (R r) = R (ConstUnionR l r)

class BiForall (r1 :: Row k1) (r2 :: Row k2) (c :: k1 -> k2 -> Constraint) Source #

Any structure over two rows in which the elements of each row satisfy some constraints can be metamorphized into another structure over both of the rows.

Minimal complete definition

biMetamorph, biMetamorph'

Instances

(KnownSymbol ℓ, c τ1 τ2, BiForall (R ρ1) (R ρ2) c) => BiForall (R ((ℓ :-> τ1) ': ρ1) :: Row k1) (R ((ℓ :-> τ2) ': ρ2) :: Row k2) (c :: k1 -> k2 -> Constraint) Source #
Instance details Defined in Data.Row.Internal Methods biMetamorph :: Proxy h -> (f Empty Empty -> g Empty Empty) -> (forall (ℓ0 :: Symbol) (τ10 :: k10) (τ20 :: k20) (ρ10 :: [LT k10]) (ρ20 :: [LT k20]). (KnownSymbol ℓ0, c τ10 τ20) => Label ℓ0 -> f (R ((ℓ0 :-> τ10) ': ρ10)) (R ((ℓ0 :-> τ20) ': ρ20)) -> (h τ10 τ20, f (R ρ10) (R ρ20))) -> (forall (ℓ1 :: Symbol) (τ11 :: k10) (τ21 :: k20) (ρ11 :: [LT k10]) (ρ21 :: [LT k20]). (KnownSymbol ℓ1, c τ11 τ21) => Label ℓ1 -> h τ11 τ21 -> g (R ρ11) (R ρ21) -> g (R ((ℓ1 :-> τ11) ': ρ11)) (R ((ℓ1 :-> τ21) ': ρ21))) -> f (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) -> g (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) Source # biMetamorph' :: Proxy h -> (f Empty Empty -> g Empty Empty) -> (forall (ℓ0 :: Symbol) (τ10 :: k10) (τ20 :: k20) (ρ10 :: [LT k10]) (ρ20 :: [LT k20]). (KnownSymbol ℓ0, c τ10 τ20) => Label ℓ0 -> f (R ((ℓ0 :-> τ10) ': ρ10)) (R ((ℓ0 :-> τ20) ': ρ20)) -> Either (h τ10 τ20) (f (R ρ10) (R ρ20))) -> (forall (ℓ1 :: Symbol) (τ11 :: k10) (τ21 :: k20) (ρ11 :: [LT k10]) (ρ21 :: [LT k20]). (KnownSymbol ℓ1, c τ11 τ21) => Label ℓ1 -> Either (h τ11 τ21) (g (R ρ11) (R ρ21)) -> g (R ((ℓ1 :-> τ11) ': ρ11)) (R ((ℓ1 :-> τ21) ': ρ21))) -> f (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) -> g (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) Source #
BiForall (R ([] :: [LT k1]) :: Row k1) (R ([] :: [LT k2]) :: Row k2) (c1 :: k1 -> k2 -> Constraint) Source #
Instance details Defined in Data.Row.Internal Methods biMetamorph :: Proxy h -> (f Empty Empty -> g Empty Empty) -> (forall (ℓ :: Symbol) (τ1 :: k10) (τ2 :: k20) (ρ1 :: [LT k10]) (ρ2 :: [LT k20]). (KnownSymbol ℓ, c1 τ1 τ2) => Label ℓ -> f (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) -> (h τ1 τ2, f (R ρ1) (R ρ2))) -> (forall (ℓ :: Symbol) (τ1 :: k10) (τ2 :: k20) (ρ1 :: [LT k10]) (ρ2 :: [LT k20]). (KnownSymbol ℓ, c1 τ1 τ2) => Label ℓ -> h τ1 τ2 -> g (R ρ1) (R ρ2) -> g (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2))) -> f (R []) (R []) -> g (R []) (R []) Source # biMetamorph' :: Proxy h -> (f Empty Empty -> g Empty Empty) -> (forall (ℓ :: Symbol) (τ1 :: k10) (τ2 :: k20) (ρ1 :: [LT k10]) (ρ2 :: [LT k20]). (KnownSymbol ℓ, c1 τ1 τ2) => Label ℓ -> f (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2)) -> Either (h τ1 τ2) (f (R ρ1) (R ρ2))) -> (forall (ℓ :: Symbol) (τ1 :: k10) (τ2 :: k20) (ρ1 :: [LT k10]) (ρ2 :: [LT k20]). (KnownSymbol ℓ, c1 τ1 τ2) => Label ℓ -> Either (h τ1 τ2) (g (R ρ1) (R ρ2)) -> g (R ((ℓ :-> τ1) ': ρ1)) (R ((ℓ :-> τ2) ': ρ2))) -> f (R []) (R []) -> g (R []) (R []) Source #

class Forall (r :: Row k) (c :: k -> Constraint) Source #

Any structure over a row in which every element is similarly constrained can be metamorphized into another structure over the same row.

Minimal complete definition

metamorph, metamorph'

Instances

(KnownSymbol ℓ, c τ, Forall (R ρ) c) => Forall (R ((ℓ :-> τ) ': ρ) :: Row k) (c :: k -> Constraint) Source #
Instance details Defined in Data.Row.Internal Methods metamorph :: Proxy h -> (f Empty -> g Empty) -> (forall (ℓ0 :: Symbol) (τ0 :: k0) (ρ0 :: [LT k0]). (KnownSymbol ℓ0, c τ0) => Label ℓ0 -> f (R ((ℓ0 :-> τ0) ': ρ0)) -> (h τ0, f (R ρ0))) -> (forall (ℓ1 :: Symbol) (τ1 :: k0) (ρ1 :: [LT k0]). (KnownSymbol ℓ1, c τ1) => Label ℓ1 -> h τ1 -> g (R ρ1) -> g (R ((ℓ1 :-> τ1) ': ρ1))) -> f (R ((ℓ :-> τ) ': ρ)) -> g (R ((ℓ :-> τ) ': ρ)) Source # metamorph' :: Proxy h -> (f Empty -> g Empty) -> (forall (ℓ0 :: Symbol) (τ0 :: k0) (ρ0 :: [LT k0]). (KnownSymbol ℓ0, c τ0) => Label ℓ0 -> f (R ((ℓ0 :-> τ0) ': ρ0)) -> Either (h τ0) (f (R ρ0))) -> (forall (ℓ1 :: Symbol) (τ1 :: k0) (ρ1 :: [LT k0]). (KnownSymbol ℓ1, c τ1) => Label ℓ1 -> Either (h τ1) (g (R ρ1)) -> g (R ((ℓ1 :-> τ1) ': ρ1))) -> f (R ((ℓ :-> τ) ': ρ)) -> g (R ((ℓ :-> τ) ': ρ)) Source #
Forall (R ([] :: [LT k]) :: Row k) (c :: k -> Constraint) Source #
Instance details Defined in Data.Row.Internal Methods metamorph :: Proxy h -> (f Empty -> g Empty) -> (forall (ℓ :: Symbol) (τ :: k0) (ρ :: [LT k0]). (KnownSymbol ℓ, c τ) => Label ℓ -> f (R ((ℓ :-> τ) ': ρ)) -> (h τ, f (R ρ))) -> (forall (ℓ :: Symbol) (τ :: k0) (ρ :: [LT k0]). (KnownSymbol ℓ, c τ) => Label ℓ -> h τ -> g (R ρ) -> g (R ((ℓ :-> τ) ': ρ))) -> f (R []) -> g (R []) Source # metamorph' :: Proxy h -> (f Empty -> g Empty) -> (forall (ℓ :: Symbol) (τ :: k0) (ρ :: [LT k0]). (KnownSymbol ℓ, c τ) => Label ℓ -> f (R ((ℓ :-> τ) ': ρ)) -> Either (h τ) (f (R ρ))) -> (forall (ℓ :: Symbol) (τ :: k0) (ρ :: [LT k0]). (KnownSymbol ℓ, c τ) => Label ℓ -> Either (h τ) (g (R ρ)) -> g (R ((ℓ :-> τ) ': ρ))) -> f (R []) -> g (R []) Source #

class Switch (v :: Row *) (r :: Row *) x | v x -> r, r x -> v where Source #

A Var and a Rec can combine if their rows line up properly.

Minimal complete definition

switch | caseon

Methods

switch :: Var v -> Rec r -> x Source #

Given a Variant and a Record of functions from each possible value of the variant to a single output type, apply the correct function to the value in the variant.

caseon :: Rec r -> Var v -> x Source #

The same as switch but with the argument order reversed

Instances

(KnownSymbol l, Switch (R v) (R r) b) => Switch (R ((l :-> a) ': v)) (R ((l :-> (a -> b)) ': r)) b Source #
Instance details Defined in Data.Row.Switch Methods switch :: Var (R ((l :-> a) ': v)) -> Rec (R ((l :-> (a -> b)) ': r)) -> b Source # caseon :: Rec (R ((l :-> (a -> b)) ': r)) -> Var (R ((l :-> a) ': v)) -> b Source #
Switch (R ([] :: [LT Type])) (R ([] :: [LT Type])) x Source #
Instance details Defined in Data.Row.Switch Methods switch :: Var (R []) -> Rec (R []) -> x Source # caseon :: Rec (R []) -> Var (R []) -> x Source #

Record Construction

empty :: Rec Empty Source #

The empty record

type (.==) (l :: Symbol) (a :: k) = Extend l a Empty infix 7 Source #

A type level way to create a singleton Row.

(.==) :: KnownSymbol l => Label l -> a -> Rec (l .== a) infix 7 Source #

The singleton record

pattern (:==) :: forall l a. KnownSymbol l => Label l -> a -> Rec (l .== a) infix 7 Source #

A pattern for the singleton record; can be used to both destruct a record when in a pattern position or construct one in an expression position.

Restriction

type family (r :: Row k) .- (s :: Symbol) :: Row k where ... infixl 6 Source #

Type level Row element removal

Equations

(R r) .- l = R (Remove l r)

(.-) :: KnownSymbol l => Rec r -> Label l -> Rec (r .- l) infixl 6 Source #

Record restriction. Remove the label l from the record.

Query

type family (r :: Row k) .! (t :: Symbol) :: k where ... infixl 5 Source #

Type level label fetching

Equations

(R r) .! l = Get l r

(.!) :: KnownSymbol l => Rec r -> Label l -> r .! l Source #

Record selection

Union

(.+) :: Rec l -> Rec r -> Rec (l .+ r) infixl 6 Source #

Record disjoint union (commutative)

type Disjoint l r = (WellBehaved l, WellBehaved r, Subset l (l .+ r), Subset r (l .+ r), ((l .+ r) .\\ l) ≈ r, ((l .+ r) .\\ r) ≈ l) Source #

A type synonym for disjointness.

pattern (:+) :: forall l r. Disjoint l r => Rec l -> Rec r -> Rec (l .+ r) infixl 6 Source #

A pattern version of record union, for use in pattern matching.

(.//) :: Rec r -> Rec r' -> Rec (r .// r') Source #

Record overwrite.

The operation r .// r' creates a new record such that:

Any label that is in both r and r' is in the resulting record with the type and value given by the fields in r,
Any label that is only found in r is in the resulting record.
Any label that is only found in r' is in the resulting record.

This can be thought of as r "overwriting" r'.

Variant construction

pattern IsJust :: forall l r. (AllUniqueLabels r, KnownSymbol l) => Label l -> (r .! l) -> Var r Source #

A pattern for variants; can be used to both destruct a variant when in a pattern position or construct one in an expression position.

Expansion

diversify :: forall r' r. Var r -> Var (r .\/ r') Source #

Make the variant arbitrarily more diverse.

Destruction

impossible :: Var Empty -> a Source #

A Variant with no options is uninhabited.

trial :: KnownSymbol l => Var r -> Label l -> Either (r .! l) (Var (r .- l)) Source #

Convert a variant into either the value at the given label or a variant without that label. This is the basic variant destructor.

trial' :: KnownSymbol l => Var r -> Label l -> Maybe (r .! l) Source #

A version of trial that ignores the leftover variant.

multiTrial :: forall x y. (AllUniqueLabels x, Forall (y .\\ x) Unconstrained1) => Var y -> Either (Var x) (Var (y .\\ x)) Source #

A trial over multiple types

Labels

labels :: forall ρ c s. (IsString s, Forall ρ c) => [s] Source #

Return a list of the labels in a row type.

Key	Shortcut
s	Open this search box
esc	Close this search box
↓,ctrl + j	Move down in search results
↑,ctrl + k	Move up in search results
↵	Go to active search result