AST.Knot

Knot is the Kind for nested higher-kinded data.

This library revolves around Knots, which enable encoding many rich recursive structures.

For more information see the README.

Documentation

newtype Knot

A Kind for nested higher-kinded data.

Constructors

Knot (Knot -> Type)

Instances

c (Const a :: Knot -> Type) => Recursively c (Const a :: Knot -> Type)

Defined in AST.Class.Recursive

Methods

recursively :: Proxy (c (Const a)) -> Dict (c (Const a), KNodesConstraint (Const a) (Recursively c))

(InferOf a ~ InferOf b, Infer m a, Infer m b) => Infer m (Sum a b)

Defined in AST.Class.Infer

Methods

inferBody :: Tree (Sum a b) (InferChild m k) -> m (Tree (Sum a b) k, Tree (InferOf (Sum a b)) (UVarOf m))

inferContext :: Proxy m -> Proxy (Sum a b) -> Dict (KNodesConstraint (Sum a b) (Infer m), KNodesConstraint (InferOf (Sum a b)) (Unify m))

KNodes (Const a :: Knot -> Type)

Defined in AST.Class.Nodes

Associated Types

type KNodesConstraint (Const a) c :: Constraint

data KWitness (Const a) a :: Type

Methods

kLiftConstraint :: KNodesConstraint (Const a) c => KWitness (Const a) n -> Proxy c -> (c n -> r) -> r

Monoid a => KPointed (Const a :: Knot -> Type)

Defined in AST.Class.Pointed

Methods

pureK :: (forall (n :: Knot -> Type). KWitness (Const a) n -> Tree p n) -> Tree (Const a) p

KFunctor (Const a :: Knot -> Type)

Defined in AST.Class.Functor

Methods

mapK :: (forall (n :: Knot -> Type). KWitness (Const a) n -> Tree p n -> Tree q n) -> Tree (Const a) p -> Tree (Const a) q

Semigroup a => KApply (Const a :: Knot -> Type)

Defined in AST.Class.Apply

Methods

zipK :: Tree (Const a) p -> Tree (Const a) q -> Tree (Const a) (Product p q)

KFoldable (Const a :: Knot -> Type)

Defined in AST.Class.Foldable

Methods

foldMapK :: Monoid a0 => (forall (n :: Knot -> Type). KWitness (Const a) n -> Tree p n -> a0) -> Tree (Const a) p -> a0

KTraversable (Const a :: Knot -> Type)

Defined in AST.Class.Traversable

Methods

sequenceK :: Applicative f => Tree (Const a) (ContainedK f p) -> f (Tree (Const a) p)

Eq a => ZipMatch (Const a :: Knot -> Type)

Defined in AST.Class.ZipMatch

Methods

zipMatch :: Tree (Const a) p -> Tree (Const a) q -> Maybe (Tree (Const a) (Product p q))

RTraversable (Const a :: Knot -> Type)

Defined in AST.Class.Recursive

Methods

recursiveKTraversable :: Proxy (Const a) -> Dict (KNodesConstraint (Const a) RTraversable)

RNodes (Const a :: Knot -> Type)

Defined in AST.Class.Recursive

Methods

recursiveKNodes :: Proxy (Const a) -> Dict (KNodesConstraint (Const a) RNodes)

(KNodes a, KNodes b) => KNodes (Product a b)

Defined in AST.Class.Nodes

Associated Types

type KNodesConstraint (Product a b) c :: Constraint

data KWitness (Product a b) a :: Type

Methods

kLiftConstraint :: KNodesConstraint (Product a b) c => KWitness (Product a b) n -> Proxy c -> (c n -> r) -> r

(KNodes a, KNodes b) => KNodes (Sum a b)

Defined in AST.Class.Nodes

Associated Types

type KNodesConstraint (Sum a b) c :: Constraint

data KWitness (Sum a b) a :: Type

Methods

kLiftConstraint :: KNodesConstraint (Sum a b) c => KWitness (Sum a b) n -> Proxy c -> (c n -> r) -> r

(KPointed a, KPointed b) => KPointed (Product a b)

Defined in AST.Class.Pointed

Methods

pureK :: (forall (n :: Knot -> Type). KWitness (Product a b) n -> Tree p n) -> Tree (Product a b) p

(KFunctor a, KFunctor b) => KFunctor (Product a b)

Defined in AST.Class.Functor

Methods

