| Safe Haskell | None | 
|---|---|
| Language | Haskell2010 | 
Data.SOP.Dict
Description
Explicit dictionaries.
When working with compound constraints such as constructed
 using All or All2, GHC cannot always prove automatically
 what one would expect to hold.
This module provides a way of explicitly proving conversions between such constraints to GHC. Such conversions still have to be manually applied.
This module remains somewhat experimental. It is therefore not exported via the main module and has to be imported explicitly.
Synopsis
- data Dict (c :: k -> Constraint) (a :: k) where- Dict :: forall {k} (c :: k -> Constraint) (a :: k). c a => Dict c a
 
- pureAll :: forall {k} (xs :: [k]). SListI xs => Dict (All (Top :: k -> Constraint)) xs
- pureAll2 :: forall {k} (xss :: [[k]]). All (SListI :: [k] -> Constraint) xss => Dict (All2 (Top :: k -> Constraint)) xss
- mapAll :: forall {k} (c :: k -> Constraint) (d :: k -> Constraint) (xs :: [k]). (forall (a :: k). Dict c a -> Dict d a) -> Dict (All c) xs -> Dict (All d) xs
- mapAll2 :: forall {k} (c :: k -> Constraint) (d :: k -> Constraint) (xss :: [[k]]). (forall (a :: k). Dict c a -> Dict d a) -> Dict (All2 c) xss -> Dict (All2 d) xss
- zipAll :: forall {k} (c :: k -> Constraint) (xs :: [k]) (d :: k -> Constraint). Dict (All c) xs -> Dict (All d) xs -> Dict (All (And c d)) xs
- zipAll2 :: forall {k} (xss :: [[k]]) (c :: k -> Constraint) (d :: k -> Constraint). All (SListI :: [k] -> Constraint) xss => Dict (All2 c) xss -> Dict (All2 d) xss -> Dict (All2 (And c d)) xss
- unAll_NP :: forall {k} (c :: k -> Constraint) (xs :: [k]). Dict (All c) xs -> NP (Dict c) xs
- unAll_POP :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All2 c) xss -> POP (Dict c) xss
- all_NP :: forall {k} (c :: k -> Constraint) (xs :: [k]). NP (Dict c) xs -> Dict (All c) xs
- all_POP :: forall {k} (xss :: [[k]]) (c :: k -> Constraint). SListI xss => POP (Dict c) xss -> Dict (All2 c) xss
- unAll2 :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All2 c) xss -> Dict (All (All c)) xss
- all2 :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All (All c)) xss -> Dict (All2 c) xss
- withDict :: forall {k} c (a :: k) r. Dict c a -> (c a => r) -> r
- hdicts :: forall {k} {l} h (c :: k -> Constraint) (xs :: l). (AllN h c xs, HPure h) => h (Dict c) xs
Documentation
data Dict (c :: k -> Constraint) (a :: k) where #
An explicit dictionary carrying evidence of a class constraint.
The constraint parameter is separated into a
 second argument so that Dict cNP.
Since: 0.2
Constructors
| Dict :: forall {k} (c :: k -> Constraint) (a :: k). c a => Dict c a | 
pureAll :: forall {k} (xs :: [k]). SListI xs => Dict (All (Top :: k -> Constraint)) xs #
A proof that the trivial constraint holds over all type-level lists.
Since: 0.2
pureAll2 :: forall {k} (xss :: [[k]]). All (SListI :: [k] -> Constraint) xss => Dict (All2 (Top :: k -> Constraint)) xss #
A proof that the trivial constraint holds over all type-level lists of lists.
Since: 0.2
mapAll :: forall {k} (c :: k -> Constraint) (d :: k -> Constraint) (xs :: [k]). (forall (a :: k). Dict c a -> Dict d a) -> Dict (All c) xs -> Dict (All d) xs #
Lifts a dictionary conversion over a type-level list.
Since: 0.2
mapAll2 :: forall {k} (c :: k -> Constraint) (d :: k -> Constraint) (xss :: [[k]]). (forall (a :: k). Dict c a -> Dict d a) -> Dict (All2 c) xss -> Dict (All2 d) xss #
Lifts a dictionary conversion over a type-level list of lists.
Since: 0.2
zipAll :: forall {k} (c :: k -> Constraint) (xs :: [k]) (d :: k -> Constraint). Dict (All c) xs -> Dict (All d) xs -> Dict (All (And c d)) xs #
If two constraints c and d hold over a type-level
 list xs, then the combination of both constraints holds
 over that list.
Since: 0.2
zipAll2 :: forall {k} (xss :: [[k]]) (c :: k -> Constraint) (d :: k -> Constraint). All (SListI :: [k] -> Constraint) xss => Dict (All2 c) xss -> Dict (All2 d) xss -> Dict (All2 (And c d)) xss #
If two constraints c and d hold over a type-level
 list of lists xss, then the combination of both constraints
 holds over that list of lists.
Since: 0.2
unAll_NP :: forall {k} (c :: k -> Constraint) (xs :: [k]). Dict (All c) xs -> NP (Dict c) xs #
If we have a constraint c that holds over a type-level
 list xs, we can create a product containing proofs that
 each individual list element satisfies c.
Since: 0.2
unAll_POP :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All2 c) xss -> POP (Dict c) xss #
If we have a constraint c that holds over a type-level
 list of lists xss, we can create a product of products
 containing proofs that all the inner elements satisfy c.
Since: 0.2
all_NP :: forall {k} (c :: k -> Constraint) (xs :: [k]). NP (Dict c) xs -> Dict (All c) xs #
If we have a product containing proofs that each element
 of xs satisfies c, then All cxs.
Since: 0.2
all_POP :: forall {k} (xss :: [[k]]) (c :: k -> Constraint). SListI xss => POP (Dict c) xss -> Dict (All2 c) xss #
If we have a product of products containing proofs that
 each inner element of xss satisfies c, then All2 cxss.
Since: 0.2
unAll2 :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All2 c) xss -> Dict (All (All c)) xss #
all2 :: forall {k} (c :: k -> Constraint) (xss :: [[k]]). Dict (All (All c)) xss -> Dict (All2 c) xss #