Safe Haskell | None |
---|---|

Language | Haskell98 |

This module implements extensible variants using closed type families.

- data Label (s :: Symbol) = Label
- class KnownSymbol (n :: Symbol)
- type family AllUniqueLabels (r :: Row *) :: Constraint where ...
- type WellBehaved ρ = (Forall ρ Unconstrained1, AllUniqueLabels ρ)
- data Var (r :: Row *)
- data Row a
- type Empty = R '[]
- type (≈) a b = a ~ b
- class (r .! l) ≈ a => HasType l a r
- pattern IsJust :: forall l r. (AllUniqueLabels r, KnownSymbol l) => Label l -> (r .! l) -> Var r
- singleton :: KnownSymbol l => Label l -> a -> Var (l .== a)
- fromLabels :: forall c ρ f. (Alternative f, Forall ρ c, AllUniqueLabels ρ) => (forall l a. (KnownSymbol l, c a) => Label l -> f a) -> f (Var ρ)
- type family (r :: Row *) .\ (l :: Symbol) :: Constraint where ...
- class Lacks (l :: Symbol) (r :: Row *)
- diversify :: forall r' r. AllUniqueLabels (r .+ r') => Var r -> Var (r .+ r')
- type family (l :: Row *) .+ (r :: Row *) :: Row * where ...
- update :: (KnownSymbol l, (r .! l) ≈ a) => Label l -> a -> Var r -> Var r
- focus :: (Applicative f, KnownSymbol l) => Label l -> ((r .! l) -> f a) -> Var r -> f (Var (Modify l a r))
- type family Modify (l :: Symbol) (a :: *) (r :: Row *) :: Row * where ...
- rename :: (KnownSymbol l, KnownSymbol l') => Label l -> Label l' -> Var r -> Var (Rename l l' r)
- type family Rename (l :: Symbol) (l' :: Symbol) (r :: Row *) :: Row * where ...
- 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))
- view :: KnownSymbol l => Label l -> Var r -> Maybe (r .! l)
- restrict :: forall r r'. (WellBehaved r, Subset r r') => Var r' -> Maybe (Var r)
- split :: forall s r. (WellBehaved s, Subset s r) => Var r -> Either (Var s) (Var (r .\\ s))
- type family (r :: Row *) .! (t :: Symbol) :: * where ...
- type family (r :: Row *) .- (s :: Symbol) :: Row * where ...
- type family (l :: Row *) .\\ (r :: Row *) :: Row * where ...
- type (.==) (l :: Symbol) (a :: *) = Extend l a Empty
- type family Map (f :: a -> b) (r :: Row a) :: Row b where ...
- map :: forall c f r. Forall r c => (forall a. c a => a -> f a) -> Var r -> Var (Map f r)
- map' :: forall f r. Forall r Unconstrained1 => (forall a. a -> f a) -> Var r -> Var (Map f r)
- transform :: forall r c f g. Forall r c => (forall a. c a => f a -> g a) -> Var (Map f r) -> Var (Map g r)
- transform' :: forall r f g. Forall r Unconstrained1 => (forall a. f a -> g a) -> Var (Map f r) -> Var (Map g r)
- class Forall (r :: Row *) (c :: * -> Constraint)
- erase :: forall c ρ b. Forall ρ c => (forall a. c a => a -> b) -> Var ρ -> b
- eraseWithLabels :: forall c ρ s b. (Forall ρ c, IsString s) => (forall a. c a => a -> b) -> Var ρ -> (s, b)
- eraseZip :: forall c ρ b. Forall ρ c => (forall a. c a => a -> a -> b) -> Var ρ -> Var ρ -> Maybe b
- sequence :: forall f r. (Forall r Unconstrained1, Applicative f) => Var (Map f r) -> f (Var r)
- compose :: forall (f :: * -> *) g r. Forall r Unconstrained1 => Var (Map f (Map g r)) -> Var (Map (Compose f g) r)
- uncompose :: forall (f :: * -> *) g r. Forall r Unconstrained1 => Var (Map (Compose f g) r) -> Var (Map f (Map g r))
- labels :: forall ρ c s. (IsString s, Forall ρ c) => [s]
- unsafeMakeVar :: forall r l. KnownSymbol l => Label l -> (r .! l) -> Var r
- unsafeInjectFront :: forall l a r. KnownSymbol l => Var (R r) -> Var (R ((l :-> a) ': r))

# Types and constraints

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: 4.7.0.0*

symbolSing

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

Are all of the labels in this Row unique?

AllUniqueLabels (R r) = AllUniqueLabelsR r |

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

A convenient way to provide common, easy constraints

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.

# Construction

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.

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.

singleton :: KnownSymbol l => Label l -> a -> Var (l .== a) Source #

A quick constructor to create a singleton variant.

fromLabels :: forall c ρ f. (Alternative f, Forall ρ c, AllUniqueLabels ρ) => (forall l a. (KnownSymbol l, c a) => Label l -> f a) -> f (Var ρ) Source #

Initialize a variant from a producer function that accepts labels. If this function returns more than one possibility, then one is chosen arbitrarily to be the value in the variant.

## Extension

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

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

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

Alias for `.\`

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

diversify :: forall r' r. AllUniqueLabels (r .+ r') => Var r -> Var (r .+ r') Source #

Make the variant arbitrarily more diverse.

## Modification

update :: (KnownSymbol l, (r .! l) ≈ a) => Label l -> a -> Var r -> Var r Source #

If the variant exists at the given label, update it to the given value. Otherwise, do nothing.

focus :: (Applicative f, KnownSymbol l) => Label l -> ((r .! l) -> f a) -> Var r -> f (Var (Modify l a r)) Source #

If the variant exists at the given label, focus on the value associated with it. Otherwise, do nothing.

type family Modify (l :: Symbol) (a :: *) (r :: Row *) :: Row * where ... Source #

Type level Row modification

rename :: (KnownSymbol l, KnownSymbol l') => Label l -> Label l' -> Var r -> Var (Rename l l' r) Source #

Rename the given label.

type family Rename (l :: Symbol) (l' :: Symbol) (r :: Row *) :: Row * where ... Source #

Type level row renaming

# 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

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

A convenient function for using view patterns when dispatching variants. For example:

myShow :: Var ("y" '::= String :| "x" '::= Int :| Empty) -> String myShow (view x -> Just n) = "Int of "++show n myShow (view y -> Just s) = "String of "++s

restrict :: forall r r'. (WellBehaved r, Subset r r') => Var r' -> Maybe (Var r) Source #

Arbitrary variant restriction. Turn a variant into a subset of itself.

split :: forall s r. (WellBehaved s, Subset s r) => Var r -> Either (Var s) (Var (r .\\ s)) Source #

Split a variant into two sub-variants.

## Types for destruction

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

Type level Row element removal

type family (l :: Row *) .\\ (r :: Row *) :: Row * 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`

.

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

A type level way to create a singleton Row.

# Row operations

## Map

type family Map (f :: a -> b) (r :: Row a) :: Row b where ... Source #

Map a type level function over a Row.

map :: forall c f r. Forall r c => (forall a. c a => a -> f a) -> Var r -> Var (Map f r) Source #

A function to map over a variant given a constraint.

map' :: forall f r. Forall r Unconstrained1 => (forall a. a -> f a) -> Var r -> Var (Map f r) Source #

A function to map over a variant given no constraint.

transform :: forall r c f g. Forall r c => (forall a. c a => f a -> g a) -> Var (Map f r) -> Var (Map g r) Source #

Lifts a natrual transformation over a variant. In other words, it acts as a
variant transformer to convert a variant of `f a`

values to a variant of `g a`

values. If no constraint is needed, instantiate the first type argument with
`Unconstrained1`

.

transform' :: forall r f g. Forall r Unconstrained1 => (forall a. f a -> g a) -> Var (Map f r) -> Var (Map g r) Source #

A form of `transformC`

that doesn't have a constraint on `a`

## Fold

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

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

erase :: forall c ρ b. Forall ρ c => (forall a. c a => a -> b) -> Var ρ -> b Source #

A standard fold

eraseWithLabels :: forall c ρ s b. (Forall ρ c, IsString s) => (forall a. c a => a -> b) -> Var ρ -> (s, b) Source #

A fold with labels

eraseZip :: forall c ρ b. Forall ρ c => (forall a. c a => a -> a -> b) -> Var ρ -> Var ρ -> Maybe b Source #

A fold over two row type structures at once

## Sequence

sequence :: forall f r. (Forall r Unconstrained1, Applicative f) => Var (Map f r) -> f (Var r) Source #

Applicative sequencing over a variant

## Compose

We can easily convert between mapping two functors over the types of a row and mapping the composition of the two functors. The following two functions perform this composition with the gaurantee that:

`>>>`

`compose . uncompose = id`

`>>>`

`uncompose . compose = id`

compose :: forall (f :: * -> *) g r. Forall r Unconstrained1 => Var (Map f (Map g r)) -> Var (Map (Compose f g) r) Source #

Convert from a variant where two functors have been mapped over the types to one where the composition of the two functors is mapped over the types.

uncompose :: forall (f :: * -> *) g r. Forall r Unconstrained1 => Var (Map (Compose f g) r) -> Var (Map f (Map g r)) Source #

Convert from a variant where the composition of two functors have been mapped over the types to one where the two functors are mapped individually one at a time over the types.

## labels

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

Return a list of the labels in a row type.

## UNSAFE operations

unsafeMakeVar :: forall r l. KnownSymbol l => Label l -> (r .! l) -> Var r Source #

An unsafe way to make a Variant. This function does not guarantee that the labels are all unique.

unsafeInjectFront :: forall l a r. KnownSymbol l => Var (R r) -> Var (R ((l :-> a) ': r)) Source #

A helper function for unsafely adding an element to the front of a variant.
This can cause the type of the resulting variant to be malformed, for instance,
if the variant already contains labels that are lexicographically before the
given label. Realistically, this function should only be used when writing
calls to `metamorph`

.