mapK :: (forall (n :: Knot -> Type). KWitness (Product a b) n -> Tree p n -> Tree q n) -> Tree (Product a b) p -> Tree (Product a b) q

(KFunctor a, KFunctor b) => KFunctor (Sum a b)

Defined in AST.Class.Functor

Methods

mapK :: (forall (n :: Knot -> Type). KWitness (Sum a b) n -> Tree p n -> Tree q n) -> Tree (Sum a b) p -> Tree (Sum a b) q

(KApply a, KApply b) => KApply (Product a b)

Defined in AST.Class.Apply

Methods

zipK :: Tree (Product a b) p -> Tree (Product a b) q -> Tree (Product a b) (Product p q)

(KFoldable a, KFoldable b) => KFoldable (Product a b)

Defined in AST.Class.Foldable

Methods

foldMapK :: Monoid a0 => (forall (n :: Knot -> Type). KWitness (Product a b) n -> Tree p n -> a0) -> Tree (Product a b) p -> a0

(KFoldable a, KFoldable b) => KFoldable (Sum a b)

Defined in AST.Class.Foldable

Methods

foldMapK :: Monoid a0 => (forall (n :: Knot -> Type). KWitness (Sum a b) n -> Tree p n -> a0) -> Tree (Sum a b) p -> a0

(KTraversable a, KTraversable b) => KTraversable (Product a b)

Defined in AST.Class.Traversable

Methods

sequenceK :: Applicative f => Tree (Product a b) (ContainedK f p) -> f (Tree (Product a b) p)

(KTraversable a, KTraversable b) => KTraversable (Sum a b)

Defined in AST.Class.Traversable

Methods

sequenceK :: Applicative f => Tree (Sum a b) (ContainedK f p) -> f (Tree (Sum a b) p)

(ZipMatch a, ZipMatch b) => ZipMatch (Product a b)

Defined in AST.Class.ZipMatch

Methods

zipMatch :: Tree (Product a b) p -> Tree (Product a b) q -> Maybe (Tree (Product a b) (Product p q))

(ZipMatch a, ZipMatch b) => ZipMatch (Sum a b)

Defined in AST.Class.ZipMatch

Methods

zipMatch :: Tree (Sum a b) p -> Tree (Sum a b) q -> Maybe (Tree (Sum a b) (Product p q))

data KWitness (Const a :: Knot -> Type) i

Defined in AST.Class.Nodes

data KWitness (Const a :: Knot -> Type) i

type KNodesConstraint (Const a :: Knot -> Type) x

Defined in AST.Class.Nodes

type KNodesConstraint (Const a :: Knot -> Type) x = ()

data KWitness (Product a b) n

Defined in AST.Class.Nodes

data KWitness (Product a b) n

• = E_Product_a (KWitness a n)
• | E_Product_b (KWitness b n)

data KWitness (Sum a b) n

Defined in AST.Class.Nodes

data KWitness (Sum a b) n

• = E_Sum_a (KWitness a n)
• | E_Sum_b (KWitness b n)

type InferOf (Sum a b)

Defined in AST.Class.Infer

type InferOf (Sum a b) = InferOf a

type KNodesConstraint (Product a b) x

Defined in AST.Class.Nodes

type KNodesConstraint (Product a b) x = (KNodesConstraint a x, KNodesConstraint b x)

type KNodesConstraint (Sum a b) x

Defined in AST.Class.Nodes

type KNodesConstraint (Sum a b) x = (KNodesConstraint a x, KNodesConstraint b x)

type family GetKnot k where ...

A type-level getter for the type constructor encoded in Knot.

Notes:

• If DataKinds supported lifting field getters this would had been replaced with the type's getter.
• GetKnot is injective, but due to no support for constrained type families, that's not expressible at the moment.
• Because GetKnot can't declared as bijective, uses of it may restrict inference. In those cases wrapping terms with the asTree helper assists Haskell's type inference as if Haskell knew that GetKnot was bijective.

Equations

GetKnot (Knot t) = t

type Tree k p = (k (Knot p) :: Type)

A type synonym to express nested-HKD structures

type (#) k p = Tree (GetKnot k) p

A type synonym to express child nodes in nested-HKDs

asTree :: Tree k p -> Tree k p

An id variant which tells the type checker that its argument is a Tree.

See the notes for GetKnot which expand on why this might be used.

Note that asTree may often be used during development to assist the inference of incomplete code, but removed once the code is complete.