Data.Extensible

Contents

• Lookup
• Product
• Sum
• Inclusion/Permutation
• Pattern match
• Monomorphic
• Parameterized

Description

>>> let t = K0 (42 :: Int) <:* K0 "foo" <:* K0 (Just "bar") <:* Nil
>>> t
K0 42 <:* K0 "foo" <:* K0 (Just "bar") <:* Nil
>>> :t t
t :: K0 :* '[Int, [Char], Maybe [Char]]
>>> pluck t :: Int
42

Synopsis

• data Position x xs
• runPosition :: Position x (y : xs) -> Either (x :~: y) (Position x xs)
• type (∈) = Member
• class Member x xs where
  • position :: Position x xs
• data h :* s where
  • Nil :: h :* []
  • Tree :: h x -> (h :* Half xs) -> (h :* Half (Tail xs)) -> h :* (x : xs)
• (<:*) :: forall h x xs. h x -> (h :* xs) -> h :* (x : xs)
• unconsP :: forall h x xs. (h :* (x : xs)) -> (h x, h :* xs)
• hoistP :: (forall x. g x -> h x) -> (g :* xs) -> h :* xs
• outP :: forall h x xs. x ∈ xs => (h :* xs) -> h x
• sector :: forall h x xs f. (Functor f, x ∈ xs) => (h x -> f (h x)) -> (h :* xs) -> f (h :* xs)
• sectorAt :: forall h x xs f. Functor f => Position x xs -> (h x -> f (h x)) -> (h :* xs) -> f (h :* xs)
• class Generate xs where
  • generate :: (forall x. Position x xs -> h x) -> h :* xs
• data h :| s where
  • UnionAt :: Position x xs -> h x -> h :| xs
• (<:|) :: (h x -> r) -> ((h :| xs) -> r) -> (h :| (x : xs)) -> r
• exhaust :: (h :| []) -> r
• inS :: x ∈ xs => h x -> h :| xs
• picked :: forall f h x xs. (x ∈ xs, Applicative f) => (h x -> f (h x)) -> (h :| xs) -> f (h :| xs)
• class Include xs ys where
  • shrink :: (h :* ys) -> h :* xs
  • spread :: (h :| xs) -> h :| ys
• newtype Match h a x = Match {
  • runMatch :: h x -> a
  }
• match :: (Match h a :* xs) -> (h :| xs) -> a
• mapMatch :: (a -> b) -> Match h a x -> Match h b x
• newtype K0 a = K0 {
  • getK0 :: a
  }
• (<%) :: x -> (K0 :* xs) -> K0 :* (x : xs)
• pluck :: x ∈ xs => (K0 :* xs) -> x
• bury :: x ∈ xs => x -> K0 :| xs
• (<%|) :: (x -> r) -> ((K0 :| xs) -> r) -> (K0 :| (x : xs)) -> r
• record :: forall f x xs. (x ∈ xs, Functor f) => (x -> f x) -> (K0 :* xs) -> f (K0 :* xs)
• (<?%) :: (x -> a) -> (Match K0 a :* xs) -> Match K0 a :* (x : xs)
• newtype K1 a f = K1 {
  • getK1 :: f a
  }
• newtype Union fs a = Union {
  • getUnion :: K1 a :| fs
  }
• liftU :: f ∈ fs => f a -> Union fs a
• (<?!) :: (f x -> a) -> (Match (K1 x) a :* xs) -> Match (K1 x) a :* (f : fs)

Lookup

Product

Sum

Inclusion/Permutation

Pattern match

Monomorphic

Parameterized