@@ -3,16 +3,20 @@ module Generate.JavaScript (showErr, jsModule) where
33import Control.Arrow (first,second)
44import Control.Monad (liftM,(<=<),join,ap)
55import Data.Char (isAlpha,isDigit)
6−import Data.List (intercalate,sortBy,inits,foldl')
6+import qualified Data.List as List
77import qualified Data.Map as Map
8+import qualified Data.Set as Set
89import Data.Either (partitionEithers)
910import qualified Text.Pandoc as Pan
10−import Data.Maybe (maybeToList)
1111
1212import Unique
1313import Generate.Cases
14−import SourceSyntax.Everything hiding (parens)
15−import Types.Types ( Type(RecordT) )
14+import SourceSyntax.Everything
15+import SourceSyntax.Location
16+import qualified Transform.SortDefinitions as SD
17+
18+deprime :: String -> String
19+deprime = map (\c -> if c == '\'' then '$' else c)
1620
1721showErr :: String -> String
1822showErr err = globalAssign "Elm.Main" (jsFunc "elm" body)
@@ -24,19 +28,22 @@ indent = concatMap f
2428 where f '\n' = "\n "
2529 f c = [c]
2630
27−internalImports =
31+internalImports name =
2832 [ ("N" , "Elm.Native"),
2933 ("_N", "N.Utils(elm)"),
3034 ("_L", "N.List(elm)"),
3135 ("_E", "N.Error(elm)"),
3236 ("_J", "N.JavaScript(elm)"),
33− ("_str", "_J.toString")
37+ ("_str", "_J.toString"),
38+ ("$moduleName", quoted name)
3439 ]
3540
3641parens s = "(" ++ s ++ ")"
3742brackets s = "{" ++ s ++ "}"
38−jsObj = brackets . intercalate ", "
39−jsList ss = "["++ intercalate "," ss ++"]"
43+commaSep = List.intercalate ", "
44+dotSep = List.intercalate "."
45+jsObj = brackets . commaSep
46+jsList ss = "["++ List.intercalate "," ss ++"]"
4047jsFunc args body = "function(" ++ args ++ "){" ++ indent body ++ "}"
4148assign x e = "\nvar " ++ x ++ " = " ++ e ++ ";"
4249ret e = "\nreturn "++ e ++";"
@@ -51,148 +58,116 @@ quoted s = "'" ++ concatMap f s ++ "'"
5158globalAssign n e = "\n" ++ assign' n e ++ ";"
5259assign' n e = n ++ " = " ++ e
5360
54−jsModule (Module names exports imports stmts) =
55− setup ("Elm":modNames) ++ globalAssign ("Elm." ++ modName) (jsFunc "elm" program)
56− where
57− modNames = if null names then ["Main"] else names
58− modName = intercalate "." modNames
59− includes = concatMap jsImport imports
60− body = stmtsToJS stmts
61− defs = assign "$op" "{}"
62− program = "\nvar " ++ usefulFuncs ++ ";" ++ defs ++ includes ++ body ++
63− setup ("elm":"Native":modNames) ++
64− assign "_" ("elm.Native." ++ modName ++ "||{}") ++
65− getExports exports stmts ++ setup ("elm":modNames) ++
66− ret (assign' ("elm." ++ modName) "_") ++ "\n"
67− setup modNames = concatMap (\n -> globalAssign n $ n ++ "||{}") .
68− map (intercalate ".") . drop 2 . inits $ init modNames
69− usefulFuncs = intercalate ", " (map (uncurry assign') internalImports)
70−
71−getExports names stmts = "\n"++ intercalate ";\n" (op : map fnPair fns)
72− where exNames n = either derename id n `elem` names
73− exports | null names = concatMap get stmts
74− | otherwise = filter exNames (concatMap get stmts)
75−
76− (fns,ops) = partitionEithers exports
77−
78− opPair op = "'" ++ op ++ "' : $op['" ++ op ++ "']"
79− fnPair fn = let fn' = derename fn in "_." ++ fn' ++ " = " ++ fn
80−
81− op = ("_.$op = "++) . jsObj $ map opPair ops
82−
83− get' (FnDef x _ _) = Just (Left x)
84− get' (OpDef op _ _ _) = Just (Right op)
85− get' (TypeAnnotation _ _) = Nothing
86− get s = case s of Definition d -> maybeToList (get' d)
87− Datatype _ _ tcs -> map (Left . fst) tcs
88− ImportEvent _ _ x _ -> [ Left x ]
89− ExportEvent _ _ _ -> []
90− TypeAlias _ _ _ -> []
91−
92−
93−jsImport (modul, how) =
94− case how of
95− As name -> assign name ("Elm." ++ modul ++ parens "elm")
96− Hiding vs -> include ++ " var hiding=" ++ (jsObj $ map (++":1") vs) ++
97− "; for(var k in _){if(k in hiding)continue;" ++
98− "eval('var '+k+'=_[\"'+k+'\"]')}"
99− Importing vs -> include ++ named
100− where
101− imprt v = assign' v ("_." ++ v)
102− def (o:p) = imprt (if isOp o then "$op['" ++ o:p ++ "']" else deprime (o:p))
103− named = if null vs then "" else "\nvar " ++ intercalate ", " (map def vs) ++ ";"
61+jsModule :: MetadataModule t v -> String
62+jsModule modul =
63+ run $ do
64+ body <- toJS . fst . SD.flattenLets [] $ program modul
65+ foreignImport <- mapM importEvent (foreignImports modul)
66+ return $ concat [ setup ("Elm": names modul)
67+ , globalAssign ("Elm." ++ modName)
68+ (jsFunc "elm" $ makeProgram body foreignImport) ]
10469 where
105− include = "\nvar _ = Elm." ++ modul ++ parens "elm" ++ ";" ++ setup modul
106− setup moduleName = " var " ++ concatMap (++";") (defs ++ [assign' moduleName "_"])
70+ modName = dotSep (names modul)
71+ makeProgram body foreignImport =
72+ concat [ "\nvar " ++ usefulFuncs ++ ";"
73+ , concatMap jsImport (imports modul)
74+ , concat foreignImport
75+ , assign "_op" "{}"
76+ , body
77+ , concatMap exportEvent $ foreignExports modul
78+ , jsExports
79+ ]
80+ setup names = concatMap (\n -> globalAssign n $ n ++ " || {}") .
81+ map dotSep . drop 2 . List.inits $ init names
82+ usefulFuncs = commaSep (map (uncurry assign') (internalImports modName))
83+
84+ jsExports = setup ("elm" : names modul) ++
85+ ret (assign' ("elm." ++ modName) (brackets exs))
10786 where
108− defs = map (\n -> assign' n (n ++ "||{}")) (subnames moduleName)
109− subnames = map (intercalate ".") . tail . inits . init . split
110− split names = case go [] names of
111− (name, []) -> [name]
112− (name, ns) -> name : split ns
113− go name str = case str of
114− '.':rest -> (reverse name, rest)
115− c:rest -> go (c:name) rest
116− [] -> (reverse name, [])
117−
118−
119−
120−stmtsToJS :: [Declaration t v] -> String
121−stmtsToJS stmts = run $ do program <- mapM toJS (sortBy cmpStmt stmts)
122− return (concat program)
123− where
124− cmpStmt s1 s2 = compare (valueOf s1) (valueOf s2)
125− valueOf s = case s of
126− Datatype _ _ _ -> 1
127− ImportEvent _ _ _ _ -> 2
128− Definition (FnDef f [] _) ->
129− if derename f == "main" then 5 else 4
130− Definition (TypeAnnotation _ _) -> 0
131− Definition _ -> 3
132− ExportEvent _ _ _ -> 6
133− TypeAlias _ _ _ -> 0
87+ exs = indent . commaSep . concatMap (pair . deprime) $ "_op" : exports modul
88+ pair x | isOp x = []
89+ | otherwise = ["\n" ++ x ++ " : " ++ x]
90+
91+
92+ importEvent (js,base,elm,_) =
93+ do v <- toJS' base
94+ return $ concat [ "\nvar " ++ elm ++ "=Signal.constant(" ++ v ++ ");"
95+ , "\ndocument.addEventListener('", js
96+ , "_' + elm.id, function(e) { elm.notify(", elm
97+ , ".id, e.value); });" ]
98+
99+ exportEvent (js,elm,_) =
100+ concat [ "\nA2( Signal.lift, function(v) { "
101+ , "var e = document.createEvent('Event');"
102+ , "e.initEvent('", js, "_' + elm.id, true, true);"
103+ , "e.value = v;"
104+ , "document.dispatchEvent(e); return v; }, ", elm, ");" ]
105+
106+jsImport (modul, method) =
107+ concat $ zipWith3 (\s n v -> s ++ assign' n v ++ ";") starters subnames values
108+ where
109+ starters = "\nvar " : repeat "\n"
110+ values = map (\name -> name ++ " || {}") (init subnames) ++
111+ ["Elm." ++ modul ++ parens "elm"]
112+ subnames = map dotSep . tail . List.inits $ split modul
113+
114+ split names = case go [] names of
115+ (name, []) -> [name]
116+ (name, ns) -> name : split ns
117+ go name str = case str of
118+ '.':rest -> (reverse name, rest)
119+ c:rest -> go (c:name) rest
120+ [] -> (reverse name, [])
121+
134122
135123class ToJS a where
136124 toJS :: a -> Unique String
137125
126+
138127instance ToJS (Def t v) where
139− toJS (FnDef x [] e) = assign x `liftM` toJS' e
140− toJS (FnDef f as e) = (assign f . wrapper . func) `liftM` toJS' e
141− where
142− func body = jsFunc (intercalate ", " as) (ret body)
143− wrapper e | length as == 1 = e
144− | otherwise = 'F' : show (length as) ++ parens e
145− toJS (OpDef op a1 a2 e) =
146− do body <- toJS' e
147− let func = "F2" ++ parens (jsFunc (a1 ++ ", " ++ a2) (ret body))
148− return (globalAssign ("$op['" ++ op ++ "']") func)
128+
129+ -- TODO: Make this handle patterns besides plain variables
130+ toJS (Def (PVar x) e)
131+ | isOp x = globalAssign ("_op['" ++ x ++ "']") `liftM` toJS' e
132+ | otherwise = assign (deprime x) `liftM` toJS' e
133+
134+ toJS (Def pattern e@(L s _)) =
135+ do n <- guid
136+ let x = "_" ++ show n
137+ var = L s . Var
138+ toDef y' = let y = deprime y' in
139+ Def (PVar y) (L s $ Case (var x) [(pattern, var y)])
140+ stmt <- assign x `liftM` toJS' e
141+ vars <- toJS . map toDef . Set.toList $ SD.boundVars pattern
142+ return (stmt ++ vars)
143+
149144 toJS (TypeAnnotation _ _) = return ""
150145
151146
152−instance ToJS (Declaration t v) where
153− toJS stmt =
154− case stmt of
155− Definition d -> toJS d
156− Datatype _ _ tcs -> concat `liftM` mapM (toJS . toDef) tcs
157− where toDef (name,args) =
158− let vars = map (('a':) . show) [1..length args] in
159− Definition . FnDef name vars . none $
160− Data (derename name) (map (none . Var) vars)
161− ImportEvent js base elm _ ->
162− do v <- toJS' base
163− return $ concat [ "\nvar " ++ elm ++ "=Elm.Signal(elm).constant(" ++ v ++ ");"
164− , "\ndocument.addEventListener('", js
165− , "_' + elm.id, function(e) { elm.notify(", elm
166− , ".id, e.value); });" ]
167− ExportEvent js elm _ ->
168− return $ concat [ "\nlift(function(v) { "
169− , "var e = document.createEvent('Event');"
170− , "e.initEvent('", js, "_' + elm.id, true, true);"
171− , "e.value = v;"
172− , "document.dispatchEvent(e); return v; })(", elm, ");" ]
173− TypeAlias n _ t -> return ""
147+instance ToJS a => ToJS [a] where
148+ toJS xs = concat `liftM` mapM toJS xs
174149
175150toJS' :: LExpr t v -> Unique String
176−toJS' (L txt span expr) =
151+toJS' (L span expr) =
177152 case expr of
178153 MultiIf ps -> multiIfToJS span ps
179154 Case e cases -> caseToJS span e cases
180155 _ -> toJS expr
181156
182−remove x e = "_N.remove('" ++ x ++ "', " ++ e ++ ")"
183−addField x v e = "_N.insert('" ++ x ++ "', " ++ v ++ ", " ++ e ++ ")"
157+remove x e = "_N.remove('" ++ deprime x ++ "', " ++ e ++ ")"
158+addField x v e = "_N.insert('" ++ deprime x ++ "', " ++ v ++ ", " ++ e ++ ")"
184159setField fs e = "_N.replace(" ++ jsList (map f fs) ++ ", " ++ e ++ ")"
185− where f (x,v) = "['" ++ x ++ "'," ++ v ++ "]"
186−access x e = e ++ "." ++ x
160+ where f (x,v) = "['" ++ deprime x ++ "'," ++ v ++ "]"
161+access x e = e ++ "." ++ deprime x
187162makeRecord kvs = record `liftM` collect kvs
188163 where
189164 combine r (k,v) = Map.insertWith (++) k v r
190− collect = liftM (foldl' combine Map.empty) . mapM prep
191− prep (k, as, e@(L t s _)) =
192− do v <- toJS' (foldr (\x e -> L t s $ Lambda x e) e as)
193− return (k,[v])
165+ collect = liftM (List.foldl' combine Map.empty) . mapM prep
166+ prep (k, e) =
167+ do v <- toJS' e
168+ return (deprime k, [v])
194169 fields fs =
195− brackets ("\n "++intercalate ",\n " (map (\(k,v) -> k++":"++v) fs))
170+ brackets ("\n "++List.intercalate ",\n " (map (\(k,v) -> k++":"++v) fs))
196171 hidden = fields . map (second jsList) .
197172 filter (not . null . snd) . Map.toList . Map.map tail
198173 record kvs = fields . (("_", hidden kvs) :) . Map.toList . Map.map head $ kvs
@@ -211,7 +186,7 @@ instance ToJS Literal where
211186instance ToJS (Expr t v) where
212187 toJS expr =
213188 case expr of
214− Var x -> return x
189+ Var x -> return (deprime x)
215190 Literal lit -> toJS lit
216191 Range lo hi -> jsRange `liftM` toJS' lo `ap` toJS' hi
217192 Access e x -> access x `liftM` toJS' e
@@ -220,12 +195,30 @@ instance ToJS (Expr t v) where
220195 Modify e fs -> do fs' <- (mapM (\(x,v) -> (,) x `liftM` toJS' v) fs)
221196 setField fs' `liftM` toJS' e
222197 Record fs -> makeRecord fs
223− Binop op e1 e2 -> binop op `liftM` toJS' e1 `ap` toJS' e2
198+ Binop op e1 e2 -> binop op e1 e2
199+
200+ Lambda p e@(L s _) -> liftM (fastFunc . ret) (toJS' body)
201+ where
202+ fastFunc body
203+ | length args < 2 || length args > 9 = foldr jsFunc body args
204+ | otherwise = "F" ++ show (length args) ++ parens (jsFunc (commaSep args) body)
205+ (args, body) = first reverse $ foldr depattern ([], innerBody) (zip patterns [1..])
224206
225− Lambda v e -> liftM (jsFunc v . ret) (toJS' e)
207+ depattern (pattern,n) (args, body) =
208+ case pattern of
209+ PVar x -> (deprime x : args, body)
210+ _ -> let arg = "arg" ++ show n
211+ in (arg:args, L s (Case (L s (Var arg)) [(pattern, body)]))
212+
213+ (patterns, innerBody) = collect [p] e
214+
215+ collect patterns lexpr@(L _ expr) =
216+ case expr of
217+ Lambda p e -> collect (p:patterns) e
218+ _ -> (patterns, lexpr)
226219
227220 App e1 e2 -> jsApp e1 e2
228− Let defs e -> jsLet defs e
221+ Let defs e -> jsLet $ SD.flattenLets defs e
229222
230223 ExplicitList es ->
231224 do es' <- mapM toJS' es
@@ -239,7 +232,7 @@ instance ToJS (Expr t v) where
239232 _ -> jsObj $ ("ctor:" ++ show name) : fields
240233 where fields = zipWith (\n e -> "_" ++ show n ++ ":" ++ e) [0..] fs
241234
242− Markdown doc -> return $ "text('" ++ pad ++ md ++ pad ++ "')"
235+ Markdown doc -> return $ "Text.text('" ++ pad ++ md ++ pad ++ "')"
243236 where pad = "<div style=\"height:0;width:0;\"> </div>"
244237 md = formatMarkdown $ Pan.writeHtmlString Pan.def doc
245238
@@ -248,12 +241,12 @@ jsApp e1 e2 =
248241 as <- mapM toJS' args
249242 return $ case as of
250243 [a] -> f ++ parens a
251− _ -> "A" ++ show (length as) ++ parens (intercalate ", " (f:as))
244+ _ -> "A" ++ show (length as) ++ parens (commaSep (f:as))
252245 where
253246 (func, args) = go [e2] e1
254247 go args e =
255248 case e of
256− (L _ _ (App e1 e2)) -> go (e2 : args) e1
249+ (L _ (App e1 e2)) -> go (e2 : args) e1
257250 _ -> (e, args)
258251
259252formatMarkdown = concatMap f
@@ -264,8 +257,8 @@ formatMarkdown = concatMap f
264257
265258multiIfToJS span ps =
266259 case last ps of
267− (L _ _ (Var "otherwise"), e) -> toJS' e >>= \b -> format b (init ps)
268− _ -> format ("_E.If" ++ parens (quoted (show span))) ps
260+ (L _ (Var "otherwise"), e) -> toJS' e >>= \b -> format b (init ps)
261+ _ -> format ("_E.If" ++ parens ("$moduleName," ++ quoted (show span))) ps
269262 where
270263 format base ps =
271264 foldr (\c e -> parens $ c ++ " : " ++ e) base `liftM` mapM f ps
@@ -273,26 +266,18 @@ multiIfToJS span ps =
273266 e' <- toJS' e
274267 return (b' ++ " ? " ++ e')
275268
276−jsLet defs e' = do ds <- jsDefs defs
277− e <- toJS' e'
278− return $ jsFunc "" (concat ds ++ ret e) ++ "()"
279− where
280− jsDefs defs = mapM toJS (sortBy f defs)
281− f a b = compare (valueOf a) (valueOf b)
282− valueOf (FnDef _ [] _) = 2
283− valueOf (FnDef _ _ _) = 1
284− valueOf (OpDef _ _ _ _) = 1
285− valueOf (TypeAnnotation _ _) = 0
269+jsLet (defs,e') = do ds <- mapM toJS defs
270+ e <- toJS' e'
271+ return $ jsFunc "" (concat ds ++ ret e) ++ "()"
286272
287273caseToJS span e ps = do
288− match <- caseToMatch ps
274+ (tempVar,match) <- caseToMatch ps
289275 e' <- toJS' e
290− let (match',stmt) = case (match,e) of
291− (Match name _ _, L _ _ (Var x)) -> (matchSubst [(name,x)] match, "")
292− (Match name _ _, _) -> (match, assign name e')
293− _ -> (match, "")
276+ let (match',stmt) = case e of
277+ L _ (Var x) -> (matchSubst [(tempVar,deprime x)] match, "")
278+ _ -> (match, assign tempVar e')
294279 matches <- matchToJS span match'
295− return $ "function(){ " ++ stmt ++ matches ++ " }()"
280+ return $ jsFunc "" (stmt ++ matches) ++ "()"
296281
297282matchToJS span match =
298283 case match of
@@ -305,7 +290,7 @@ matchToJS span match =
305290 access = if any isLiteral clauses then "" else ".ctor"
306291 return $ concat [ "\nswitch (", name, access, ") {"
307292 , indent cases, "\n}", finally ]
308− Fail -> return ("_E.Case" ++ parens (quoted (show span)))
293+ Fail -> return ("_E.Case" ++ parens ("$moduleName," ++ quoted (show span)))
309294 Break -> return "break;"
310295 Other e -> ret `liftM` toJS' e
311296 Seq ms -> concat `liftM` mapM (matchToJS span) (dropEnd [] ms)
@@ -320,36 +305,64 @@ clauseToJS span var (Clause value vars e) = do
320305 let vars' = map (\n -> var ++ "._" ++ show n) [0..]
321306 s <- matchToJS span $ matchSubst (zip vars vars') e
322307 return $ concat [ "\ncase ", case value of
323− Left name -> quoted name
324308 Right (Boolean True) -> "true"
325309 Right (Boolean False) -> "false"
326310 Right lit -> show lit
311+ Left name -> quoted $ case List.elemIndices '.' name of
312+ [] -> name
313+ is -> drop (last is + 1) name
327314 , ":", indent s ]
328315
329316jsNil = "_L.Nil"
330317jsCons e1 e2 = "_L.Cons(" ++ e1 ++ "," ++ e2 ++ ")"
331318jsRange e1 e2 = "_L.range" ++ parens (e1 ++ "," ++ e2)
332−jsCompare e1 e2 op = parens ("_N.cmp(" ++ e1 ++ "," ++ e2 ++ ").ctor" ++ op)
319+jsCompare e1 e2 op = parens ("_N.cmp(" ++ e1 ++ "," ++ e2 ++ ")" ++ op)
333320
334−binop (o:p) e1 e2
335− | isAlpha o || '_' == o = (o:p) ++ parens e1 ++ parens e2
321+
322+binop op e1 e2
323+ | op == "Basics.." =
324+ do ss <- mapM toJS' (e1 : collect [] e2)
325+ return . jsFunc "$" . ret $ apply "$" ss
326+ | op == "Basics.<|" =
327+ do arg <- toJS' e2
328+ funcs <- mapM toJS' (collect [] e1)
329+ return (apply arg funcs)
336330 | otherwise =
337− let ops = ["+","-","*","/","&&","||"] in
338− case o:p of
339− "::" -> jsCons e1 e2
340− "++" -> "_L.append" ++ parens (e1 ++ "," ++ e2)
341− "<|" -> e1 ++ parens e2
342− "|>" -> e2 ++ parens e1
343− "." -> jsFunc "x" . ret $ e1 ++ parens (e2 ++ parens "x")
344− "^" -> "Math.pow(" ++ e1 ++ "," ++ e2 ++ ")"
345− "==" -> "_N.eq(" ++ e1 ++ "," ++ e2 ++ ")"
346− "/=" -> "!_N.eq(" ++ e1 ++ "," ++ e2 ++ ")"
347− "<" -> jsCompare e1 e2 "==='LT'"
348− ">" -> jsCompare e1 e2 "==='GT'"
349− "<=" -> jsCompare e1 e2 "!=='GT'"
350− ">=" -> jsCompare e1 e2 "!=='LT'"
351− "<~" -> "A2(lift," ++ e1 ++ "," ++ e2 ++ ")"
352− "~" -> "A3(lift2,F2(function(f,x){return f(x)}),"++e1++","++e2++")"
353− _ | elem (o:p) ops -> parens (e1 ++ (o:p) ++ e2)
354− | otherwise -> concat [ "$op['", o:p, "']"
355− , parens e1, parens e2 ]
331+ binopNormal op `liftM` toJS' e1 `ap` toJS' e2
332+ where
333+ apply = foldr (\f arg-> f ++ parens arg)
334+
335+ collect es e =
336+ case e of
337+ L _ (Binop op e1 e2) | op == "Basics.." -> collect (es ++ [e1]) e2
338+ _ -> es ++ [e]
339+
340+binopNormal op s1 s2 =
341+ case Map.lookup op opDict of
342+ Just e -> e
343+ Nothing -> "A2" ++ parens (commaSep [ prefix ++ func, s1, s2 ])
344+ where
345+ func | isOp op' = "_op['" ++ op' ++ "']"
346+ | otherwise = op'
347+ (prefix, op') = case List.elemIndices '.' op of
348+ [] -> ("", op)
349+ xs -> splitAt (last xs + 1) op
350+
351+ opDict = Map.fromList $ basics ++
352+ [ ("::", jsCons s1 s2)
353+ , ("List.++", "_L.append" ++ parens (s1 ++ "," ++ s2)) ]
354+
355+ ops = pow : map (\op -> (op, parens (s1 ++ op ++ s2))) ["+","-","*","/","&&","||"]
356+ where pow = ("^" , "Math.pow(" ++ s1 ++ "," ++ s2 ++ ")")
357+
358+ basics = ops ++ map (\(op,e) -> ("Basics." ++ op, e))
359+ (ops ++ [ ("<|", s1 ++ parens s2)
360+ , ("|>", s2 ++ parens s1)
361+ , ("==", "_N.eq(" ++ s1 ++ "," ++ s2 ++ ")")
362+ , ("/=", "!_N.eq(" ++ s1 ++ "," ++ s2 ++ ")")
363+ , ("<" , jsCompare s1 s2 "<0")
364+ , (">" , jsCompare s1 s2 ">0")
365+ , ("<=", jsCompare s1 s2 "<1")
366+ , (">=", jsCompare s1 s2 ">-1")
367+ , ("div", parens (s1 ++ "/" ++ s2 ++ "|0"))
368+ ])