module Conversions.ToPurescript.Common where

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

import           Data.Map (Map)
import qualified Data.Map as Map


var :: H.Var -> P.Var
var :: Var -> Var
var (H.Var String
x) = String -> Var
P.Var forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming String
x

ctor :: H.Ctor -> P.Ctor
ctor :: Ctor -> Ctor
ctor (H.Ctor String
x) = String -> Ctor
P.Ctor forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming String
x

varOp :: H.VarOp -> P.VarOp
varOp :: VarOp -> VarOp
varOp (H.VarOp String
x) = String -> VarOp
P.VarOp forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming String
x

ctorOp :: H.CtorOp -> P.CtorOp
ctorOp :: CtorOp -> CtorOp
ctorOp (H.CtorOp String
x) = String -> CtorOp
P.CtorOp forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming String
x

varOpFn :: H.Var -> P.Var
varOpFn :: Var -> Var
varOpFn (H.Var String
x) = String -> Var
P.Var forall a b. (a -> b) -> a -> b
$ forall k. Ord k => Map k k -> k -> k
find Map String String
varOpFnMap forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming String
x

class' :: H.Class -> P.Class
class' :: Class -> Class
class' (H.Class String
x) = String -> Class
P.Class String
x


module' :: H.Module -> P.Module
module' :: Module -> Module
module' (H.Module [String]
x) = [String] -> Module
P.Module forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
x

qualifier' :: H.Module -> P.Module
qualifier' :: Module -> Module
qualifier' (H.Module [String]
x) = [String] -> Module
P.Module forall a b. (a -> b) -> a -> b
$ String -> String
replaceNaming forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
x


literal :: H.Literal -> P.Literal
literal :: Literal -> Literal
literal Literal
H.UnitLit       = Literal
P.UnitLit
literal (H.BoolLit Bool
x)   = Bool -> Literal
P.BoolLit Bool
x
literal (H.IntLit String
x)    = String -> Literal
P.IntLit String
x
literal (H.FloatLit String
x)  = String -> Literal
P.NumberLit String
x
literal (H.CharLit Char
x)   = Char -> Literal
P.CharLit Char
x
literal (H.StringLit String
x) = String -> Literal
P.StringLit String
x



qVar :: H.QVar -> P.QVar
qVar :: QVar -> QVar
qVar (H.QVar Maybe Module
x Var
y) = Maybe Module -> Var -> QVar
P.QVar (Module -> Module
qualifier' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Module
x) (Var -> Var
var Var
y)

qVarOp :: H.QVarOp -> P.QVarOp
qVarOp :: QVarOp -> QVarOp
qVarOp (H.QVarOp Maybe Module
x VarOp
y) = Maybe Module -> VarOp -> QVarOp
P.QVarOp (Module -> Module
qualifier' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Module
x) (VarOp -> VarOp
varOp VarOp
y)

qCtor :: H.QCtor -> P.QCtor
qCtor :: QCtor -> QCtor
qCtor (H.QCtor Maybe Module
x Ctor
y) = Maybe Module -> Ctor -> QCtor
P.QCtor (Module -> Module
qualifier' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Module
x) (Ctor -> Ctor
ctor Ctor
y)

qCtorOp :: H.QCtorOp -> P.QCtorOp
qCtorOp :: QCtorOp -> QCtorOp
qCtorOp (H.QCtorOp Maybe Module
x CtorOp
y) = Maybe Module -> CtorOp -> QCtorOp
P.QCtorOp (Module -> Module
qualifier' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Module
x) (CtorOp -> CtorOp
ctorOp CtorOp
y)

qClass :: H.QClass -> P.QClass
qClass :: QClass -> QClass
qClass (H.QClass Maybe Module
x Class
y) = Maybe Module -> Class -> QClass
P.QClass (Module -> Module
qualifier' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Module
x) (Class -> Class
class' Class
y)


replaceNaming :: String -> String
replaceNaming :: String -> String
replaceNaming String
x = forall k. Ord k => Map k k -> k -> k
find Map Char Char
charMap forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall k. Ord k => Map k k -> k -> k
find Map String String
globalMap String
x

find :: Ord k => Map k k -> k -> k
find :: forall k. Ord k => Map k k -> k -> k
find Map k k
x k
y = forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault k
y k
y Map k k
x

globalMap :: Map String String
globalMap :: Map String String
globalMap = Map String String
varOpMap forall a. Semigroup a => a -> a -> a
<> Map String String
ctorOpMap forall a. Semigroup a => a -> a -> a
<> Map String String
varMap forall a. Semigroup a => a -> a -> a
<> Map String String
ctorMap


charMap :: Map Char Char
charMap :: Map Char Char
charMap = forall k a. Map k a
Map.empty

varOpMap :: Map String String
varOpMap :: Map String String
varOpMap = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String
".", String
"<<<"), (String
"++", String
"<>"),
                         (String
"<&>", String
"<#>"),
                         (String
",", String
"/\\"), (String
",,", String
"Tuple3"),
                         (String
",,,", String
"Tuple4"), (String
",,,,", String
"Tuple5")]

ctorOpMap :: Map String String
ctorOpMap :: Map String String
ctorOpMap = forall k a. Map k a
Map.empty

varMap :: Map String String
varMap :: Map String String
varMap = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String
"fmap", String
"map")]

ctorMap :: Map String String
ctorMap :: Map String String
ctorMap = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String
"True", String
"true"), (String
"False", String
"false")]

varOpFnMap :: Map String String
varOpFnMap :: Map String String
varOpFnMap = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String
"==", String
"eq"), (String
"/=", String
"notEq"),
                         (String
"<>", String
"append"), (String
"<$>", String
"map"),
                         (String
"<*>", String
"apply"), (String
">>=", String
"bind") ]