module Conversions.ToScala.Pattern where

import qualified SyntaxTrees.Haskell.Common  as H
import qualified SyntaxTrees.Haskell.Pattern as H
import qualified SyntaxTrees.Scala.Common    as S
import qualified SyntaxTrees.Scala.Pattern   as S

import Conversions.ToScala.Common (literal, qCtor, qCtorOp, var)
import Data.Maybe                 (mapMaybe)


pattern' :: H.Pattern -> S.Pattern
pattern' :: Pattern -> Pattern
pattern' (H.CtorPattern QCtor
x [Pattern]
y) = QCtor -> [Pattern] -> Pattern
S.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
S.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 -> [Pattern] -> Pattern
S.CtorPattern (QCtor -> QCtor
qCtor QCtor
x)
                                               (Var -> Pattern
S.VarPattern forall b c a. (b -> c) -> (a -> b) -> a -> c
. Var -> Var
var forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst 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) = QCtor -> [Pattern] -> Pattern
S.CtorPattern (QCtor -> QCtor
qCtor QCtor
x)
                                               (Var -> Pattern
S.VarPattern forall b c a. (b -> c) -> (a -> b) -> a -> c
. Var -> Var
var forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Var, Maybe Pattern)]
y)
pattern' (H.AliasedPattern Var
x Pattern
y) = Var -> Pattern -> Pattern
S.AliasedPattern (Var -> Var
var Var
x) (Pattern -> Pattern
pattern' Pattern
y)
pattern' (H.ListPattern [Pattern]
x) = QCtor -> [Pattern] -> Pattern
S.CtorPattern  (Maybe Package -> Ctor -> QCtor
S.QCtor forall a. Maybe a
Nothing forall a b. (a -> b) -> a -> b
$ String -> Ctor
S.Ctor String
"List") (Pattern -> Pattern
pattern' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Pattern]
x)
pattern' (H.TuplePattern [Pattern]
x) = [Pattern] -> Pattern
S.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
S.VarPattern forall a b. (a -> b) -> a -> b
$ Var -> Var
var Var
x
pattern' (H.LitPattern Literal
x) = Literal -> Pattern
S.LitPattern forall a b. (a -> b) -> a -> b
$ Literal -> Literal
literal Literal
x
pattern' Pattern
H.Wildcard = Pattern
S.Wildcard


extractVar :: H.Pattern -> Maybe H.Var
extractVar :: Pattern -> Maybe Var
extractVar (H.VarPattern Var
x) = forall a. a -> Maybe a
Just Var
x
extractVar Pattern
_                = forall a. Maybe a
Nothing

extractVars :: [H.Pattern] -> [H.Var]
extractVars :: [Pattern] -> [Var]
extractVars [Pattern]
x = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Pattern -> Maybe Var
extractVar [Pattern]
x

allVars :: [H.Pattern] -> Bool
allVars :: [Pattern] -> Bool
allVars [Pattern]
x = forall (t :: * -> *) a. Foldable t => t a -> Int
length (forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Pattern -> Maybe Var
extractVar [Pattern]
x) forall a. Eq a => a -> a -> Bool
== forall (t :: * -> *) a. Foldable t => t a -> Int
length [Pattern]
x

extractVar' :: S.Pattern -> Maybe S.Var
extractVar' :: Pattern -> Maybe Var
extractVar' (S.VarPattern Var
x) = forall a. a -> Maybe a
Just Var
x
extractVar' Pattern
_                = forall a. Maybe a
Nothing

extractVars' :: [S.Pattern] -> [S.Var]
extractVars' :: [Pattern] -> [Var]
extractVars' [Pattern]
x = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Pattern -> Maybe Var
extractVar' [Pattern]
x

allVars' :: [S.Pattern] -> Bool
allVars' :: [Pattern] -> Bool
allVars' [Pattern]
x = forall (t :: * -> *) a. Foldable t => t a -> Int
length (forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Pattern -> Maybe Var
extractVar' [Pattern]
x) forall a. Eq a => a -> a -> Bool
== forall (t :: * -> *) a. Foldable t => t a -> Int
length [Pattern]
x