{-# LANGUAGE TypeFamilies #-}
module HaScalaM.Instances.Pat where
import HaScalaM.Classes.Base
import HaScalaM.Classes.Pat
import HaScalaM.Classes.Term
import HaScalaM.Types.Pat
import HaScalaM.Types.Tilde
instance Pat p => Tree (SmArgClauseP p)
instance Pat p => SyntaxValuesClauses p (SmArgClauseP p)
where values :: SmArgClauseP p -> [p]
values (SmArgClauseP [p]
vs) = [p]
vs
instance Pat p => ArgClause p (SmArgClauseP p)
instance Pat p => WithPats p (SmArgClauseP p)
where pats :: SmArgClauseP p -> [p]
pats (SmArgClauseP [p]
ps) = [p]
ps
instance Pat p => ArgClauseP p (SmArgClauseP p)
instance Tree SmPatP
instance ( Term t
, Pat p
, ArgClauseP p ac
) => Tree (SmExtractP t p ac)
instance ( Term t
, Pat p
, ArgClauseP p ac
) => Apply t p ac (SmExtractP t p ac)
where fun :: SmExtractP t p ac -> t
fun (SmExtractP t
f ac
_) = t
f
argClause :: SmExtractP t p ac -> ac
argClause (SmExtractP t
_ ac
ac) = ac
ac
instance ( NameT tn
, Pat p
, ArgClauseP p ac
) => Tree (SmExtractInfixP tn p ac)
instance ( NameT tn
, Pat p
, ArgClauseP p ac
) => Infix p tn ac (SmExtractInfixP tn p ac)
where lhs :: SmExtractInfixP tn p ac -> p
lhs (SmExtractInfixP p
l tn
_ ac
_) = p
l
op :: SmExtractInfixP tn p ac -> tn
op (SmExtractInfixP p
_ tn
n ac
_) = tn
n
arg :: SmExtractInfixP tn p ac -> ac
arg (SmExtractInfixP p
_ tn
_ ac
ac) = ac
ac
instance Term t => Tree (SmMacroP t)
instance Term t => WithBody t (SmMacroP t)
where body :: SmMacroP t -> t
body (SmMacroP t
b) = t
b
instance Pat p => Tree (SmTupleP p)
instance Pat p => Tuple p (SmTupleP p)
where args :: SmTupleP p -> [p]
args (SmTupleP [p]
as) = [p]
as
instance NameT tn => Tree (SmVarP tn)
instance NameT tn => Member tn (SmVarP tn)
where name :: SmVarP tn -> tn
name (SmVarP tn
n) = tn
n
instance NameT tn => MemberT tn (SmVarP tn)
instance Tree SmPat
instance Pat SmPat