-- | Defines operator precedence.
module Language.Drasil.ModelExpr.Precedence where

import Language.Drasil.ModelExpr.Lang 

-- These precedences are inspired from Haskell/F# 
-- as documented at http://kevincantu.org/code/operators.html
-- They are all multiplied by 10, to leave room to weave things in between

-- | prec2Arith - precedence for arithmetic-related binary operations.
prec2Arith :: ArithBinOp -> Int
prec2Arith :: ArithBinOp -> Int
prec2Arith Frac = 190
prec2Arith Pow  = 200
prec2Arith Subt = 180

-- | prec2Bool - precedence for boolean-related binary operations.
prec2Bool :: BoolBinOp -> Int
prec2Bool :: BoolBinOp -> Int
prec2Bool _ = 130

-- | prec2Eq - precedence for equality-related binary operations.
prec2Eq :: EqBinOp -> Int
prec2Eq :: EqBinOp -> Int
prec2Eq _  = 130

-- | prec2LA - precedence for access-related binary operations.
prec2LA :: LABinOp -> Int
prec2LA :: LABinOp -> Int
prec2LA _ = 250

-- | prec2Ord - precedence for order-related binary operations.
prec2Ord :: OrdBinOp -> Int
prec2Ord :: OrdBinOp -> Int
prec2Ord _  = 130

prec2Spc :: SpaceBinOp -> Int
prec2Spc :: SpaceBinOp -> Int
prec2Spc _ = 170

prec2Stat :: StatBinOp -> Int
prec2Stat :: StatBinOp -> Int
prec2Stat _ = 130

-- | prec2VVV - precedence for Vec->Vec->Vec-related binary operations.
prec2VVV :: VVVBinOp -> Int
prec2VVV :: VVVBinOp -> Int
prec2VVV _ = 190

-- | prec2VVN - precedence for Vec->Vec->Num-related binary operations.
prec2VVN :: VVNBinOp -> Int
prec2VVN :: VVNBinOp -> Int
prec2VVN _ = 190

-- | precA - precedence for arithmetic-related Binary-Associative (Commutative) operators.
precA :: AssocArithOper -> Int
precA :: AssocArithOper -> Int
precA MulI  = 190
precA MulRe = 190
precA AddI  = 180
precA AddRe = 180

-- | precB - precedence for boolean-related Binary-Associative (Commutative) operators.
precB :: AssocBoolOper -> Int
precB :: AssocBoolOper -> Int
precB And         = 120
precB Or          = 110
precB Equivalence = 100

-- | prec1 - precedence of unary operators.
prec1 :: UFunc -> Int
prec1 :: UFunc -> Int
prec1 Neg = 230
prec1 Exp = 200
prec1 _   = 250

-- | prec1B - precedence of boolean-related unary operators.
prec1B :: UFuncB -> Int
prec1B :: UFuncB -> Int
prec1B Not = 230

-- | prec1VV - precedence of vector-vector-related unary operators.
prec1VV :: UFuncVV -> Int
prec1VV :: UFuncVV -> Int
prec1VV _ = 250

-- | prec1Vec - precedence of vector-number-related unary operators.
prec1VN :: UFuncVN -> Int
prec1VN :: UFuncVN -> Int
prec1VN _ = 230

-- | eprec - `ModelExpr` precedence.
mePrec :: ModelExpr -> Int
mePrec :: ModelExpr -> Int
mePrec Lit{}                  = 500
mePrec Spc{}                  = 500
mePrec (AssocA op :: AssocArithOper
op _)          = AssocArithOper -> Int
precA AssocArithOper
op
mePrec (AssocB op :: AssocBoolOper
op _)          = AssocBoolOper -> Int
precB AssocBoolOper
op
mePrec C{}                    = 500
mePrec Deriv{}                = ArithBinOp -> Int
prec2Arith ArithBinOp
Frac
mePrec FCall{}                = 210
mePrec Case{}                 = 200
mePrec Matrix{}               = 220
mePrec (UnaryOp fn :: UFunc
fn _)         = UFunc -> Int
prec1 UFunc
fn
mePrec (UnaryOpB fn :: UFuncB
fn _)        = UFuncB -> Int
prec1B UFuncB
fn
mePrec (UnaryOpVV fn :: UFuncVV
fn _)       = UFuncVV -> Int
prec1VV UFuncVV
fn
mePrec (UnaryOpVN fn :: UFuncVN
fn _)       = UFuncVN -> Int
prec1VN UFuncVN
fn
mePrec (Operator o :: AssocArithOper
o _ _)       = AssocArithOper -> Int
precA AssocArithOper
o
mePrec (ArithBinaryOp bo :: ArithBinOp
bo _ _) = ArithBinOp -> Int
prec2Arith ArithBinOp
bo
mePrec (BoolBinaryOp bo :: BoolBinOp
bo _ _)  = BoolBinOp -> Int
prec2Bool BoolBinOp
bo
mePrec (EqBinaryOp bo :: EqBinOp
bo _ _)    = EqBinOp -> Int
prec2Eq EqBinOp
bo
mePrec (LABinaryOp bo :: LABinOp
bo _ _)    = LABinOp -> Int
prec2LA LABinOp
bo
mePrec (SpaceBinaryOp bo :: SpaceBinOp
bo _ _) = SpaceBinOp -> Int
prec2Spc SpaceBinOp
bo
mePrec (StatBinaryOp bo :: StatBinOp
bo _ _)  = StatBinOp -> Int
prec2Stat StatBinOp
bo
mePrec (OrdBinaryOp bo :: OrdBinOp
bo _ _)   = OrdBinOp -> Int
prec2Ord OrdBinOp
bo
mePrec (VVVBinaryOp bo :: VVVBinOp
bo _ _)   = VVVBinOp -> Int
prec2VVV VVVBinOp
bo
mePrec (VVNBinaryOp bo :: VVNBinOp
bo _ _)   = VVNBinOp -> Int
prec2VVN VVNBinOp
bo
mePrec RealI{}                = 170
mePrec ForAll{}               = 130