module Language.JSMW.Arith (
lt, le, gt, ge, eq, ne, (===), (=/=),
land, lor
,isNAN
,toString
,parseInt
,parseFloat) where
import BrownPLT.JavaScript
import Data.DOM
import Language.JSMW.Monad
arithBin op x y = let et = exprType x in ParenExpr et (InfixExpr et op x y)
arithPfx op x = let et = exprType x in ParenExpr et (PrefixExpr et op x)
arithFun fn x = let et = exprType x in ParenExpr et (CallExpr et (VarRef et $ Id et fn) [x])
boolBin op x y = (arithBin op x y) /\ (undefined :: Bool)
instance Num (Expression Double) where
(+) = arithBin OpAdd
() = arithBin OpSub
(*) = arithBin OpMul
negate = arithPfx PrefixMinus
abs = arithFun "Math.abs"
signum = arithFun "(function(x){return (x<0)?(-1):(x>0)?1:0})"
fromInteger n = NumLit (undefined :: a) (fromIntegral n)
instance Num (Expression String) where
(+) = arithBin OpAdd
(*) x y = error "(*) undefined on strings"
abs x = error "abs undefined on strings"
signum x = error "signum undefined on strings"
fromInteger = string . show
instance Fractional (Expression Double) where
(/) = arithBin OpDiv
fromRational n = NumLit (undefined :: a) (fromRational n)
lt :: Expression a -> Expression a -> Expression Bool
le :: Expression a -> Expression a -> Expression Bool
gt :: Expression a -> Expression a -> Expression Bool
ge :: Expression a -> Expression a -> Expression Bool
eq :: Expression a -> Expression a -> Expression Bool
ne :: Expression a -> Expression a -> Expression Bool
(===) :: Expression a -> Expression a -> Expression Bool
(=/=) :: Expression a -> Expression a -> Expression Bool
lt = boolBin OpLT
le = boolBin OpLEq
gt = boolBin OpGT
ge = boolBin OpGEq
eq = boolBin OpEq
ne = boolBin OpNEq
(===) = boolBin OpStrictEq
(=/=) = boolBin OpStrictNEq
infix 4 `lt`, `le`, `gt`, `ge`, `eq`, `ne`, ===, =/=
land :: Expression Bool -> Expression Bool -> Expression Bool
lor :: Expression Bool -> Expression Bool -> Expression Bool
land = arithBin OpLAnd
lor = arithBin OpLOr
infixr 3 `land`
infixr 2 `lor`
isNAN :: Expression Double -> JSMW e (Expression Bool)
isNAN n = do
let dt = undefined :: Bool
nx <- once =<< return n
once =<< return (CallExpr dt (VarRef dt (Id dt "isNaN")) [nx /\ dt])
toString :: Expression a -> JSMW e (Expression String)
toString x = do
vx <- once =<< return x
once =<< return (CallExpr "" (DotRef "" (vx /\ "") (Id "" "toString")) [])
parseInt :: Expression String -> Expression Double -> JSMW e (Expression Double)
parseInt s r = do
let dt = undefined :: Double
str <- once =<< return s
rdx <- once =<< return r
once =<< return (CallExpr dt (VarRef dt (Id dt "parseInt")) [str /\ dt, rdx /\ dt])
parseFloat :: Expression String -> JSMW e (Expression Double)
parseFloat s = do
let dt = undefined :: Double
str <- once =<< return s
once =<< return (CallExpr dt (VarRef dt (Id dt "parseFloat")) [str /\ dt])