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)


-- E ---------------------------------------------------------------------------

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