Control.Env.Hierarchical.Internal

Documentation

class Environment env where

Minimal complete definition

Nothing

Associated Types

type Super env

Super env represents the inheritance relation between environments.

• If env owns a field of the form Extends T, then T is the super environment.
• If env owns no field of the form Extends T, then Root is the super environment.
• Every env must have at most one field of the form Extends T because multiple inheritance is not supported.

type Fields1 env :: [Type -> Type]

interfaces that are fields of the environment

type Fields env :: [Type]

fields of the environment

Methods

superL :: Lens' env (Super env)

Lens to super environment

default superL :: Field (Extends (Super env)) env => Lens' env (Super env)

Instances

Environment Root

Defined in Control.Env.Hierarchical.Internal

Associated Types

type Super Root

type Fields1 Root :: [Type -> Type]

type Fields Root :: [Type]

Methods

superL :: Lens' Root (Super Root)

newtype Extends env

Wrapper that represents the super environment.

Constructors

Extends env

Instances

Eq env => Eq (Extends env)

Defined in Control.Env.Hierarchical.Internal

Methods

(==) :: Extends env -> Extends env -> Bool

(/=) :: Extends env -> Extends env -> Bool

Ord env => Ord (Extends env)

Defined in Control.Env.Hierarchical.Internal

Methods

compare :: Extends env -> Extends env -> Ordering

(<) :: Extends env -> Extends env -> Bool

(<=) :: Extends env -> Extends env -> Bool

(>) :: Extends env -> Extends env -> Bool

(>=) :: Extends env -> Extends env -> Bool

max :: Extends env -> Extends env -> Extends env

min :: Extends env -> Extends env -> Extends env

Show env => Show (Extends env)

Defined in Control.Env.Hierarchical.Internal

Methods

showsPrec :: Int -> Extends env -> ShowS

show :: Extends env -> String

showList :: [Extends env] -> ShowS

data Root

Root environment that does not have any fields.

Constructors

Root

Instances

Environment Root

Defined in Control.Env.Hierarchical.Internal

Associated Types

type Super Root

type Fields1 Root :: [Type -> Type]

type Fields Root :: [Type]

Methods

superL :: Lens' Root (Super Root)

type Super Root

Defined in Control.Env.Hierarchical.Internal

type Super Root = TypeError ('Text "No super environment for Root") :: Type

type Fields1 Root

Defined in Control.Env.Hierarchical.Internal

type Fields1 Root = '[] :: [Type -> Type]

type Fields Root

Defined in Control.Env.Hierarchical.Internal

type Fields Root = '[] :: [Type]

class Field a env where

direct field of env

Methods

fieldL :: Lens' env a

Instances

Field env env

Defined in Control.Env.Hierarchical.Internal

Methods

fieldL :: Lens' env env

class Trans s (l :: [Type]) where

Associated Types

type Target s l

Methods

transL :: Lens' s (Target s l)

Instances

Trans s ('[] :: [Type])

Defined in Control.Env.Hierarchical.Internal

Associated Types

type Target s '[]

Methods

transL :: Lens' s (Target s '[])

(Environment s, Super s ~ t, Trans t l) => Trans s (t ': l)

Defined in Control.Env.Hierarchical.Internal

Associated Types

type Target s (t ': l)

Methods

transL :: Lens' s (Target s (t ': l))

data SomeInterface f env where

Constructors

SomeInterface :: Lens' env' (f env') -> Lens' env env' -> SomeInterface f env

type family Has a env where ...

Type constraint meaning env contains a as a (including ancestors') field.

An environment env contains unique value for each type T that satisfies Has T env. If you want to depends on multiple values of the same type, please distinguish them by using newtype.

Equations

Has a env = HasAux a env (FindEnv a env (Addr env))

type family Has1 f env where ...

Type constraint meaning env contains f env' for some ancestor env'

Equations

Has1 f env = Has1Aux f env (FindEnv1 f env (Addr env))

getL :: forall a env. Has a env => Lens' env a

Lens to extract a from env

ifaceL :: forall f env. Has1 f env => SomeInterface f env

runIF :: forall f env a. Has1 f env => (forall env'. f env' -> RIO env' a) -> RIO env a

Run action that depends on an interface f. The action must be polymorphic to env', because it will run in some ancestor environment, which may be different from env,

rootL :: Lens' x Root

extendsL :: Lens' (Extends x) x