module Conversions.ToPurescript.Pattern where

import qualified SyntaxTrees.Haskell.Pattern    as H
import qualified SyntaxTrees.Purescript.Common  as P
import qualified SyntaxTrees.Purescript.Pattern as P

import Conversions.ToPurescript.Common (literal, qCtor, qCtorOp, var)


pattern' :: H.Pattern -> P.Pattern
pattern' :: Pattern -> Pattern
pattern' (H.CtorPattern QCtor
x [Pattern]
y) = QCtor -> [Pattern] -> Pattern
P.CtorPattern (QCtor -> QCtor
qCtor QCtor
x) (Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern]
y)
pattern' (H.InfixCtorPattern QCtorOp
x [Pattern]
y) = QCtorOp -> [Pattern] -> Pattern
P.InfixCtorPattern (QCtorOp -> QCtorOp
qCtorOp QCtorOp
x)
                                                       (Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern]
y)
pattern' (H.RecordPattern QCtor
x [(Var, Maybe Pattern)]
y) = QCtor -> [(Var, Maybe Pattern)] -> Pattern
P.RecordPattern (QCtor -> QCtor
qCtor QCtor
x)
                                ((\(Var
z, Maybe Pattern
t) -> (Var -> Var
var Var
z, Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Pattern
t)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Var, Maybe Pattern)]
y)
pattern' (H.WildcardRecordPattern QCtor
x [(Var, Maybe Pattern)]
y) = Pattern -> Pattern
pattern' forall a b. (a -> b) -> a -> b
$ QCtor -> [(Var, Maybe Pattern)] -> Pattern
H.RecordPattern QCtor
x [(Var, Maybe Pattern)]
y
pattern' (H.AliasedPattern Var
x Pattern
y) = Var -> Pattern -> Pattern
P.AliasedPattern (Var -> Var
var Var
x) (Pattern -> Pattern
pattern' Pattern
y)
pattern' (H.ListPattern [Pattern]
x) = QCtor -> [Pattern] -> Pattern
P.CtorPattern
  (Maybe Module -> Ctor -> QCtor
P.QCtor forall a. Maybe a
Nothing forall a b. (a -> b) -> a -> b
$ String -> Ctor
P.Ctor String
"Array") (Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern]
x)
pattern' (H.TuplePattern [Pattern]
x) = [Pattern] -> Pattern
P.TuplePattern forall a b. (a -> b) -> a -> b
$ Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern]
x
pattern' (H.VarPattern Var
x) = Var -> Pattern
P.VarPattern forall a b. (a -> b) -> a -> b
$ Var -> Var
var Var
x
pattern' (H.LitPattern Literal
x) = Literal -> Pattern
P.LitPattern forall a b. (a -> b) -> a -> b
$ Literal -> Literal
literal Literal
x
pattern' Pattern
H.Wildcard = Pattern
P.Wildcard