{-# LANGUAGE AllowAmbiguousTypes #-}
module HaScalaM.Types.Pat where

import HaScalaM.Classes
import HaScalaM.Classes.Pat
import HaScalaM.Classes.Term
import HaScalaM.Classes.Type
import HaScalaM.Types.Ref


--------------------------------------------------------------------------- P --

data SmExtractP t p ac where
    SmExtractP :: ( Term t
                  , Pat p
                  , ArgClauseP p ac
                  ) => { forall t p ac. SmExtractP t p ac -> t
funXP :: t
                       , forall t p ac. SmExtractP t p ac -> ac
argClauseXP :: ac } -> SmExtractP t p ac

data SmExtractInfixP tn p ac where
    SmExtractInfixP :: ( NameT tn
                       , Pat p
                       , ArgClauseP p ac
                       ) => { forall tn p ac. SmExtractInfixP tn p ac -> p
lhsXxP :: p
                            , forall tn p ac. SmExtractInfixP tn p ac -> tn
opXxP :: tn
                            , forall tn p ac. SmExtractInfixP tn p ac -> ac
argClauseXxP :: ac } -> SmExtractInfixP tn p ac

data SmMacroP t where
    SmMacroP :: Term t => { forall t. SmMacroP t -> t
bodyMP :: t } -> SmMacroP t

data SmTupleP p where
    SmTupleP :: Pat p => { forall p. SmTupleP p -> [p]
argsTP :: [p] } -> SmTupleP p

data SmVarP tn where
    SmVarP :: NameT tn => { forall tn. SmVarP tn -> tn
varVP :: tn } -> SmVarP tn