module HaScalaM.Instances.Enums where
import HaScalaM.Classes.Base
import HaScalaM.Classes.Enums
import HaScalaM.Classes.Pat
import HaScalaM.Classes.Term
import HaScalaM.Types.Enums
import HaScalaM.Types.Tilde (SmEnumerator)
instance ( Pat p
, Term b
) => Tree (SmCaseGeneratorE p b)
instance ( Pat p
, Term b
) => Enumerator (SmCaseGeneratorE p b)
instance ( Pat p
, Term b
) => WithBody b (SmCaseGeneratorE p b)
where body :: SmCaseGeneratorE p b -> b
body (SmCaseGeneratorE p
_ b
rhs) = b
rhs
instance ( Pat p
, Term b
) => Assign p b (SmCaseGeneratorE p b)
where pat :: SmCaseGeneratorE p b -> p
pat (SmCaseGeneratorE p
p b
_) = p
p
rhs :: SmCaseGeneratorE p b -> b
rhs (SmCaseGeneratorE p
_ b
r) = b
r
instance ( Pat p
, Term b
) => CaseGenerator p b (SmCaseGeneratorE p b)
instance ( Pat p
, Term b
) => Tree (SmGeneratorE p b)
instance ( Pat p
, Term b
) => Enumerator (SmGeneratorE p b)
instance ( Pat p
, Term b
) => WithBody b (SmGeneratorE p b)
where body :: SmGeneratorE p b -> b
body (SmGeneratorE p
_ b
rhs) = b
rhs
instance ( Pat p
, Term b
) => Assign p b (SmGeneratorE p b)
where pat :: SmGeneratorE p b -> p
pat (SmGeneratorE p
p b
_) = p
p
rhs :: SmGeneratorE p b -> b
rhs (SmGeneratorE p
_ b
r) = b
r
instance ( Pat p
, Term b
) => Generator p b (SmGeneratorE p b)
instance Term c => Tree (SmGuardE c)
instance Term c => WithCond c (SmGuardE c)
where cond :: SmGuardE c -> c
cond (SmGuardE c
c) = c
c
instance Term c => Guard c (SmGuardE c)
where cond :: SmGuardE c -> c
cond (SmGuardE c
c) = c
c
instance ( Pat p
, Term b
) => Tree (SmValE p b)
instance ( Pat p
, Term b
) => Enumerator (SmValE p b)
instance ( Pat p
, Term b
) => WithBody b (SmValE p b)
where body :: SmValE p b -> b
body (SmValE p
_ b
rhs) = b
rhs
instance ( Pat p
, Term b
) => Assign p b (SmValE p b)
where pat :: SmValE p b -> p
pat (SmValE p
p b
_) = p
p
rhs :: SmValE p b -> b
rhs (SmValE p
_ b
r) = b
r
instance ( Pat p
, Term b
) => Val p b (SmValE p b)
instance Tree SmEnumerator
instance Enumerator SmEnumerator