| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Cubix.Language.Parametric.Syntax
Synopsis
- data BoolF (e :: * -> *) l where
- data BoolL
- data IntF (e :: * -> *) l where
- data IntL
- data IntegerF (e :: * -> *) l where
- data IntegerL
- data CharF (e :: * -> *) l where
- data CharL
- data UnitF (e :: * -> *) l where
- pattern BoolF' :: (BoolF :-<: fs, All HFunctor fs) => Bool -> CxtS h fs a BoolL
- iBoolF :: forall h fs a j. ((:-<:) BoolF fs, InjF fs BoolL j) => Bool -> CxtS h fs a j
- pattern IntF' :: (IntF :-<: fs, All HFunctor fs) => Int -> CxtS h fs a IntL
- iIntF :: forall h fs a j. ((:-<:) IntF fs, InjF fs IntL j) => Int -> CxtS h fs a j
- pattern IntegerF' :: (IntegerF :-<: fs, All HFunctor fs) => Integer -> CxtS h fs a IntegerL
- iIntegerF :: forall h fs a j. ((:-<:) IntegerF fs, InjF fs IntegerL j) => Integer -> CxtS h fs a j
- pattern CharF' :: (CharF :-<: fs, All HFunctor fs) => Char -> CxtS h fs a CharL
- iCharF :: forall h fs a j. ((:-<:) CharF fs, InjF fs CharL j) => Char -> CxtS h fs a j
- pattern UnitF' :: (UnitF :-<: fs, All HFunctor fs) => CxtS h fs a ()
- iUnitF :: forall h fs a j. ((:-<:) UnitF fs, InjF fs () j) => CxtS h fs a j
- data FunctionCallAttrsL
- data FunctionExpL
- data FunctionArgumentsL
- data FunctionCallL
- data FunctionCall e l where
- FunctionCall :: e FunctionCallAttrsL -> e FunctionExpL -> e FunctionArgumentsL -> FunctionCall e FunctionCallL
- data EmptyFunctionCallAttrs (e :: * -> *) l where
- data FunctionIdent e l where
- FunctionIdent :: e IdentL -> FunctionIdent e FunctionExpL
- data FunctionArgumentL
- data FunctionArgumentList e l where
- data ReceiverL
- data ReceiverArg e l where
- ReceiverArg :: e ReceiverL -> ReceiverArg e FunctionArgumentL
- data PositionalArgExpL
- data PositionalArgument e l where
- pattern FunctionCall' :: (FunctionCall :-<: fs, All HFunctor fs) => CxtS h fs a FunctionCallAttrsL -> CxtS h fs a FunctionExpL -> CxtS h fs a FunctionArgumentsL -> CxtS h fs a FunctionCallL
- iFunctionCall :: forall h fs a j. ((:-<:) FunctionCall fs, InjF fs FunctionCallL j) => CxtS h fs a FunctionCallAttrsL -> CxtS h fs a FunctionExpL -> CxtS h fs a FunctionArgumentsL -> CxtS h fs a j
- pattern EmptyFunctionCallAttrs' :: (EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionCallAttrsL
- iEmptyFunctionCallAttrs :: forall h fs a j. ((:-<:) EmptyFunctionCallAttrs fs, InjF fs FunctionCallAttrsL j) => CxtS h fs a j
- pattern FunctionIdent' :: (FunctionIdent :-<: fs, All HFunctor fs) => CxtS h fs a IdentL -> CxtS h fs a FunctionExpL
- iFunctionIdent :: forall h fs a j. ((:-<:) FunctionIdent fs, InjF fs FunctionExpL j) => CxtS h fs a IdentL -> CxtS h fs a j
- pattern FunctionArgumentList' :: (FunctionArgumentList :-<: fs, All HFunctor fs) => CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL
- iFunctionArgumentList :: forall h fs a j. ((:-<:) FunctionArgumentList fs, InjF fs FunctionArgumentsL j) => CxtS h fs a [FunctionArgumentL] -> CxtS h fs a j
- pattern ReceiverArg' :: (ReceiverArg :-<: fs, All HFunctor fs) => CxtS h fs a ReceiverL -> CxtS h fs a FunctionArgumentL
- iReceiverArg :: forall h fs a j. ((:-<:) ReceiverArg fs, InjF fs FunctionArgumentL j) => CxtS h fs a ReceiverL -> CxtS h fs a j
- pattern PositionalArgument' :: (PositionalArgument :-<: fs, All HFunctor fs) => CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL
- iPositionalArgument :: forall h fs a j. ((:-<:) PositionalArgument fs, InjF fs FunctionArgumentL j) => CxtS h fs a PositionalArgExpL -> CxtS h fs a j
- data FunctionDeclAttrsL
- data FunctionParameterDeclL
- data FunctionParameterDeclAttrsL
- data FunctionDeclL
- data FunctionDecl e l where
- FunctionDecl :: e FunctionDeclAttrsL -> e IdentL -> e [FunctionParameterDeclL] -> FunctionDecl e FunctionDeclL
- data EmptyFunctionDeclAttrs (e :: * -> *) l where
- data SelfParameterDecl (e :: * -> *) l where
- data PositionalParameterDeclOptionalIdent e l where
- data PositionalParameterDeclWithIdent e l where
- pattern FunctionDecl' :: (FunctionDecl :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterDeclL] -> CxtS h fs a FunctionDeclL
- iFunctionDecl :: forall h fs a j. ((:-<:) FunctionDecl fs, InjF fs FunctionDeclL j) => CxtS h fs a FunctionDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterDeclL] -> CxtS h fs a j
- pattern EmptyFunctionDeclAttrs' :: (EmptyFunctionDeclAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDeclAttrsL
- iEmptyFunctionDeclAttrs :: forall h fs a j. ((:-<:) EmptyFunctionDeclAttrs fs, InjF fs FunctionDeclAttrsL j) => CxtS h fs a j
- pattern SelfParameterDecl' :: (SelfParameterDecl :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclL
- iSelfParameterDecl :: forall h fs a j. ((:-<:) SelfParameterDecl fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a j
- pattern PositionalParameterDeclOptionalIdent' :: (PositionalParameterDeclOptionalIdent :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a (Maybe IdentL) -> CxtS h fs a FunctionParameterDeclL
- iPositionalParameterDeclOptionalIdent :: forall h fs a j. ((:-<:) PositionalParameterDeclOptionalIdent fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a (Maybe IdentL) -> CxtS h fs a j
- pattern PositionalParameterDeclWithIdent' :: (PositionalParameterDeclWithIdent :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterDeclL
- iPositionalParameterDeclWithIdent :: forall h fs a j. ((:-<:) PositionalParameterDeclWithIdent fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a j
- data FunctionDefAttrsL
- data FunctionParameterL
- data FunctionBodyL
- data FunctionDefL
- data FunctionDef e l where
- FunctionDef :: e FunctionDefAttrsL -> e IdentL -> e [FunctionParameterL] -> e FunctionBodyL -> FunctionDef e FunctionDefL
- data EmptyFunctionDefAttrs (e :: * -> *) l where
- data SelfParameter (e :: * -> *) l where
- data ParameterAttrsL
- data PositionalParameter e l where
- data EmptyParameterAttrs (e :: * -> *) l where
- pattern FunctionDef' :: (FunctionDef :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDefAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterL] -> CxtS h fs a FunctionBodyL -> CxtS h fs a FunctionDefL
- iFunctionDef :: forall h fs a j. ((:-<:) FunctionDef fs, InjF fs FunctionDefL j) => CxtS h fs a FunctionDefAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterL] -> CxtS h fs a FunctionBodyL -> CxtS h fs a j
- pattern EmptyFunctionDefAttrs' :: (EmptyFunctionDefAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDefAttrsL
- iEmptyFunctionDefAttrs :: forall h fs a j. ((:-<:) EmptyFunctionDefAttrs fs, InjF fs FunctionDefAttrsL j) => CxtS h fs a j
- pattern EmptyParameterAttrs :: EmptyParameterAttrs e ParameterAttrsL
- iEmptyParameterAttrs :: forall h fs a j. ((:-<:) EmptyParameterAttrs fs, InjF fs ParameterAttrsL j) => CxtS h fs a j
- pattern SelfParameter' :: (SelfParameter :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterL
- iSelfParameter :: forall h fs a j. ((:-<:) SelfParameter fs, InjF fs FunctionParameterL j) => CxtS h fs a j
- pattern PositionalParameter' :: (PositionalParameter :-<: fs, All HFunctor fs) => CxtS h fs a ParameterAttrsL -> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterL
- iPositionalParameter :: forall h fs a j. ((:-<:) PositionalParameter fs, InjF fs FunctionParameterL j) => CxtS h fs a ParameterAttrsL -> CxtS h fs a IdentL -> CxtS h fs a j
- pattern EmptyParameterAttrs' :: (EmptyParameterAttrs :-<: fs, All HFunctor fs) => CxtS h fs a ParameterAttrsL
- iEmptyParameterAttrs :: forall h fs a j. ((:-<:) EmptyParameterAttrs fs, InjF fs ParameterAttrsL j) => CxtS h fs a j
- data MaybeF e l where
- data ListF e l where
- data PairF e l where
- data TripleF e l where
- data EitherF e l where
- pattern Just' :: (MaybeF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a (Maybe l)
- pattern Nothing' :: (MaybeF :<: f, Typeable l, HFunctor f) => Cxt h f a (Maybe l)
- pattern JustA' :: (MaybeF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a (Maybe l)
- pattern ConsF' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l]
- pattern NilF' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h f a [l]
- pattern SingletonF' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a [l]
- pattern ConsFA' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a [l] -> Cxt h (f :&: p) a [l]
- pattern NilFA' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a [l]
- pattern SingletonFA' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a [l]
- pattern PairF' :: (PairF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l -> Cxt h f a l' -> Cxt h f a (l, l')
- pattern TripleF' :: (TripleF :<: f, Typeable i, Typeable j, Typeable k, HFunctor f) => Cxt h f a i -> Cxt h f a j -> Cxt h f a k -> Cxt h f a (i, j, k)
- pattern Left' :: (EitherF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l -> Cxt h f a (Either l l')
- pattern Right' :: (EitherF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l' -> Cxt h f a (Either l l')
- riNothingF :: forall h f a l. (MaybeF :<: f, Typeable l) => Cxt h f a (Maybe l)
- iJustF :: (MaybeF :-<: fs, InjF fs (Maybe l) l', Typeable l) => CxtS h fs a l -> CxtS h fs a l'
- riNilF :: forall h f a l. (ListF :<: f, Typeable l) => Cxt h f a [l]
- iConsF :: (ListF :-<: fs, InjF fs [l] l', Typeable l) => CxtS h fs a l -> CxtS h fs a [l] -> CxtS h fs a l'
- riPairF :: (PairF :<: f, Typeable i, Typeable j) => Cxt h f a i -> Cxt h f a j -> Cxt h f a (i, j)
- riTripleF :: (TripleF :<: f, Typeable i, Typeable j, Typeable k) => Cxt h f a i -> Cxt h f a j -> Cxt h f a k -> Cxt h f a (i, j, k)
- riLeftF :: (EitherF :<: f, Typeable i, Typeable j) => Cxt h f a i -> Cxt h f a (Either i j)
- riRightF :: (EitherF :<: f, Typeable i, Typeable j) => Cxt h f a j -> Cxt h f a (Either i j)
- class ExtractF f e where
- extractF :: e (f l) -> f (e l)
- class KExtractF f g where
- class KExtractF' f g where
- kextractF' :: g e (f l) -> f (e l)
- class ExtractF2 f e where
- extractF2 :: e (f l l') -> f (e l) (e l')
- class KExtractF2 f g where
- kextractF2 :: ExtractF2 f e => g e (f l l') -> f (e l) (e l')
- class KExtractF2' f g where
- kextractF2' :: g e (f l l') -> f (e l) (e l')
- class ExtractF3 f e where
- extractF3 :: e (f l l' l'') -> f (e l) (e l') (e l'')
- class KExtractF3 f g where
- kextractF3 :: ExtractF3 f e => g e (f l l' l'') -> f (e l) (e l') (e l'')
- class KExtractF3' f g where
- kextractF3' :: g e (f l l' l'') -> f (e l) (e l') (e l'')
- class Functor f => InsertF f e where
- insertFHole :: (InsertF e (Context f (HFix g)), Typeable l) => e (HFix g l) -> Context f (HFix g) (e l)
- liftF :: (InsertF f h, ExtractF f g, Functor f, Typeable b) => (f (g a) -> f (h b)) -> g (f a) -> h (f b)
- mapF :: (InsertF f h, ExtractF f g, Functor f, Typeable b) => (g a -> h b) -> g (f a) -> h (f b)
- data IdentL
- data Ident (e :: * -> *) l where
- data MultiLocalVarDeclCommonAttrsL
- data LocalVarInitL
- data IsOptional
- data OptLocalVarInitL
- data OptLocalVarInit e l where
- data LocalVarDeclAttrsL
- data TupleBinder e l where
- TupleBinder :: e [IdentL] -> TupleBinder e VarDeclBinderL
- data IdentIsVarDeclBinder (e :: Type -> Type) i = i ~ VarDeclBinderL => IdentIsVarDeclBinder (e IdentL)
- data EmptyLocalVarDeclAttrs (e :: * -> *) l where
- data VarDeclBinderL
- data SingleLocalVarDeclL
- data SingleLocalVarDecl e l where
- data EmptyMultiLocalVarDeclCommonAttrs (e :: * -> *) l
- data MultiLocalVarDeclL
- data MultiLocalVarDecl e l where
- data AssignOpL
- data AssignOpEquals (e :: * -> *) l where
- data LhsL
- data RhsL
- data AssignL
- data Assign e l where
- data BlockItemL
- data BlockEndL
- data EmptyBlockEnd (e :: * -> *) l where
- data BlockL
- data Block e l where
- Block :: e [BlockItemL] -> e BlockEndL -> Block e BlockL
- data EmptyBlockItem (e :: * -> *) l where
- pattern Ident' :: (Ident :-<: fs, All HFunctor fs) => String -> CxtS h fs a IdentL
- iIdent :: forall h fs a j. ((:-<:) Ident fs, InjF fs IdentL j) => String -> CxtS h fs a j
- pattern JustLocalVarInit' :: (OptLocalVarInit :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarInitL -> CxtS h fs a OptLocalVarInitL
- iJustLocalVarInit :: forall h fs a j. ((:-<:) OptLocalVarInit fs, InjF fs OptLocalVarInitL j) => CxtS h fs a LocalVarInitL -> CxtS h fs a j
- pattern NoLocalVarInit' :: (OptLocalVarInit :-<: fs, All HFunctor fs) => CxtS h fs a OptLocalVarInitL
- iNoLocalVarInit :: forall h fs a j. ((:-<:) OptLocalVarInit fs, InjF fs OptLocalVarInitL j) => CxtS h fs a j
- pattern EmptyLocalVarDeclAttrs' :: (EmptyLocalVarDeclAttrs :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarDeclAttrsL
- iEmptyLocalVarDeclAttrs :: forall h fs a j. ((:-<:) EmptyLocalVarDeclAttrs fs, InjF fs LocalVarDeclAttrsL j) => CxtS h fs a j
- pattern TupleBinder' :: (TupleBinder :-<: fs, All HFunctor fs) => CxtS h fs a [IdentL] -> CxtS h fs a VarDeclBinderL
- iTupleBinder :: forall h fs a j. ((:-<:) TupleBinder fs, InjF fs VarDeclBinderL j) => CxtS h fs a [IdentL] -> CxtS h fs a j
- pattern IdentIsVarDeclBinder' :: (IdentIsVarDeclBinder :-<: fs, All HFunctor fs) => CxtS h fs a IdentL -> CxtS h fs a VarDeclBinderL
- iIdentIsVarDeclBinder :: forall h fs a j. ((:-<:) IdentIsVarDeclBinder fs, InjF fs VarDeclBinderL j) => CxtS h fs a IdentL -> CxtS h fs a j
- pattern SingleLocalVarDecl' :: (SingleLocalVarDecl :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarDeclAttrsL -> CxtS h fs a VarDeclBinderL -> CxtS h fs a OptLocalVarInitL -> CxtS h fs a SingleLocalVarDeclL
- iSingleLocalVarDecl :: forall h fs a j. ((:-<:) SingleLocalVarDecl fs, InjF fs SingleLocalVarDeclL j) => CxtS h fs a LocalVarDeclAttrsL -> CxtS h fs a VarDeclBinderL -> CxtS h fs a OptLocalVarInitL -> CxtS h fs a j
- pattern EmptyMultiLocalVarDeclCommonAttrs' :: (EmptyMultiLocalVarDeclCommonAttrs :-<: fs, All HFunctor fs) => CxtS h fs a MultiLocalVarDeclCommonAttrsL
- iEmptyMultiLocalVarDeclCommonAttrs :: forall h fs a j. ((:-<:) EmptyMultiLocalVarDeclCommonAttrs fs, InjF fs MultiLocalVarDeclCommonAttrsL j) => CxtS h fs a j
- pattern MultiLocalVarDecl' :: (MultiLocalVarDecl :-<: fs, All HFunctor fs) => CxtS h fs a MultiLocalVarDeclCommonAttrsL -> CxtS h fs a [SingleLocalVarDeclL] -> CxtS h fs a MultiLocalVarDeclL
- iMultiLocalVarDecl :: forall h fs a j. ((:-<:) MultiLocalVarDecl fs, InjF fs MultiLocalVarDeclL j) => CxtS h fs a MultiLocalVarDeclCommonAttrsL -> CxtS h fs a [SingleLocalVarDeclL] -> CxtS h fs a j
- pattern AssignOpEquals' :: (AssignOpEquals :-<: fs, All HFunctor fs) => CxtS h fs a AssignOpL
- iAssignOpEquals :: forall h fs a j. ((:-<:) AssignOpEquals fs, InjF fs AssignOpL j) => CxtS h fs a j
- pattern Assign' :: (Assign :-<: fs, All HFunctor fs) => CxtS h fs a LhsL -> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a AssignL
- iAssign :: forall h fs a j. ((:-<:) Assign fs, InjF fs AssignL j) => CxtS h fs a LhsL -> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a j
- pattern EmptyBlockEnd' :: (EmptyBlockEnd :-<: fs, All HFunctor fs) => CxtS h fs a BlockEndL
- iEmptyBlockEnd :: forall h fs a j. ((:-<:) EmptyBlockEnd fs, InjF fs BlockEndL j) => CxtS h fs a j
- pattern Block' :: (Block :-<: fs, All HFunctor fs) => CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a BlockL
- iBlock :: forall h fs a j. ((:-<:) Block fs, InjF fs BlockL j) => CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a j
- pattern EmptyBlockItem' :: (EmptyBlockItem :-<: fs, All HFunctor fs) => CxtS h fs a BlockItemL
- iEmptyBlockItem :: forall h fs a j. ((:-<:) EmptyBlockItem fs, InjF fs BlockItemL j) => CxtS h fs a j
Documentation
data BoolF (e :: * -> *) l where Source #
Instances
data IntF (e :: * -> *) l where Source #
Instances
data IntegerF (e :: * -> *) l where Source #
Instances
data CharF (e :: * -> *) l where Source #
Instances
data UnitF (e :: * -> *) l where Source #
Instances
pattern IntegerF' :: (IntegerF :-<: fs, All HFunctor fs) => Integer -> CxtS h fs a IntegerL Source #
iIntegerF :: forall h fs a j. ((:-<:) IntegerF fs, InjF fs IntegerL j) => Integer -> CxtS h fs a j Source #
data FunctionCallAttrsL Source #
Instances
| KDynCase EmptyFunctionCallAttrs FunctionCallAttrsL Source # | |
Defined in Cubix.Language.Parametric.Syntax.Function Methods kdyncase :: forall (e :: Type -> Type) b. EmptyFunctionCallAttrs e b -> Maybe (b :~: FunctionCallAttrsL) # | |
| KDynCase JavaTypeArgs FunctionCallAttrsL Source # | |
Defined in Cubix.Language.Java.Parametric.Common.Types Methods kdyncase :: forall (e :: Type -> Type) b. JavaTypeArgs e b -> Maybe (b :~: FunctionCallAttrsL) # | |
data FunctionExpL Source #
Instances
data FunctionArgumentsL Source #
Instances
| KDynCase FunctionArgumentList FunctionArgumentsL Source # | |
Defined in Cubix.Language.Parametric.Syntax.Function Methods kdyncase :: forall (e :: Type -> Type) b. FunctionArgumentList e b -> Maybe (b :~: FunctionArgumentsL) # | |
| KDynCase LuaSpecialFunArg FunctionArgumentsL Source # | |
Defined in Cubix.Language.Lua.Parametric.Common.Types Methods kdyncase :: forall (e :: Type -> Type) b. LuaSpecialFunArg e b -> Maybe (b :~: FunctionArgumentsL) # | |
data FunctionCallL Source #
Upon evaluating a FunctionCall node, the following occurs: 1) The FunctionExp is evaluated. 2) The function call attrs are evaluated. 3) The arguments are evaluated, in unspecified order. (Remember, we model C, which has unspecified order) 4) A function is looked up based on the function exp and the arguments, and is then invoked with the given arguments.
1 and 2 happpen in unspecified order. 1 and 2 happen before 3, which happens before 4.
All positional arguments in the invocation and the function definition are matched up sequentially If argument types do not line up (e.g.: pass a positional arg at a receiver position), this is undefined; said positional argument is ignored in the above computation
Instances
data FunctionCall e l where Source #
Constructors
| FunctionCall :: e FunctionCallAttrsL -> e FunctionExpL -> e FunctionArgumentsL -> FunctionCall e FunctionCallL |
Instances
data EmptyFunctionCallAttrs (e :: * -> *) l where Source #
Constructors
| EmptyFunctionCallAttrs :: EmptyFunctionCallAttrs e FunctionCallAttrsL |
Instances
data FunctionIdent e l where Source #
Constructors
| FunctionIdent :: e IdentL -> FunctionIdent e FunctionExpL |
Instances
data FunctionArgumentL Source #
Additional non-syntactic assumptions: * At most one argument is receiver, and it's at the front of the list if exists. * Positional and receiver args are before other args
Instances
| KDynCase ReceiverArg FunctionArgumentL Source # | |
Defined in Cubix.Language.Parametric.Syntax.Function Methods kdyncase :: forall (e :: Type -> Type) b. ReceiverArg e b -> Maybe (b :~: FunctionArgumentL) # | |
| KDynCase PositionalArgument FunctionArgumentL Source # | |
Defined in Cubix.Language.Parametric.Syntax.Function Methods kdyncase :: forall (e :: Type -> Type) b. PositionalArgument e b -> Maybe (b :~: FunctionArgumentL) # | |
| KDynCase PythonArg FunctionArgumentL Source # | |
| InjF MJavaSig ExpL FunctionArgumentL Source # | |
Defined in Cubix.Language.Java.Parametric.Common.Types Methods injF :: forall h (a :: Type -> Type). CxtS h MJavaSig a ExpL -> CxtS h MJavaSig a FunctionArgumentL Source # projF' :: forall h p (a :: Type -> Type). Cxt h (Sum MJavaSig :&: p) a FunctionArgumentL -> Maybe (Cxt h (Sum MJavaSig :&: p) a ExpL) Source # projF :: forall h (a :: Type -> Type). CxtS h MJavaSig a FunctionArgumentL -> Maybe (CxtS h MJavaSig a ExpL) Source # | |
data FunctionArgumentList e l where Source #
Constructors
| FunctionArgumentList :: e [FunctionArgumentL] -> FunctionArgumentList e FunctionArgumentsL |
Instances
Instances
data ReceiverArg e l where Source #
Constructors
| ReceiverArg :: e ReceiverL -> ReceiverArg e FunctionArgumentL |
Instances
data PositionalArgExpL Source #
Instances
data PositionalArgument e l where Source #
Constructors
| PositionalArgument :: e PositionalArgExpL -> PositionalArgument e FunctionArgumentL |
Instances
pattern FunctionCall' :: (FunctionCall :-<: fs, All HFunctor fs) => CxtS h fs a FunctionCallAttrsL -> CxtS h fs a FunctionExpL -> CxtS h fs a FunctionArgumentsL -> CxtS h fs a FunctionCallL Source #
iFunctionCall :: forall h fs a j. ((:-<:) FunctionCall fs, InjF fs FunctionCallL j) => CxtS h fs a FunctionCallAttrsL -> CxtS h fs a FunctionExpL -> CxtS h fs a FunctionArgumentsL -> CxtS h fs a j Source #
pattern EmptyFunctionCallAttrs' :: (EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionCallAttrsL Source #
iEmptyFunctionCallAttrs :: forall h fs a j. ((:-<:) EmptyFunctionCallAttrs fs, InjF fs FunctionCallAttrsL j) => CxtS h fs a j Source #
pattern FunctionIdent' :: (FunctionIdent :-<: fs, All HFunctor fs) => CxtS h fs a IdentL -> CxtS h fs a FunctionExpL Source #
iFunctionIdent :: forall h fs a j. ((:-<:) FunctionIdent fs, InjF fs FunctionExpL j) => CxtS h fs a IdentL -> CxtS h fs a j Source #
pattern FunctionArgumentList' :: (FunctionArgumentList :-<: fs, All HFunctor fs) => CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL Source #
iFunctionArgumentList :: forall h fs a j. ((:-<:) FunctionArgumentList fs, InjF fs FunctionArgumentsL j) => CxtS h fs a [FunctionArgumentL] -> CxtS h fs a j Source #
pattern ReceiverArg' :: (ReceiverArg :-<: fs, All HFunctor fs) => CxtS h fs a ReceiverL -> CxtS h fs a FunctionArgumentL Source #
iReceiverArg :: forall h fs a j. ((:-<:) ReceiverArg fs, InjF fs FunctionArgumentL j) => CxtS h fs a ReceiverL -> CxtS h fs a j Source #
pattern PositionalArgument' :: (PositionalArgument :-<: fs, All HFunctor fs) => CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL Source #
iPositionalArgument :: forall h fs a j. ((:-<:) PositionalArgument fs, InjF fs FunctionArgumentL j) => CxtS h fs a PositionalArgExpL -> CxtS h fs a j Source #
data FunctionDeclAttrsL Source #
Instances
data FunctionParameterDeclL Source #
Instances
data FunctionParameterDeclAttrsL Source #
Instances
data FunctionDeclL Source #
Instances
data FunctionDecl e l where Source #
Constructors
| FunctionDecl :: e FunctionDeclAttrsL -> e IdentL -> e [FunctionParameterDeclL] -> FunctionDecl e FunctionDeclL |
Instances
data EmptyFunctionDeclAttrs (e :: * -> *) l where Source #
Constructors
| EmptyFunctionDeclAttrs :: EmptyFunctionDeclAttrs e FunctionDeclAttrsL |
Instances
data SelfParameterDecl (e :: * -> *) l where Source #
Constructors
| SelfParameterDecl :: SelfParameterDecl e FunctionParameterDeclL |
Instances
data PositionalParameterDeclOptionalIdent e l where Source #
Constructors
| PositionalParameterDeclOptionalIdent :: e FunctionParameterDeclAttrsL -> e (Maybe IdentL) -> PositionalParameterDeclOptionalIdent e FunctionParameterDeclL |
Instances
data PositionalParameterDeclWithIdent e l where Source #
Constructors
| PositionalParameterDeclWithIdent :: e FunctionParameterDeclAttrsL -> e IdentL -> PositionalParameterDeclWithIdent e FunctionParameterDeclL |
Instances
pattern FunctionDecl' :: (FunctionDecl :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterDeclL] -> CxtS h fs a FunctionDeclL Source #
iFunctionDecl :: forall h fs a j. ((:-<:) FunctionDecl fs, InjF fs FunctionDeclL j) => CxtS h fs a FunctionDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterDeclL] -> CxtS h fs a j Source #
pattern EmptyFunctionDeclAttrs' :: (EmptyFunctionDeclAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDeclAttrsL Source #
iEmptyFunctionDeclAttrs :: forall h fs a j. ((:-<:) EmptyFunctionDeclAttrs fs, InjF fs FunctionDeclAttrsL j) => CxtS h fs a j Source #
pattern SelfParameterDecl' :: (SelfParameterDecl :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclL Source #
iSelfParameterDecl :: forall h fs a j. ((:-<:) SelfParameterDecl fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a j Source #
pattern PositionalParameterDeclOptionalIdent' :: (PositionalParameterDeclOptionalIdent :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a (Maybe IdentL) -> CxtS h fs a FunctionParameterDeclL Source #
iPositionalParameterDeclOptionalIdent :: forall h fs a j. ((:-<:) PositionalParameterDeclOptionalIdent fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a (Maybe IdentL) -> CxtS h fs a j Source #
pattern PositionalParameterDeclWithIdent' :: (PositionalParameterDeclWithIdent :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterDeclL Source #
iPositionalParameterDeclWithIdent :: forall h fs a j. ((:-<:) PositionalParameterDeclWithIdent fs, InjF fs FunctionParameterDeclL j) => CxtS h fs a FunctionParameterDeclAttrsL -> CxtS h fs a IdentL -> CxtS h fs a j Source #
data FunctionDefAttrsL Source #
Instances
data FunctionParameterL Source #
Instances
data FunctionBodyL Source #
Instances
data FunctionDefL Source #
Instances
data FunctionDef e l where Source #
Constructors
| FunctionDef :: e FunctionDefAttrsL -> e IdentL -> e [FunctionParameterL] -> e FunctionBodyL -> FunctionDef e FunctionDefL |
Instances
data EmptyFunctionDefAttrs (e :: * -> *) l where Source #
Constructors
| EmptyFunctionDefAttrs :: EmptyFunctionDefAttrs e FunctionDefAttrsL |
Instances
data SelfParameter (e :: * -> *) l where Source #
Constructors
| SelfParameter :: SelfParameter e FunctionParameterL |
Instances
data ParameterAttrsL Source #
Instances
data PositionalParameter e l where Source #
Constructors
| PositionalParameter :: e ParameterAttrsL -> e IdentL -> PositionalParameter e FunctionParameterL |
Instances
data EmptyParameterAttrs (e :: * -> *) l where Source #
Constructors
| EmptyParameterAttrs :: EmptyParameterAttrs e ParameterAttrsL |
Instances
pattern FunctionDef' :: (FunctionDef :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDefAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterL] -> CxtS h fs a FunctionBodyL -> CxtS h fs a FunctionDefL Source #
iFunctionDef :: forall h fs a j. ((:-<:) FunctionDef fs, InjF fs FunctionDefL j) => CxtS h fs a FunctionDefAttrsL -> CxtS h fs a IdentL -> CxtS h fs a [FunctionParameterL] -> CxtS h fs a FunctionBodyL -> CxtS h fs a j Source #
pattern EmptyFunctionDefAttrs' :: (EmptyFunctionDefAttrs :-<: fs, All HFunctor fs) => CxtS h fs a FunctionDefAttrsL Source #
iEmptyFunctionDefAttrs :: forall h fs a j. ((:-<:) EmptyFunctionDefAttrs fs, InjF fs FunctionDefAttrsL j) => CxtS h fs a j Source #
pattern EmptyParameterAttrs :: EmptyParameterAttrs e ParameterAttrsL Source #
iEmptyParameterAttrs :: forall h fs a j. ((:-<:) EmptyParameterAttrs fs, InjF fs ParameterAttrsL j) => CxtS h fs a j Source #
pattern SelfParameter' :: (SelfParameter :-<: fs, All HFunctor fs) => CxtS h fs a FunctionParameterL Source #
iSelfParameter :: forall h fs a j. ((:-<:) SelfParameter fs, InjF fs FunctionParameterL j) => CxtS h fs a j Source #
pattern PositionalParameter' :: (PositionalParameter :-<: fs, All HFunctor fs) => CxtS h fs a ParameterAttrsL -> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterL Source #
iPositionalParameter :: forall h fs a j. ((:-<:) PositionalParameter fs, InjF fs FunctionParameterL j) => CxtS h fs a ParameterAttrsL -> CxtS h fs a IdentL -> CxtS h fs a j Source #
pattern EmptyParameterAttrs' :: (EmptyParameterAttrs :-<: fs, All HFunctor fs) => CxtS h fs a ParameterAttrsL Source #
iEmptyParameterAttrs :: forall h fs a j. ((:-<:) EmptyParameterAttrs fs, InjF fs ParameterAttrsL j) => CxtS h fs a j Source #
Functorial syntax
data MaybeF e l where Source #
A higher-order functor version of Maybe, for use with multi-sorted compositional data types
e : a functor mapping labels to terms of the corresponding sort
l : the label. Will have the form Maybe l'
Constructors
| NothingF :: Typeable l => MaybeF e (Maybe l) | |
| JustF :: Typeable l => e l -> MaybeF e (Maybe l) |
Instances
A higher-order functor version of [], for use with multi-sorted compositional data types
e : a functor mapping labels to terms of the corresponding sort
l : the label. Will have the form [l]
Instances
A higher-order functor version of (,), for use with multi-sorted compositional data types
e : a functor mapping labels to terms of the corresponding sort
l : the label . Will have the form (l1,l2)
Instances
data TripleF e l where Source #
Constructors
| TripleF :: (Typeable i, Typeable j, Typeable k) => e i -> e j -> e k -> TripleF e (i, j, k) |
Instances
data EitherF e l where Source #
A higher-order functor version of Either, for use with multi-sorted compositional data types
e : a functor mapping labels to terms of the corresponding sort
l : the label . Will have the form (Either l1 l2)
Constructors
| LeftF :: (Typeable i, Typeable j) => e i -> EitherF e (Either i j) | |
| RightF :: (Typeable i, Typeable j) => e j -> EitherF e (Either i j) |
Instances
pattern Just' :: (MaybeF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a (Maybe l) Source #
pattern JustA' :: (MaybeF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a (Maybe l) Source #
I really don't like having to copy variants for annotated versions, but must with current design
pattern ConsF' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l] Source #
pattern SingletonF' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h f a l -> Cxt h f a [l] Source #
pattern ConsFA' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a [l] -> Cxt h (f :&: p) a [l] Source #
pattern SingletonFA' :: (ListF :<: f, Typeable l, HFunctor f) => Cxt h (f :&: p) a l -> Cxt h (f :&: p) a [l] Source #
pattern PairF' :: (PairF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l -> Cxt h f a l' -> Cxt h f a (l, l') Source #
pattern TripleF' :: (TripleF :<: f, Typeable i, Typeable j, Typeable k, HFunctor f) => Cxt h f a i -> Cxt h f a j -> Cxt h f a k -> Cxt h f a (i, j, k) Source #
pattern Left' :: (EitherF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l -> Cxt h f a (Either l l') Source #
pattern Right' :: (EitherF :<: f, Typeable l, Typeable l', HFunctor f) => Cxt h f a l' -> Cxt h f a (Either l l') Source #
Smart constructors
riNothingF :: forall h f a l. (MaybeF :<: f, Typeable l) => Cxt h f a (Maybe l) Source #
Smart constructor for NothingF. Restricted; cannot be lifted through a sort injection
iJustF :: (MaybeF :-<: fs, InjF fs (Maybe l) l', Typeable l) => CxtS h fs a l -> CxtS h fs a l' Source #
riNilF :: forall h f a l. (ListF :<: f, Typeable l) => Cxt h f a [l] Source #
Smart constructor for NilF. Restricted; cannot be lifted through a sort injection
iConsF :: (ListF :-<: fs, InjF fs [l] l', Typeable l) => CxtS h fs a l -> CxtS h fs a [l] -> CxtS h fs a l' Source #
riPairF :: (PairF :<: f, Typeable i, Typeable j) => Cxt h f a i -> Cxt h f a j -> Cxt h f a (i, j) Source #
Smart constructor for PairF. Restricted; cannot be lifted through a sort injection
riTripleF :: (TripleF :<: f, Typeable i, Typeable j, Typeable k) => Cxt h f a i -> Cxt h f a j -> Cxt h f a k -> Cxt h f a (i, j, k) Source #
riLeftF :: (EitherF :<: f, Typeable i, Typeable j) => Cxt h f a i -> Cxt h f a (Either i j) Source #
riRightF :: (EitherF :<: f, Typeable i, Typeable j) => Cxt h f a j -> Cxt h f a (Either i j) Source #
Converting functorial syntax
class ExtractF f e where Source #
Methods
extractF :: e (f l) -> f (e l) Source #
Pulls a functor out of a label.
Example:
extractF::JavaProj[SourceFileL] -> [JavaProjSourceFileL]
Beware that this function unsafely assumes that e.g.: a term of sort
[l] is a ListF node (and similar for Maybe, etc).
If you define a custom node that has sort [l] for any l, and
do not define a corresponding ExtractF instance, then extractF
may give an error.
class KExtractF f g where Source #
Inductive form of ExtractF.
An instance KExtract f g gives rise to an instance ExtractF f (Term g)
class KExtractF' f g where Source #
Methods
kextractF' :: g e (f l) -> f (e l) Source #
Instances
| KExtractF' Maybe MaybeF Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor | |
| NotSum g => KExtractF' f g Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF' :: g e (f l) -> f (e l) Source # | |
| All (KExtractF' f) gs => KExtractF' f (Sum gs) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF' :: Sum gs e (f l) -> f (e l) Source # | |
| KExtractF' f g => KExtractF' f (g :&: a) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF' :: (g :&: a) e (f l) -> f (e l) Source # | |
class KExtractF2 f g where Source #
Methods
kextractF2 :: ExtractF2 f e => g e (f l l') -> f (e l) (e l') Source #
Instances
| KExtractF2' f g => KExtractF2 f g Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2 :: ExtractF2 f e => g e (f l l') -> f (e l) (e l') Source # | |
| All (KExtractF2 f) gs => KExtractF2 f (Sum gs) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2 :: ExtractF2 f e => Sum gs e (f l l') -> f (e l) (e l') Source # | |
| KExtractF2 f g => KExtractF2 f (g :&: a) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2 :: ExtractF2 f e => (g :&: a) e (f l l') -> f (e l) (e l') Source # | |
class KExtractF2' f g where Source #
Methods
kextractF2' :: g e (f l l') -> f (e l) (e l') Source #
Instances
| KExtractF2' Either EitherF Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor | |
| KExtractF2' (,) PairF Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2' :: PairF e (l, l') -> (e l, e l') Source # | |
| NotSum g => KExtractF2' f g Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2' :: g e (f l l') -> f (e l) (e l') Source # | |
| All (KExtractF2' f) gs => KExtractF2' f (Sum gs) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2' :: Sum gs e (f l l') -> f (e l) (e l') Source # | |
| KExtractF2' f g => KExtractF2' f (g :&: a) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF2' :: (g :&: a) e (f l l') -> f (e l) (e l') Source # | |
class KExtractF3 f g where Source #
Methods
kextractF3 :: ExtractF3 f e => g e (f l l' l'') -> f (e l) (e l') (e l'') Source #
Instances
| KExtractF3' f g => KExtractF3 f g Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3 :: ExtractF3 f e => g e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
| All (KExtractF3 f) gs => KExtractF3 f (Sum gs) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3 :: ExtractF3 f e => Sum gs e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
| KExtractF3 f g => KExtractF3 f (g :&: a) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3 :: ExtractF3 f e => (g :&: a) e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
class KExtractF3' f g where Source #
Methods
kextractF3' :: g e (f l l' l'') -> f (e l) (e l') (e l'') Source #
Instances
| KExtractF3' (,,) TripleF Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3' :: TripleF e (l, l', l'') -> (e l, e l', e l'') Source # | |
| NotSum g => KExtractF3' f g Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3' :: g e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
| All (KExtractF3' f) gs => KExtractF3' f (Sum gs) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3' :: Sum gs e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
| KExtractF3' f g => KExtractF3' f (g :&: a) Source # | |
Defined in Cubix.Language.Parametric.Syntax.Functor Methods kextractF3' :: (g :&: a) e (f l l' l'') -> f (e l) (e l') (e l'') Source # | |
class Functor f => InsertF f e where Source #
Methods
insertF :: Typeable l => f (e l) -> e (f l) Source #
Inverse of extractF. Pushes a functor into a label.
Example:
insertF:: [JavaProjSourceFileL] ->JavaProj[SourceFileL]
Note that this cannot be used on a labeled tree, as the insertion operation will require generating additional labels.
This is an instance of a distributive law, and can probably be replaced with such.
insertFHole :: (InsertF e (Context f (HFix g)), Typeable l) => e (HFix g l) -> Context f (HFix g) (e l) Source #
liftF :: (InsertF f h, ExtractF f g, Functor f, Typeable b) => (f (g a) -> f (h b)) -> g (f a) -> h (f b) Source #
mapF :: (InsertF f h, ExtractF f g, Functor f, Typeable b) => (g a -> h b) -> g (f a) -> h (f b) Source #
Instances
data Ident (e :: * -> *) l where Source #
Instances
data MultiLocalVarDeclCommonAttrsL Source #
Instances
data LocalVarInitL Source #
Instances
data IsOptional Source #
Constructors
| Optional | |
| NotOptional |
data OptLocalVarInitL Source #
Instances
| KDynCase OptLocalVarInit OptLocalVarInitL Source # | |
Defined in Cubix.Language.Parametric.Syntax.VarDecl Methods kdyncase :: forall (e :: Type -> Type) b. OptLocalVarInit e b -> Maybe (b :~: OptLocalVarInitL) # | |
data OptLocalVarInit e l where Source #
Constructors
| JustLocalVarInit :: e LocalVarInitL -> OptLocalVarInit e OptLocalVarInitL | |
| NoLocalVarInit :: OptLocalVarInit e OptLocalVarInitL |
Instances
data LocalVarDeclAttrsL Source #
Instances
| KDynCase EmptyLocalVarDeclAttrs LocalVarDeclAttrsL Source # | |
Defined in Cubix.Language.Parametric.Syntax.VarDecl Methods kdyncase :: forall (e :: Type -> Type) b. EmptyLocalVarDeclAttrs e b -> Maybe (b :~: LocalVarDeclAttrsL) # | |
| KDynCase ArrayDimVarDeclAttrs LocalVarDeclAttrsL Source # | |
Defined in Cubix.Language.Java.Parametric.Common.Types Methods kdyncase :: forall (e :: Type -> Type) b. ArrayDimVarDeclAttrs e b -> Maybe (b :~: LocalVarDeclAttrsL) # | |
| KDynCase CLocalVarAttrs LocalVarDeclAttrsL Source # | |
Defined in Cubix.Language.C.Parametric.Common.Types Methods kdyncase :: forall (e :: Type -> Type) b. CLocalVarAttrs e b -> Maybe (b :~: LocalVarDeclAttrsL) # | |
data TupleBinder e l where Source #
Represents declaring a list of identifiers, where the list of identifiers should be thought of a single entity being declared. Not to be used as the LHS of an assignment
This models the (x,y) = (1,2) pattern found in Haskell, or "local x,y" in Lua
Constructors
| TupleBinder :: e [IdentL] -> TupleBinder e VarDeclBinderL |
Instances
data IdentIsVarDeclBinder (e :: Type -> Type) i Source #
Constructors
| i ~ VarDeclBinderL => IdentIsVarDeclBinder (e IdentL) |
Instances
data EmptyLocalVarDeclAttrs (e :: * -> *) l where Source #
Constructors
| EmptyLocalVarDeclAttrs :: EmptyLocalVarDeclAttrs e LocalVarDeclAttrsL |
Instances
data VarDeclBinderL Source #
Instances
data SingleLocalVarDeclL Source #
See MultiLocalVarDecl spec
If no LocalVarInit is present, then the declared variable is unitialized, and may not be referenced until another language If a LocalVarInit is present, then it is executed immediately, before placing the variable in scope, and the result is stored in the declared variable.
We assume this variable can only be referenced by something enclosed by the local block which contains an identifier contained within the var binder, or at least by something assigned to some value derived from such a reference.
This forbids a newly-declared variable from referring to itself (sorry Haskell) This does not model C's "static" keyword
FIXME: So.....I wrote that variables declared without an initializer are unitialized, but that does not model Lua. Luckily, I don't actually depend on this anywhere.
Instances
data SingleLocalVarDecl e l where Source #
Constructors
| SingleLocalVarDecl :: e LocalVarDeclAttrsL -> e VarDeclBinderL -> e OptLocalVarInitL -> SingleLocalVarDecl e SingleLocalVarDeclL |
Instances
data EmptyMultiLocalVarDeclCommonAttrs (e :: * -> *) l Source #
Instances
data MultiLocalVarDeclL Source #
Informal spec:
There is a notion of variable scope. Executing a MultiLocalVarDecl statement places each local variable declared into scope. Our intention is that MultiLocalVarDecl is only to be used for local declarations, although we have not yet found a reason why it can't be used for top-level variable declarations as in C.
- - Multi local var decl Each variable declaration has no effect save putting the variable into scope, and executing the initializer expression. Initializer expressions, if present, are executed in left-to-right order. If the language has a notion of an initialized variable, then all declarations for which an initializer is present will be considered initialized.
Executing a MultiLocalVarDecl will execute all contained SingleLocalVardecl
Note: C++ variable declarations cannot use this, because the declarations are effectful FIXME: Does not really give a good account for space allocation (e.g.: references to local variables)
Instances
data MultiLocalVarDecl e l where Source #
Constructors
| MultiLocalVarDecl :: e MultiLocalVarDeclCommonAttrsL -> e [SingleLocalVarDeclL] -> MultiLocalVarDecl e MultiLocalVarDeclL |
Instances
See spec for assign
We assume that AssignOpEquals has, as its associated f_op, the function f(x,y)=(typeof x)y where (typeof x)y denotes a type conversion from y to the type of x. We leave it unspecified what exactly that means
Instances
data AssignOpEquals (e :: * -> *) l where Source #
Constructors
| AssignOpEquals :: AssignOpEquals e AssignOpL |
Instances
Instances
Instances
The Assign node must have semantics of the following form:
store(lhs',f_op(lhs', eval(rhs))) where lhs' = evalToLoc(lhs)
where eval and evalToLoc are arbitrary evaluation function (potentially with side effects)
The lhs must be evaluated before the rhs.
Note that C can contain arbitrary function calls in lvalues
If an assign may be used in an expression context, then the store takes effect before its return value, all effects in eval(rhs) take effect before the return, and the return value is the value assigned to lhs
If the LHS is a variable, it will be considered initialized after execution of the Assign
FIXME: This spec should maybe contain something like "every var init can be a valid assign", because there are restrictions on assignments, e.g.: C can assign between lvalues with partial overlap. This opens up a rabbit hole of possible constraints we need to specify to avoid allowing transformations to create invalid programs
Instances
data Assign e l where Source #
Instances
data BlockItemL Source #
Instances
Instances
| KDynCase EmptyBlockEnd BlockEndL Source # | |
Defined in Cubix.Language.Parametric.Syntax.VarDecl | |
| KDynCase LuaBlockEnd BlockEndL Source # | |
Defined in Cubix.Language.Lua.Parametric.Common.Types | |
| InjF MLuaSig (Maybe [ExpL]) BlockEndL Source # | |
Defined in Cubix.Language.Lua.Parametric.Common.Types Methods injF :: forall h (a :: Type -> Type). CxtS h MLuaSig a (Maybe [ExpL]) -> CxtS h MLuaSig a BlockEndL Source # projF' :: forall h p (a :: Type -> Type). Cxt h (Sum MLuaSig :&: p) a BlockEndL -> Maybe (Cxt h (Sum MLuaSig :&: p) a (Maybe [ExpL])) Source # projF :: forall h (a :: Type -> Type). CxtS h MLuaSig a BlockEndL -> Maybe (CxtS h MLuaSig a (Maybe [ExpL])) Source # | |
data EmptyBlockEnd (e :: * -> *) l where Source #
Constructors
| EmptyBlockEnd :: EmptyBlockEnd e BlockEndL |
Instances
Instances
Block has the following semantics * Any variable introduced by MultiLocalVarDecl may not be referenced outside of the items contained in this block. * Beware that languages such as JavaScript have assignment constructs which do not obey this. We place * no limitation on the visibilty of other kinds of declarations.
We are also using this to model function bodies in Python, though these have the additional restriction of being nonempty
Constructors
| Block :: e [BlockItemL] -> e BlockEndL -> Block e BlockL |
Instances
data EmptyBlockItem (e :: * -> *) l where Source #
This is inserted at the end of blocks so that there's a place to insert at the end of blocks, and so that the sort of empty block-item lists can be correctly determined
This is a bit of a hack....but, it's actually kinda nice in some ways
Constructors
| EmptyBlockItem :: EmptyBlockItem e BlockItemL |
Instances
pattern JustLocalVarInit' :: (OptLocalVarInit :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarInitL -> CxtS h fs a OptLocalVarInitL Source #
iJustLocalVarInit :: forall h fs a j. ((:-<:) OptLocalVarInit fs, InjF fs OptLocalVarInitL j) => CxtS h fs a LocalVarInitL -> CxtS h fs a j Source #
pattern NoLocalVarInit' :: (OptLocalVarInit :-<: fs, All HFunctor fs) => CxtS h fs a OptLocalVarInitL Source #
iNoLocalVarInit :: forall h fs a j. ((:-<:) OptLocalVarInit fs, InjF fs OptLocalVarInitL j) => CxtS h fs a j Source #
pattern EmptyLocalVarDeclAttrs' :: (EmptyLocalVarDeclAttrs :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarDeclAttrsL Source #
iEmptyLocalVarDeclAttrs :: forall h fs a j. ((:-<:) EmptyLocalVarDeclAttrs fs, InjF fs LocalVarDeclAttrsL j) => CxtS h fs a j Source #
pattern TupleBinder' :: (TupleBinder :-<: fs, All HFunctor fs) => CxtS h fs a [IdentL] -> CxtS h fs a VarDeclBinderL Source #
iTupleBinder :: forall h fs a j. ((:-<:) TupleBinder fs, InjF fs VarDeclBinderL j) => CxtS h fs a [IdentL] -> CxtS h fs a j Source #
pattern IdentIsVarDeclBinder' :: (IdentIsVarDeclBinder :-<: fs, All HFunctor fs) => CxtS h fs a IdentL -> CxtS h fs a VarDeclBinderL Source #
iIdentIsVarDeclBinder :: forall h fs a j. ((:-<:) IdentIsVarDeclBinder fs, InjF fs VarDeclBinderL j) => CxtS h fs a IdentL -> CxtS h fs a j Source #
pattern SingleLocalVarDecl' :: (SingleLocalVarDecl :-<: fs, All HFunctor fs) => CxtS h fs a LocalVarDeclAttrsL -> CxtS h fs a VarDeclBinderL -> CxtS h fs a OptLocalVarInitL -> CxtS h fs a SingleLocalVarDeclL Source #
iSingleLocalVarDecl :: forall h fs a j. ((:-<:) SingleLocalVarDecl fs, InjF fs SingleLocalVarDeclL j) => CxtS h fs a LocalVarDeclAttrsL -> CxtS h fs a VarDeclBinderL -> CxtS h fs a OptLocalVarInitL -> CxtS h fs a j Source #
pattern EmptyMultiLocalVarDeclCommonAttrs' :: (EmptyMultiLocalVarDeclCommonAttrs :-<: fs, All HFunctor fs) => CxtS h fs a MultiLocalVarDeclCommonAttrsL Source #
iEmptyMultiLocalVarDeclCommonAttrs :: forall h fs a j. ((:-<:) EmptyMultiLocalVarDeclCommonAttrs fs, InjF fs MultiLocalVarDeclCommonAttrsL j) => CxtS h fs a j Source #
pattern MultiLocalVarDecl' :: (MultiLocalVarDecl :-<: fs, All HFunctor fs) => CxtS h fs a MultiLocalVarDeclCommonAttrsL -> CxtS h fs a [SingleLocalVarDeclL] -> CxtS h fs a MultiLocalVarDeclL Source #
iMultiLocalVarDecl :: forall h fs a j. ((:-<:) MultiLocalVarDecl fs, InjF fs MultiLocalVarDeclL j) => CxtS h fs a MultiLocalVarDeclCommonAttrsL -> CxtS h fs a [SingleLocalVarDeclL] -> CxtS h fs a j Source #
pattern AssignOpEquals' :: (AssignOpEquals :-<: fs, All HFunctor fs) => CxtS h fs a AssignOpL Source #
iAssignOpEquals :: forall h fs a j. ((:-<:) AssignOpEquals fs, InjF fs AssignOpL j) => CxtS h fs a j Source #
pattern Assign' :: (Assign :-<: fs, All HFunctor fs) => CxtS h fs a LhsL -> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a AssignL Source #
iAssign :: forall h fs a j. ((:-<:) Assign fs, InjF fs AssignL j) => CxtS h fs a LhsL -> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a j Source #
pattern EmptyBlockEnd' :: (EmptyBlockEnd :-<: fs, All HFunctor fs) => CxtS h fs a BlockEndL Source #
iEmptyBlockEnd :: forall h fs a j. ((:-<:) EmptyBlockEnd fs, InjF fs BlockEndL j) => CxtS h fs a j Source #
pattern Block' :: (Block :-<: fs, All HFunctor fs) => CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a BlockL Source #
iBlock :: forall h fs a j. ((:-<:) Block fs, InjF fs BlockL j) => CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a j Source #
pattern EmptyBlockItem' :: (EmptyBlockItem :-<: fs, All HFunctor fs) => CxtS h fs a BlockItemL Source #
iEmptyBlockItem :: forall h fs a j. ((:-<:) EmptyBlockItem fs, InjF fs BlockItemL j) => CxtS h fs a j Source #