HaScalaM.Instances.Term

Orphan instances

Tree SmTerm

Term SmTerm

Template m n t' t ac i p s e => WithTemplate m n t' t ac i p s e (SmNewAnonymousT m n t' t ac i p s e)

Methods

templ :: SmNewAnonymousT m n t' t ac i p s e -> e

ParamClauseT m n p t' t pc => FunctionT m n p pc t' t (SmFunctionT m n p t' t pc)

(ParamClauseT' m n p' t' b' pc', Term t) => WithT'ParamClause m n p' t' b' pc' (SmPolyFunctionT m n p' t' b' pc' t)

Methods

t'paramClause :: SmPolyFunctionT m n p' t' b' pc' t -> pc'

(p ~ SmParamT m n t' t, ParamsType m, ParamT m n p t' t) => ParamClauseT m n p t' t (SmParamClauseT m n p t' t)

Methods

mod' :: SmParamClauseT m n p t' t -> Maybe m

ArgClauseT m t ac => Apply t t ac (SmApplyT m t ac)

Methods

fun :: SmApplyT m t ac -> t

argClause :: SmApplyT m t ac -> ac

(Term t, ArgClauseT' t' ac') => Apply t t' ac' (SmApplyType'T t t' ac')

Methods

fun :: SmApplyType'T t t' ac' -> t

argClause :: SmApplyType'T t t' ac' -> ac'

(Pat p, Term t, Case p t ct) => WithCases p t ct (SmPartialFunctionT p t ct)

Methods

cases :: SmPartialFunctionT p t ct -> [ct]

Case p t ct => WithCases p t ct (SmTryT p t ct)

Methods

cases :: SmTryT p t ct -> [ct]

(p ~ SmParamT m n t' t, ParamsType m, ParamT m n p t' t) => ParamClause m n p (SmParamClauseT m n p t' t)

ParamClauseT m n p t' t pc => Function p pc t (SmContextFunctionT m n p t' t pc)

Methods

paramClause :: SmContextFunctionT m n p t' t pc -> pc

ParamClauseT m n p t' t pc => Function p pc t (SmFunctionT m n p t' t pc)

Methods

paramClause :: SmFunctionT m n p t' t pc -> pc

(NameT tn, ArgClauseT' t' ac', ArgClauseT m t ac) => Infix t tn ac (SmApplyInfixT m tn t t' ac' ac)

Methods

lhs :: SmApplyInfixT m tn t t' ac' ac -> t

op :: SmApplyInfixT m tn t t' ac' ac -> tn

arg :: SmApplyInfixT m tn t t' ac' ac -> ac

(ParamClauseT' m n p' t' b' pc', Term t) => Function p' pc' t (SmPolyFunctionT m n p' t' b' pc' t)

Methods

paramClause :: SmPolyFunctionT m n p' t' b' pc' t -> pc'

(Pat p, Term t) => CaseTree p t (SmCaseCT p t)

Methods

pat :: SmCaseCT p t -> p

(m ~ SmMod, t ~ SmTerm, ArgsType m, Term t) => ArgClauseT m t (SmArgClauseT m t)

Methods

mod :: SmArgClauseT m t -> Maybe m

(Pat p, Term t) => Case p t (SmCaseCT p t)

(Mod m, Name n, Type' t', Term t) => Param m n (SmParamT m n t' t)

Methods

mods' :: SmParamT m n t' t -> [m]

(Mod m, Name n, Type' t', Term t) => ParamT m n (SmParamT m n t' t) t' t

Methods

defaultOpt :: SmParamT m n t' t -> Maybe t

Term t => Tree (SmAssignT t :: Type)

Stat s => Tree (SmBlockT s :: Type)

Term t => Tree (SmDoT t :: Type)

Term t => Tree (SmTupleT t :: Type)

Term t => Tree (SmWhileT t :: Type)

Term t => Tuple t (SmTupleT t)

Methods

args :: SmTupleT t -> [t]

Term t => WithBody t (SmAssignT t)

Methods

body :: SmAssignT t -> t

Term t => WithBody t (SmDoT t)

Methods

body :: SmDoT t -> t

Term t => WithBody t (SmWhileT t)

Methods

body :: SmWhileT t -> t

Stat s => WithExprs s (SmBlockT s)

Methods

exprs :: SmBlockT s -> [s]

Stat s => WithStats s (SmBlockT s)

Methods

stats :: SmBlockT s -> [s]

Term t => WithCond t (SmDoT t)

Methods

cond :: SmDoT t -> t

Term t => WithCond t (SmWhileT t)

Methods

cond :: SmWhileT t -> t

(t ~ SmTerm, ArgsType m, Term t) => ArgClause t (SmArgClauseT m t)

(t ~ SmTerm, ArgsType m, Term t) => SyntaxValuesClauses t (SmArgClauseT m t)

Methods

values :: SmArgClauseT m t -> [t]

(Enumerator e, Term t) => Tree (SmForT e t :: Type)

(Enumerator e, Term t) => Tree (SmForYieldT e t :: Type)

(Mod m, Term t) => Tree (SmIfT m t :: Type)

(ArgsType m, Term t) => Tree (SmArgClauseT m t :: Type)

(Pat p, Term t) => Tree (SmCaseCT p t :: Type)

(Enumerator e, Term t) => WithBody t (SmForT e t)

Methods

body :: SmForT e t -> t

(Enumerator e, Term t) => WithBody t (SmForYieldT e t)

Methods

body :: SmForYieldT e t -> t

(Pat p, Term t) => WithBody t (SmCaseCT p t)

Methods

body :: SmCaseCT p t -> t

(Enumerator e, Term t) => WithExprs e (SmForT e t)

Methods

exprs :: SmForT e t -> [e]

(Enumerator e, Term t) => WithExprs e (SmForYieldT e t)

Methods

exprs :: SmForYieldT e t -> [e]

(Mod m, Term t) => WithMods m (SmIfT m t)

Methods

mods :: SmIfT m t -> [m]

(Enumerator e, Term t) => WithEnums e (SmForT e t)

Methods

enums :: SmForT e t -> [e]

(Enumerator e, Term t) => WithEnums e (SmForYieldT e t)

Methods

enums :: SmForYieldT e t -> [e]

(Mod m, Term t) => WithCond t (SmIfT m t)

Methods

cond :: SmIfT m t -> t

(Pat p, Term t) => WithCondOpt t (SmCaseCT p t)

Methods

cond' :: SmCaseCT p t -> Maybe t

ArgClauseT m t ac => Tree (SmApplyT m t ac :: Type)

(Term t, ArgClauseT' t' ac') => Tree (SmApplyType'T t t' ac' :: Type)

(Pat p, Term t, Case p t ct) => Tree (SmMatchT p t ct :: Type)

(Pat p, Term t, Case p t ct) => Tree (SmPartialFunctionT p t ct :: Type)

Case p t ct => Tree (SmTryT p t ct :: Type)

(Pat p, Term t, Case p t ct) => WithExprs ct (SmMatchT p t ct)

Methods

exprs :: SmMatchT p t ct -> [ct]

(Pat p, Term t, Case p t ct) => WithExprs ct (SmPartialFunctionT p t ct)

Methods

exprs :: SmPartialFunctionT p t ct -> [ct]

Case p t ct => WithExprs ct (SmTryT p t ct)

Methods

exprs :: SmTryT p t ct -> [ct]

(Mod m, Name n, Type' t', Term t) => Member n (SmParamT m n t' t)

Methods

name :: SmParamT m n t' t -> n

(Mod m, Name n, Type' t', Term t) => Tree (SmParamT m n t' t :: Type)

(Mod m, Name n, Type' t', Term t) => WithDeclTpeOpt t' (SmParamT m n t' t)

Methods

decltpe' :: SmParamT m n t' t -> Maybe t'

(p ~ SmParamT m n t' t, ParamsType m, ParamT m n p t' t) => SyntaxValuesClauses p (SmParamClauseT m n p t' t)

Methods

values :: SmParamClauseT m n p t' t -> [p]

(p ~ SmParamT m n t' t, ParamsType m, ParamT m n p t' t) => Tree (SmParamClauseT m n p t' t :: Type)

(NameT tn, ArgClauseT' t' ac', ArgClauseT m t ac) => Tree (SmApplyInfixT m tn t t' ac' ac :: Type)

ParamClauseT m n p t' t pc => Tree (SmContextFunctionT m n p t' t pc :: Type)

ParamClauseT m n p t' t pc => Tree (SmFunctionT m n p t' t pc :: Type)

ParamClauseT m n p t' t pc => WithBody t (SmContextFunctionT m n p t' t pc)

Methods

body :: SmContextFunctionT m n p t' t pc -> t

ParamClauseT m n p t' t pc => WithBody t (SmFunctionT m n p t' t pc)

Methods

body :: SmFunctionT m n p t' t pc -> t

(ParamClauseT' m n p' t' b' pc', Term t) => Tree (SmPolyFunctionT m n p' t' b' pc' t :: Type)

(ParamClauseT' m n p' t' b' pc', Term t) => WithBody t (SmPolyFunctionT m n p' t' b' pc' t)

Methods

body :: SmPolyFunctionT m n p' t' b' pc' t -> t

Template m n t' t ac i p s e => Tree (SmNewAnonymousT m n t' t ac i p s e :: Type)