module HaScalaM.Instances.Enums where
import HaScalaM.Classes.Base
import HaScalaM.Classes.Enums
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
) => WithBody b (SmCaseGeneratorE p b) where
body :: SmCaseGeneratorE p b -> b
body (SmCaseGeneratorE p
_ b
rhs) = b
rhs
instance ( Pat p
, Term b
) => CaseGenerator p b (SmCaseGeneratorE p b)
where patCG :: SmCaseGeneratorE p b -> p
patCG (SmCaseGeneratorE p
p b
_) = p
p
rhsCG :: SmCaseGeneratorE p b -> b
rhsCG (SmCaseGeneratorE p
_ b
r) = b
r
instance ( Pat p
, Term b
) => Tree (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
, WithBody (SmGeneratorE p b) b
) => Generator p b (SmGeneratorE p b)
where patG :: SmGeneratorE p b -> p
patG (SmGeneratorE p
p b
_) = p
p
rhsG :: SmGeneratorE p b -> b
rhsG (SmGeneratorE p
_ b
r) = b
r
instance Term b => Tree (SmGuardE b)
instance Term b => Guard b (SmGuardE b)
where condG :: SmGuardE b -> b
condG (SmGuardE b
c) = b
c
instance ( Pat p
, Term b
) => Tree (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
) => Val p b (SmValE p b)
where patV :: SmValE p b -> p
patV (SmValE p
p b
_) = p
p
rhsV :: SmValE p b -> b
rhsV (SmValE p
_ b
r) = b
r
instance Tree SmEnumerator
instance Enumerator SmEnumerator