| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Data.Row
Contents
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 Forall (r :: Row k) (c :: k -> Constraint)
- class Switch (v :: Row *) (r :: Row *) x | v x -> r, r x -> v where
- 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 |
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 # | |
| (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 |
| Forall r Eq => Eq (Var r) Source # | |
| (Forall r Eq, Forall r Ord) => Ord (Var r) Source # | |
| Forall r Show => Show (Var r) Source # | |
| GenericVar r => Generic (Var r) Source # | |
| Forall r NFData => NFData (Var r) Source # | |
Defined in Data.Row.Variants | |
| type Rep (Var r) Source # | |
Defined in Data.Row.Variants | |
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 # | |
| (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 |
| (Forall r Bounded, AllUniqueLabels r) => Bounded (Rec r) Source # | |
| Forall r Eq => Eq (Rec r) Source # | |
| (Forall r Eq, Forall r Ord) => Ord (Rec r) Source # | |
| Forall r Show => Show (Rec r) Source # | |
| GenericRec r => Generic (Rec r) Source # | |
| Forall r NFData => NFData (Rec r) Source # | |
Defined in Data.Row.Records | |
| type Rep (Rec r) Source # | |
Defined in Data.Row.Records | |
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.
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.
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 # | |
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?
type family (l :: Row k) .\/ (r :: Row k) where ... infixl 6 Source #
The minimum join of the two rows.
type family (l :: Row k) .\\ (r :: Row k) :: Row k where ... infixl 6 Source #
Type level Row difference. That is, l is the row remaining after
removing any matching elements of .\\ rr from l.
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.
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
Instances
| (KnownSymbol ℓ, c τ, Forall (R ρ) c) => Forall (R ((ℓ :-> τ) ': ρ) :: Row k) (c :: k -> Constraint) Source # | |
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 # | |
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 #
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
Record Construction
type (.==) (l :: Symbol) (a :: k) = Extend l a Empty infix 7 Source #
A type level way to create a singleton Row.
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
(.-) :: KnownSymbol l => Rec r -> Label l -> Rec (r .- l) infixl 6 Source #
Record restriction. Remove the label l from the record.
Query
Union
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
randr'is in the resulting record with the type and value given by the fields inr, - Any label that is only found in
ris 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