Hyper.Class.Functor

A variant of Functor for HyperTypes

Documentation

class HNodes h => HFunctor h where

A variant of Functor for HyperTypes

Minimal complete definition

Nothing

Methods

hmap :: (forall n. HWitness h n -> (p # n) -> q # n) -> (h # p) -> h # q

HFunctor variant of fmap

Applied a given mapping for h's nodes (trees along witnesses that they are nodes of h) to result with a new tree, potentially with a different nest type.

default hmap :: (Generic1 h, HFunctor (Rep1 h), HWitnessType h ~ HWitnessType (Rep1 h)) => (forall n. HWitness h n -> (p # n) -> q # n) -> (h # p) -> h # q

Instances

HFunctor Prune

Defined in Hyper.Type.Prune

Methods

hmap :: (forall (n :: HyperType). HWitness Prune n -> (p # n) -> q # n) -> (Prune # p) -> Prune # q

HFunctor Pure

Defined in Hyper.Type.Pure

Methods

hmap :: (forall (n :: HyperType). HWitness Pure n -> (p # n) -> q # n) -> (Pure # p) -> Pure # q

HFunctor (ANode c)

Defined in Hyper.Combinator.ANode

Methods

hmap :: (forall (n :: HyperType). HWitness (ANode c) n -> (p # n) -> q # n) -> (ANode c # p) -> ANode c # q

HFunctor a => HFunctor (Ann a)

Defined in Hyper.Combinator.Ann

Methods

hmap :: (forall (n :: HyperType). HWitness (Ann a) n -> (p # n) -> q # n) -> (Ann a # p) -> Ann a # q

HFunctor (App expr)

Defined in Hyper.Syntax.App

Methods

hmap :: (forall (n :: HyperType). HWitness (App expr) n -> (p # n) -> q # n) -> (App expr # p) -> App expr # q

HFunctor (FuncType typ)

Defined in Hyper.Syntax.FuncType

Methods

hmap :: (forall (n :: HyperType). HWitness (FuncType typ) n -> (p # n) -> q # n) -> (FuncType typ # p) -> FuncType typ # q

(Recursively HFunctor typ, HFunctor (NomVarTypes typ)) => HFunctor (LoadedNominalDecl typ)

Defined in Hyper.Syntax.Nominal

Methods

hmap :: (forall (n :: HyperType). HWitness (LoadedNominalDecl typ) n -> (p # n) -> q # n) -> (LoadedNominalDecl typ # p) -> LoadedNominalDecl typ # q

HFunctor (NominalDecl typ)

Defined in Hyper.Syntax.Nominal

Methods

hmap :: (forall (n :: HyperType). HWitness (NominalDecl typ) n -> (p # n) -> q # n) -> (NominalDecl typ # p) -> NominalDecl typ # q

Functor f => HFunctor (F f)

Defined in Hyper.Type.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (F f) n -> (p # n) -> q # n) -> (F f # p) -> F f # q

HFunctor t => HFunctor (UnifyError t)

Defined in Hyper.Unify.Error

Methods

hmap :: (forall (n :: HyperType). HWitness (UnifyError t) n -> (p # n) -> q # n) -> (UnifyError t # p) -> UnifyError t # q

HFunctor v => HFunctor (GTerm v)

Defined in Hyper.Unify.Generalize

Methods

hmap :: (forall (n :: HyperType). HWitness (GTerm v) n -> (p # n) -> q # n) -> (GTerm v # p) -> GTerm v # q

HFunctor (Const a :: AHyperType -> Type)

Defined in Hyper.Class.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (Const a) n -> (p # n) -> q # n) -> (Const a # p) -> Const a # q

HFunctor h => HFunctor (Rec1 h)

Defined in Hyper.Class.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (Rec1 h) n -> (p # n) -> q # n) -> (Rec1 h # p) -> Rec1 h # q

(HFunctor a, HFunctor b) => HFunctor (HCompose a b)

Defined in Hyper.Combinator.Compose

Methods

hmap :: (forall (n :: HyperType). HWitness (HCompose a b) n -> (p # n) -> q # n) -> (HCompose a b # p) -> HCompose a b # q

Recursively HFunctor h => HFunctor (HFlip Ann h)

Defined in Hyper.Combinator.Ann

Methods

hmap :: (forall (n :: HyperType). HWitness (HFlip Ann h) n -> (p # n) -> q # n) -> (HFlip Ann h # p) -> HFlip Ann h # q

HFunctor (InferOf e) => HFunctor (HFlip InferResult e)

Defined in Hyper.Infer.Result

Methods

hmap :: (forall (n :: HyperType). HWitness (HFlip InferResult e) n -> (p # n) -> q # n) -> (HFlip InferResult e # p) -> HFlip InferResult e # q

Recursively HFunctor ast => HFunctor (HFlip GTerm ast)

Defined in Hyper.Unify.Generalize

Methods

hmap :: (forall (n :: HyperType). HWitness (HFlip GTerm ast) n -> (p # n) -> q # n) -> (HFlip GTerm ast # p) -> HFlip GTerm ast # q

HFunctor (Lam v expr)

Defined in Hyper.Syntax.Lam

Methods

hmap :: (forall (n :: HyperType). HWitness (Lam v expr) n -> (p # n) -> q # n) -> (Lam v expr # p) -> Lam v expr # q

HFunctor (Let v expr)

Defined in Hyper.Syntax.Let

Methods

hmap :: (forall (n :: HyperType). HWitness (Let v expr) n -> (p # n) -> q # n) -> (Let v expr # p) -> Let v expr # q

HFunctor (TermMap h expr)

Defined in Hyper.Syntax.Map

Methods

hmap :: (forall (n :: HyperType). HWitness (TermMap h expr) n -> (p # n) -> q # n) -> (TermMap h expr # p) -> TermMap h expr # q

HFunctor (FromNom nomId term)

Defined in Hyper.Syntax.Nominal

Methods

hmap :: (forall (n :: HyperType). HWitness (FromNom nomId term) n -> (p # n) -> q # n) -> (FromNom nomId term # p) -> FromNom nomId term # q

HFunctor v => HFunctor (NominalInst n v)

Defined in Hyper.Syntax.Nominal

Methods

hmap :: (forall (n0 :: HyperType). HWitness (NominalInst n v) n0 -> (p # n0) -> q # n0) -> (NominalInst n v # p) -> NominalInst n v # q

HFunctor (ToNom nomId term)

Defined in Hyper.Syntax.Nominal

Methods

hmap :: (forall (n :: HyperType). HWitness (ToNom nomId term) n -> (p # n) -> q # n) -> (ToNom nomId term # p) -> ToNom nomId term # q

HFunctor (Scheme varTypes typ)

Defined in Hyper.Syntax.Scheme

Methods

hmap :: (forall (n :: HyperType). HWitness (Scheme varTypes typ) n -> (p # n) -> q # n) -> (Scheme varTypes typ # p) -> Scheme varTypes typ # q

HFunctor (TypeSig vars term)

Defined in Hyper.Syntax.TypeSig

Methods

hmap :: (forall (n :: HyperType). HWitness (TypeSig vars term) n -> (p # n) -> q # n) -> (TypeSig vars term # p) -> TypeSig vars term # q

HFunctor (Var v expr)

Defined in Hyper.Syntax.Var

Methods

hmap :: (forall (n :: HyperType). HWitness (Var v expr) n -> (p # n) -> q # n) -> (Var v expr # p) -> Var v expr # q

(HFunctor a, HFunctor b) => HFunctor (a :*: b)

Defined in Hyper.Class.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (a :*: b) n -> (p # n) -> q # n) -> ((a :*: b) # p) -> (a :*: b) # q

(HFunctor a, HFunctor b) => HFunctor (a :+: b)

Defined in Hyper.Class.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (a :+: b) n -> (p # n) -> q # n) -> ((a :+: b) # p) -> (a :+: b) # q

HFunctor (FlatRowExtends key val rest)

Defined in Hyper.Syntax.Row

Methods

hmap :: (forall (n :: HyperType). HWitness (FlatRowExtends key val rest) n -> (p # n) -> q # n) -> (FlatRowExtends key val rest # p) -> FlatRowExtends key val rest # q

HFunctor (RowExtend key val rest)

Defined in Hyper.Syntax.Row

Methods

hmap :: (forall (n :: HyperType). HWitness (RowExtend key val rest) n -> (p # n) -> q # n) -> (RowExtend key val rest # p) -> RowExtend key val rest # q

HFunctor (TypedLam var typ expr)

Defined in Hyper.Syntax.TypedLam

Methods

hmap :: (forall (n :: HyperType). HWitness (TypedLam var typ expr) n -> (p # n) -> q # n) -> (TypedLam var typ expr # p) -> TypedLam var typ expr # q

HFunctor h => HFunctor (M1 i m h)

Defined in Hyper.Class.Functor

Methods

hmap :: (forall (n :: HyperType). HWitness (M1 i m h) n -> (p # n) -> q # n) -> (M1 i m h # p) -> M1 i m h # q

hmapped1 :: forall h n p q. (HFunctor h, HNodesConstraint h ((~) n)) => Setter (h # p) (h # q) (p # n) (q # n)

HFunctor variant of mapped for HyperTypes with a single node type.

Avoids using RankNTypes and thus can be composed with other optics.

hiso :: HFunctor h => (forall n. HWitness h n -> AnIso' (p # n) (q # n)) -> Iso' (h # p) (h # q)

Define Isos for HFunctors

TODO: Is there an equivalent for this in lens that we can name this after?