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)


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

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