e07d16b · elk · git.iko.soy

git.iko.soy/elk

Get rid of dependency on language-ecmascript

Can potentially create the Text.Lazy.Builder directly, though I suspect the expensive part is actually producing the new Text, not the intermediate data structure.

commite07d16b1c7720eb6f3572874f70c691f4bfe0b54 authorEvan Czaplicki <evancz@users.noreply.github.com> dateMon 5 Dec 2016, 19:09 (10 years ago) parent36d38db

7 files changed+257−270

compare with master

unifiedsplit

elm-compiler.cabal−2 src/Generate/JavaScript.hs+16−14 src/Generate/JavaScript/BuiltIn.hs+38−35 src/Generate/JavaScript/Expression.hs+107−114 src/Generate/JavaScript/Foreign.hs+37−31 src/Generate/JavaScript/Helpers.hs+23−35 src/Generate/JavaScript/Variable.hs+36−39

elm-compiler.cabal−2

@@ -149,7 +149,6 @@ Library

149149 directory >= 1.0 && < 2.0,

150150 edit-distance >= 0.2 && < 0.3,

151151 filepath >= 1 && < 2.0,

152− language-ecmascript >= 0.15 && < 0.18,

153152 language-glsl >= 0.0.2 && < 0.3,

154153 mtl >= 2.2 && < 3,

155154 pretty >= 1.0 && < 2.0,

@@ -220,7 +219,6 @@ Test-Suite compiler-tests

220219 edit-distance >= 0.2 && < 0.3,

221220 filemanip >= 0.3.5 && < 0.4,

222221 filepath >= 1 && < 2.0,

223− language-ecmascript >= 0.15 && < 0.18,

224222 language-glsl >= 0.0.2 && < 0.3,

225223 mtl >= 2.2 && < 3,

226224 pretty >= 1.0 && < 2.0,

src/Generate/JavaScript.hs+16−14

@@ -1,14 +1,16 @@

1+{-# OPTIONS_GHC -Wall #-}

2+{-# LANGUAGE OverloadedStrings #-}

13module Generate.JavaScript (generate) where

35import qualified Control.Monad.State as State

6+import Data.Text (Text)

47import qualified Data.Text.Lazy as LazyText

5−import qualified Language.ECMAScript3.Syntax as JS

79import qualified AST.Effects as Effects

810import qualified AST.Module as Module

911import qualified AST.Module.Name as ModuleName

1012import qualified Elm.Package as Pkg

11−import qualified Generate.JavaScript.Builder as Builder

13+import qualified Generate.JavaScript.Builder as JS

1214import qualified Generate.JavaScript.Expression as JS

1315import qualified Generate.JavaScript.Helpers as JS

1416import qualified Generate.JavaScript.Variable as Var

@@ -29,14 +31,14 @@ generate (Module.Module moduleName _ info) =

2931 body =

3032 State.evalState genBody 0

3133 in

32− Builder.stmtsToText body

34+ JS.stmtsToText body

3335

3436

3537

3638-- GENERATE EFFECT MANAGER

3739

3840

39−generateEffectManager :: ModuleName.Canonical -> Effects.Canonical -> [JS.Statement ()]

41+generateEffectManager :: ModuleName.Canonical -> Effects.Canonical -> [JS.Stmt]

4042generateEffectManager moduleName effects =

4143 case effects of

4244 Effects.None ->

@@ -51,15 +53,15 @@ generateEffectManager moduleName effects =

5153 Var.coreNative "Platform" "effectManagers"

5254

5355 managerName =

54− JS.StringLit () (ModuleName.canonicalToString moduleName)

56+ JS.String (ModuleName.canonicalToText moduleName)

5557

5658 entry name =

57− ( JS.PropId () (JS.Id () name)

59+ ( JS.IdProp (JS.Id name)

5860 , JS.ref (Var.qualified moduleName name)

5961 )

6062

6163 managerEntries =

62− [ "pkg" ==> Pkg.toString pkgName

64+ [ "pkg" ==> Pkg.toText pkgName

6365 , entry "init"

6466 , entry "onEffects"

6567 , entry "onSelfMsg"

@@ -77,15 +79,15 @@ generateEffectManager moduleName effects =

7779 [ "tag" ==> "fx", entry "cmdMap", entry "subMap" ]

7880

7981 addManager =

80− JS.AssignExpr () JS.OpAssign

81− (JS.LBracket () managers managerName)

82− (JS.ObjectLit () (managerEntries ++ otherEntries))

82+ JS.Assign JS.OpAssign

83+ (JS.LBracket managers managerName)

84+ (JS.Object (managerEntries ++ otherEntries))

8385 in

84− [ JS.ExprStmt () addManager ]

86+ [ JS.ExprStmt addManager ]

8587

8688

87−(==>) :: String -> String -> ( JS.Prop (), JS.Expression () )

89+(==>) :: Text -> Text -> ( JS.Prop, JS.Expr )

8890(==>) key value =

89− ( JS.PropId () (JS.Id () key)

90− , JS.StringLit () value

91+ ( JS.IdProp (JS.Id key)

92+ , JS.String value

9193 )

src/Generate/JavaScript/BuiltIn.hs+38−35

@@ -1,5 +1,7 @@

1+{-# OPTIONS_GHC -Wall #-}

2+{-# LANGUAGE OverloadedStrings #-}

13module Generate.JavaScript.BuiltIn

2− ( character, string

4+ ( character

35 , list, cons

46 , recordUpdate

57 , eq, cmp

@@ -8,52 +10,49 @@ module Generate.JavaScript.BuiltIn

810 )

911 where

1012

11−import qualified Language.ECMAScript3.Syntax as JS

13+import qualified Data.Text as Text

14+import Data.Text (Text)

1215

1316import qualified AST.Module.Name as ModuleName

14−import Generate.JavaScript.Helpers ((<|), (==>), call)

17+import qualified Generate.JavaScript.Builder as JS

18+import Generate.JavaScript.Helpers ((<|), (==>))

1519import qualified Generate.JavaScript.Variable as Var

1620import qualified Reporting.Region as R

1721

1822

1923

20−utils :: String -> [JS.Expression ()] -> JS.Expression ()

24+utils :: Text -> [JS.Expr] -> JS.Expr

2125utils func args =

22− Var.coreNative "Utils" func `call` args

26+ JS.Call (Var.coreNative "Utils" func) args

2327

2428

2529

2630-- LITERALS

2731

2832

29−character :: Char -> JS.Expression ()

33+character :: Char -> JS.Expr

3034character char =

31− utils "chr" [ JS.StringLit () [char] ]

32−

33−

34−string :: String -> JS.Expression ()

35−string str =

36− JS.StringLit () str

35+ utils "chr" [ JS.String (Text.singleton char) ]

3736

3837

3938

4039-- LISTS

4140

4241

43−list :: [JS.Expression ()] -> JS.Expression ()

42+list :: [JS.Expr] -> JS.Expr

4443list elements =

4544 case elements of

4645 [] ->

47− JS.ObjectLit () [ "ctor" ==> JS.StringLit () "[]" ]

46+ JS.Object [ "ctor" ==> JS.String "[]" ]

4847

4948 front : back ->

5049 cons front (list back)

5150

5251

53−cons :: JS.Expression () -> JS.Expression () -> JS.Expression ()

52+cons :: JS.Expr -> JS.Expr -> JS.Expr

5453cons front back =

55− JS.ObjectLit ()

56− [ "ctor" ==> JS.StringLit () "::"

54+ JS.Object

55+ [ "ctor" ==> JS.String "::"

5756 , "_0" ==> front

5857 , "_1" ==> back

5958 ]

@@ -63,11 +62,11 @@ cons front back =

6362-- RECORDS

6463

6564

66−recordUpdate :: JS.Expression () -> [(String, JS.Expression ())] -> JS.Expression ()

65+recordUpdate :: JS.Expr -> [(Text, JS.Expr)] -> JS.Expr

6766recordUpdate record fields =

6867 utils "update"

6968 [ record

70− , JS.ObjectLit () (map (uncurry (==>)) fields)

69+ , JS.Object (map (uncurry (==>)) fields)

7170 ]

7271

7372

@@ -75,12 +74,12 @@ recordUpdate record fields =

7574-- COMPARISIONS

7675

7776

78−eq :: JS.Expression () -> JS.Expression () -> JS.Expression ()

77+eq :: JS.Expr -> JS.Expr -> JS.Expr

7978eq left right =

8079 utils "eq" [ left, right ]

8180

8281

83−cmp :: JS.Expression () -> JS.Expression () -> JS.Expression ()

82+cmp :: JS.Expr -> JS.Expr -> JS.Expr

8483cmp left right =

8584 utils "cmp" [ left, right ]

8685

@@ -89,31 +88,35 @@ cmp left right =

8988-- EFFECTS

9089

9190

92−effect :: ModuleName.Canonical -> JS.Expression ()

91+effect :: ModuleName.Canonical -> JS.Expr

9392effect effectName =

9493 Var.coreNative "Platform" "leaf" <|

95− JS.StringLit () (ModuleName.canonicalToString effectName)

94+ JS.String (ModuleName.canonicalToText effectName)

9695

9796

98−outgoingPort :: String -> JS.Expression () -> JS.Expression ()

97+outgoingPort :: Text -> JS.Expr -> JS.Expr

9998outgoingPort name converter =

100− Var.coreNative "Platform" "outgoingPort" `call` [ JS.StringLit () name, converter ]

99+ JS.Call

100+ (Var.coreNative "Platform" "outgoingPort")

101+ [ JS.String name, converter ]

101102

102103

103−incomingPort :: String -> JS.Expression () -> JS.Expression ()

104+incomingPort :: Text -> JS.Expr -> JS.Expr

104105incomingPort name converter =

105− Var.coreNative "Platform" "incomingPort" `call` [ JS.StringLit () name, converter ]

106+ JS.Call

107+ (Var.coreNative "Platform" "incomingPort")

108+ [ JS.String name, converter ]

106109

107110

108111

109112-- CRASH

110113

111114

112−crash :: ModuleName.Canonical -> R.Region -> Maybe (JS.Expression ()) -> JS.Expression ()

115+crash :: ModuleName.Canonical -> R.Region -> Maybe (JS.Expr) -> JS.Expr

113116crash home region maybeCaseCrashValue =

114117 let

115118 homeString =

116− JS.StringLit () (ModuleName.canonicalToString home)

119+ JS.String (ModuleName.canonicalToText home)

117120 in

118121 case maybeCaseCrashValue of

119122 Nothing ->

@@ -123,17 +126,17 @@ crash home region maybeCaseCrashValue =

123126 utils "crashCase" [ homeString, regionToJs region, crashValue ]

124127

125128

126−regionToJs :: R.Region -> JS.Expression ()

129+regionToJs :: R.Region -> JS.Expr

127130regionToJs (R.Region start end) =

128− JS.ObjectLit ()

131+ JS.Object

129132 [ "start" ==> positionToJs start

130133 , "end" ==> positionToJs end

131134 ]

132135

133136

134−positionToJs :: R.Position -> JS.Expression ()

137+positionToJs :: R.Position -> JS.Expr

135138positionToJs (R.Position line column) =

136− JS.ObjectLit ()

137− [ "line" ==> JS.IntLit () line

138− , "column" ==> JS.IntLit () column

139+ JS.Object

140+ [ "line" ==> JS.Int line

141+ , "column" ==> JS.Int column

139142 ]

src/Generate/JavaScript/Expression.hs+107−114

@@ -1,10 +1,13 @@

1+{-# LANGUAGE OverloadedStrings #-}

12module Generate.JavaScript.Expression (generateDef) where

34import Control.Arrow (second)

45import Control.Monad.State (State, foldM)

56import qualified Data.List as List

67import qualified Data.Map as Map

7−import Language.ECMAScript3.Syntax

8+import Data.Monoid ((<>))

9+import qualified Data.Text as Text

10+import Data.Text (Text)

811

912import qualified AST.Expression.Canonical as Can

1013import AST.Expression.Optimized as Opt

@@ -12,6 +15,7 @@ import qualified AST.Literal as L

1215import qualified AST.Module.Name as ModuleName

1316import qualified AST.Variable as Var

1417import Generate.JavaScript.Helpers as Help

18+import qualified Generate.JavaScript.Builder as JS

1519import qualified Generate.JavaScript.BuiltIn as BuiltIn

1620import qualified Generate.JavaScript.Foreign as Foreign

1721import qualified Generate.JavaScript.Literal as Literal

@@ -24,16 +28,16 @@ import qualified Optimize.DecisionTree as DT

2428

2529

2630data Code

27− = JsExpr (Expression ())

28− | JsBlock [Statement ()]

31+ = JsExpr JS.Expr

32+ | JsBlock [JS.Stmt]

2933

3034

31−jsExpr :: Expression () -> State Int Code

35+jsExpr :: JS.Expr -> State Int Code

3236jsExpr exp =

3337 return (JsExpr exp)

3438

3539

36−jsBlock :: [Statement ()] -> State Int Code

40+jsBlock :: [JS.Stmt] -> State Int Code

3741jsBlock exp =

3842 return (JsBlock exp)

3943

@@ -45,44 +49,44 @@ isBlock code =

4549 JsExpr _ -> False

4650

4751

48−toStatementList :: Code -> [Statement ()]

52+toStatementList :: Code -> [JS.Stmt]

4953toStatementList code =

5054 case code of

5155 JsExpr expr ->

52− [ ReturnStmt () (Just expr) ]

56+ [ JS.Return (Just expr) ]

5357

5458 JsBlock stmts ->

5559 stmts

5660

5761

58−toStatement :: Code -> Statement ()

62+toStatement :: Code -> JS.Stmt

5963toStatement code =

6064 case code of

6165 JsExpr expr ->

62− ReturnStmt () (Just expr)

66+ JS.Return (Just expr)

6367

6468 JsBlock [stmt] ->

6569 stmt

6670

6771 JsBlock stmts ->

68− BlockStmt () stmts

72+ JS.Block stmts

6973

7074

71−toExpr :: Code -> Expression ()

75+toExpr :: Code -> JS.Expr

7276toExpr code =

7377 case code of

7478 JsExpr expr ->

75− expr

79+ expr

7680

7781 JsBlock stmts ->

78− function [] stmts `call` []

82+ JS.Call (function [] stmts) []

7983

8084

8185

8286-- DEFINITIONS

8387

8488

85−generateDef :: Opt.Def -> State Int [Statement ()]

89+generateDef :: Opt.Def -> State Int [JS.Stmt]

8690generateDef def =

8791 do (home, name, jsBody) <-

8892 case def of

@@ -99,7 +103,7 @@ generateDef def =

99103-- EXPRESSIONS

100104

101105

102−generateJsExpr :: Opt.Expr -> State Int (Expression ())

106+generateJsExpr :: Opt.Expr -> State Int JS.Expr

103107generateJsExpr optExpr =

104108 toExpr <$> generateCode optExpr

105109

@@ -114,8 +118,8 @@ generateCode expr =

114118 jsExpr (Literal.literal lit)

115119

116120 Access record field ->

117− do record' <- generateJsExpr record

118− jsExpr $ DotRef () record' (var (Var.safe field))

121+ do jsRecord <- generateJsExpr record

122+ jsExpr $ JS.DotRef jsRecord (JS.Id (Var.safe field))

119123

120124 Update record fields ->

121125 let

@@ -134,7 +138,7 @@ generateCode expr =

134138 return (Var.safe field ==> jsValue)

135139 in

136140 do jsFields <- mapM toField fields

137− jsExpr $ ObjectLit () jsFields

141+ jsExpr $ JS.Object jsFields

138142

139143 Binop op leftExpr rightExpr ->

140144 binop op leftExpr rightExpr

@@ -148,14 +152,15 @@ generateCode expr =

148152 TailCall name argNames args ->

149153 let

150154 reassign name tempName =

151− ExprStmt () (AssignExpr () OpAssign (LVar () (Var.safe name)) (ref tempName))

155+ JS.ExprStmt $

156+ JS.Assign JS.OpAssign (JS.LVar (Var.safe name)) (ref tempName)

152157 in

153158 do args' <- mapM generateJsExpr args

154159 tempNames <- mapM (\_ -> Var.fresh) args

155160 jsBlock $

156− VarDeclStmt () (zipWith varDecl tempNames args')

161+ JS.VarDeclStmt (zipWith varDecl tempNames args')

157162 : zipWith reassign argNames tempNames

158− ++ [ContinueStmt () (Just (Id () (Var.safe name)))]

163+ ++ [JS.Continue (Just (JS.Id (Var.safe name)))]

159164

160165 Let defs body ->

161166 do stmts <- mapM generateDef defs

@@ -175,17 +180,17 @@ generateCode expr =

175180 Ctor tag members ->

176181 let

177182 ctor =

178− "ctor" ==> StringLit () tag

183+ "ctor" ==> JS.String tag

179184

180185 toEntry entry n =

181− ("_" ++ show n) ==> entry

186+ ("_" <> Text.pack (show n)) ==> entry

182187 in

183188 do jsMembers <- mapM generateJsExpr members

184− jsExpr $ ObjectLit () (ctor : zipWith toEntry jsMembers [ 0 :: Int .. ])

189+ jsExpr $ JS.Object (ctor : zipWith toEntry jsMembers [ 0 :: Int .. ])

185190

186191 CtorAccess dataExpr index ->

187192 do jsDataExpr <- generateJsExpr dataExpr

188− jsExpr $ DotRef () jsDataExpr (var ("_" ++ show index))

193+ jsExpr $ JS.DotRef jsDataExpr (JS.Id ("_" <> Text.pack (show index)))

189194

190195 Cmd moduleName ->

191196 jsExpr $ BuiltIn.effect moduleName

@@ -204,7 +209,7 @@ generateCode expr =

204209 generateProgram kind body

205210

206211 GLShader _uid src _tipe ->

207− jsExpr $ ObjectLit () [(PropString () "src", Literal.literal (L.Str src))]

212+ jsExpr $ JS.Object [(JS.StringProp "src", Literal.literal (L.Str src))]

208213

209214 Crash home region maybeBranchProblem ->

210215 do maybeOptBranchProblem <- traverse generateJsExpr maybeBranchProblem

@@ -224,7 +229,7 @@ generateProgram kind body =

224229

225230 Can.NoFlags ->

226231 do almostProgram <- generateJsExpr body

227− jsExpr (almostProgram `call` [])

232+ jsExpr (JS.Call almostProgram [])

228233

229234 Can.Flags tipe ->

230235 do almostProgram <- generateJsExpr body

@@ -236,22 +241,22 @@ generateProgram kind body =

236241-- FUNCTIONS

237242

238243

239−generateFunction :: [String] -> Opt.Expr -> State Int Code

244+generateFunction :: [Text] -> Opt.Expr -> State Int Code

240245generateFunction args body =

241246 do code <- generateCode body

242247 jsExpr (generateFunctionWithArity args code)

243248

244249

245−generateTailFunction :: String -> [String] -> Opt.Expr -> State Int (Expression ())

250+generateTailFunction :: Text -> [Text] -> Opt.Expr -> State Int JS.Expr

246251generateTailFunction name args body =

247252 do code <- generateCode body

248253 return $ generateFunctionWithArity args $ JsBlock $ (:[]) $

249− LabelledStmt ()

250− (Id () (Var.safe name))

251− (WhileStmt () (BoolLit () True) (toStatement code))

254+ JS.Labelled

255+ (JS.Id (Var.safe name))

256+ (JS.While (JS.Bool True) (toStatement code))

252257

253258

254−generateFunctionWithArity :: [String] -> Code -> Expression ()

259+generateFunctionWithArity :: [Text] -> Code -> JS.Expr

255260generateFunctionWithArity rawArgs code =

256261 let

257262 args = map Var.safe rawArgs

@@ -259,7 +264,7 @@ generateFunctionWithArity rawArgs code =

259264 in

260265 if 2 <= arity && arity <= 9 then

261266 let

262− fN = "F" ++ show arity

267+ fN = "F" <> Text.pack (show arity)

263268 in

264269 ref fN <| function args (toStatementList code)

265270 else

@@ -267,7 +272,7 @@ generateFunctionWithArity rawArgs code =

267272 (lastArg:otherArgs) = reverse args

268273 innerBody = function [lastArg] (toStatementList code)

269274 in

270− foldl (\body arg -> function [arg] [ReturnStmt () (Just body)]) innerBody otherArgs

275+ foldl (\body arg -> function [arg] [JS.Return (Just body)]) innerBody otherArgs

271276

272277

273278

@@ -281,7 +286,7 @@ generateCall func args =

281286 case getUnaryOp var of

282287 Just op ->

283288 do jsArg <- generateJsExpr arg

284− jsExpr $ PrefixExpr () op jsArg

289+ jsExpr $ JS.Prefix op jsArg

285290

286291 Nothing ->

287292 generateCallHelp func args

@@ -291,7 +296,7 @@ generateCall func args =

291296 Just (op, left, right) ->

292297 do jsLeft <- generateJsExpr left

293298 jsRight <- generateJsExpr right

294− jsExpr $ InfixExpr () op jsLeft jsRight

299+ jsExpr $ JS.Infix op jsLeft jsRight

295300

296301 Nothing ->

297302 generateCallHelp func args

@@ -304,58 +309,58 @@ generateCallHelp :: Opt.Expr -> [Opt.Expr] -> State Int Code

304309generateCallHelp func args =

305310 let

306311 arity = length args

307− aN = "A" ++ show arity

312+ aN = "A" <> Text.pack (show arity)

308313 in

309314 do jsFunc <- generateJsExpr func

310315 jsArgs <- mapM generateJsExpr args

311316 jsExpr $

312317 if 2 <= arity && arity <= 9 then

313− ref aN `call` (jsFunc:jsArgs)

318+ JS.Call (ref aN) (jsFunc:jsArgs)

314319 else

315320 foldl1 (<|) (jsFunc:jsArgs)

316321

317322

318−getUnaryOp :: Var.Canonical -> Maybe PrefixOp

323+getUnaryOp :: Var.Canonical -> Maybe JS.PrefixOp

319324getUnaryOp var =

320325 if var == bitwiseComplement then

321− Just PrefixBNot

326+ Just JS.PrefixBNot

322327

323328 else if var == basicsNot then

324− Just PrefixLNot

329+ Just JS.PrefixLNot

325330

326331 else

327332 Nothing

328333

329334

330−getBinaryOp :: Var.Canonical -> Opt.Expr -> Opt.Expr -> Maybe (InfixOp, Opt.Expr, Opt.Expr)

335+getBinaryOp :: Var.Canonical -> Opt.Expr -> Opt.Expr -> Maybe (JS.InfixOp, Opt.Expr, Opt.Expr)

331336getBinaryOp (Var.Canonical home name) left right =

332337 if home /= bitwise then

333338 Nothing

334339

335340 else

336341 case name of

337− "and" -> Just ( OpBAnd, left, right )

338− "or" -> Just ( OpBOr, left, right )

339− "xor" -> Just ( OpBXor, left, right )

340− "shiftLeftBy" -> Just ( OpLShift, right, left )

341− "shiftRightBy" -> Just ( OpSpRShift, right, left )

342− "shiftRightZfBy" -> Just ( OpZfRShift, right, left )

342+ "and" -> Just ( JS.OpBAnd, left, right )

343+ "or" -> Just ( JS.OpBOr, left, right )

344+ "xor" -> Just ( JS.OpBXor, left, right )

345+ "shiftLeftBy" -> Just ( JS.OpLShift, right, left )

346+ "shiftRightBy" -> Just ( JS.OpSpRShift, right, left )

347+ "shiftRightZfBy" -> Just ( JS.OpZfRShift, right, left )

343348 _ -> Nothing

344349

345350

346351bitwiseComplement :: Var.Canonical

347352bitwiseComplement =

348− Var.inCore ["Bitwise"] "complement"

353+ Var.inCore "Bitwise" "complement"

349354

350355

351356basicsNot :: Var.Canonical

352357basicsNot =

353− Var.inCore ["Basics"] "not"

358+ Var.inCore "Basics" "not"

354359

355360

356361bitwise :: Var.Home

357362bitwise =

358− Var.Module (ModuleName.inCore ["Bitwise"])

363+ Var.Module (ModuleName.inCore "Bitwise")

359364

360365

361366

@@ -372,10 +377,10 @@ generateIf givenBranches givenFinally =

372377 (,) <$> generateJsExpr condition <*> generateCode expr

373378

374379 ifExpression (condition, branch) otherwise =

375− CondExpr () condition branch otherwise

380+ JS.If condition branch otherwise

376381

377382 ifStatement (condition, branch) otherwise =

378− IfStmt () condition branch otherwise

383+ JS.IfStmt condition branch otherwise

379384 in

380385 do jsBranches <- mapM convertBranch branches

381386 jsFinally <- generateCode finally

@@ -421,11 +426,7 @@ crushIfsHelp visitedBranches unvisitedBranches finally =

421426-- CASE EXPRESSIONS

422427

423428

424−generateCase

425− :: String

426− -> Opt.Decider Opt.Choice

427− -> [(Int, Opt.Expr)]

428− -> State Int [Statement ()]

429+generateCase :: Text -> Opt.Decider Opt.Choice -> [(Int, Opt.Expr)] -> State Int [JS.Stmt]

429430generateCase exprName decider jumps =

430431 do labelRoot <- Var.fresh

431432 decider <- generateDecider exprName labelRoot decider

@@ -436,76 +437,68 @@ generateCase exprName decider jumps =

436437-- handle any jumps

437438

438439

439−goto :: String -> [Statement ()] -> (Int, Opt.Expr) -> State Int [Statement ()]

440+goto :: Text -> [JS.Stmt] -> (Int, Opt.Expr) -> State Int [JS.Stmt]

440441goto labelRoot deciderStmts (target, branch) =

441442 let

442443 labeledDeciderStmt =

443− LabelledStmt ()

444+ JS.Labelled

444445 (toLabel labelRoot target)

445− (DoWhileStmt () (BlockStmt () deciderStmts) (BoolLit () False))

446+ (JS.DoWhile (JS.Block deciderStmts) (JS.Bool False))

446447 in

447448 do code <- generateCode branch

448449 return (labeledDeciderStmt : toStatementList code)

449450

450451

451−toLabel :: String -> Int -> Id ()

452+toLabel :: Text -> Int -> JS.Id

452453toLabel root target =

453− Id () (root ++ "_" ++ show target)

454+ JS.Id (root <> "_" <> Text.pack (show target))

454455

455456

456457

457458-- turn deciders into ifs and switches

458459

459460

460−generateDecider

461− :: String

462− -> String

463− -> Opt.Decider Opt.Choice

464− -> State Int [Statement ()]

461+generateDecider :: Text -> Text -> Opt.Decider Opt.Choice -> State Int [JS.Stmt]

465462generateDecider exprName labelRoot decisionTree =

466463 case decisionTree of

467464 Opt.Leaf (Opt.Inline branch) ->

468465 toStatementList <$> generateCode branch

469466

470467 Opt.Leaf (Opt.Jump target) ->

471− return [ BreakStmt () (Just (toLabel labelRoot target)) ]

468+ return [ JS.Break (Just (toLabel labelRoot target)) ]

472469

473470 Opt.Chain testChain success failure ->

474471 let

475472 makeTest (path, test) =

476473 do testExpr <- pathToTestableExpr exprName path test

477− return (InfixExpr () OpStrictEq testExpr (testToExpr test))

474+ return (JS.Infix JS.OpStrictEq testExpr (testToExpr test))

478475 in

479476 do testExprs <- mapM makeTest testChain

480− let cond = List.foldl1' (InfixExpr () OpLAnd) testExprs

477+ let cond = List.foldl1' (JS.Infix JS.OpLAnd) testExprs

481478 thenBranch <- generateDecider exprName labelRoot success

482479 elseBranch <- generateDecider exprName labelRoot failure

483− return [ IfStmt () cond (BlockStmt () thenBranch) (BlockStmt () elseBranch) ]

480+ return [ JS.IfStmt cond (JS.Block thenBranch) (JS.Block elseBranch) ]

484481

485482 Opt.FanOut path edges fallback ->

486483 do testExpr <- pathToTestableExpr exprName path (fst (head edges))

487− caseClauses <- mapM (edgeToCaseClause exprName labelRoot) edges

488− caseDefault <- CaseDefault () <$> generateDecider exprName labelRoot fallback

489− return [ SwitchStmt () testExpr (caseClauses ++ [caseDefault]) ]

484+ caseClauses <- mapM (edgeToCase exprName labelRoot) edges

485+ caseDefault <- JS.Default <$> generateDecider exprName labelRoot fallback

486+ return [ JS.Switch testExpr (caseClauses ++ [caseDefault]) ]

490487

491488

492−edgeToCaseClause

493− :: String

494− -> String

495− -> (DT.Test, Opt.Decider Opt.Choice)

496− -> State Int (CaseClause ())

497−edgeToCaseClause exprName labelRoot (test, subTree) =

498− CaseClause () (testToExpr test) <$> generateDecider exprName labelRoot subTree

489+edgeToCase :: Text -> Text -> (DT.Test, Opt.Decider Opt.Choice) -> State Int JS.Case

490+edgeToCase exprName labelRoot (test, subTree) =

491+ JS.Case (testToExpr test) <$> generateDecider exprName labelRoot subTree

499492

500493

501−testToExpr :: DT.Test -> Expression ()

494+testToExpr :: DT.Test -> JS.Expr

502495testToExpr test =

503496 case test of

504497 DT.Constructor (Var.Canonical _ tag) ->

505− StringLit () tag

498+ JS.String tag

506499

507500 DT.Literal (L.Chr char) ->

508− StringLit () [char]

501+ JS.String (Text.singleton char)

509502

510503 DT.Literal lit ->

511504 Literal.literal lit

@@ -515,21 +508,21 @@ testToExpr test =

515508-- work with paths

516509

517510

518−pathToTestableExpr :: String -> DT.Path -> DT.Test -> State Int (Expression ())

511+pathToTestableExpr :: Text -> DT.Path -> DT.Test -> State Int JS.Expr

519512pathToTestableExpr root path exampleTest =

520513 do accessExpr <- generateJsExpr (pathToExpr root path)

521514 case exampleTest of

522515 DT.Constructor _ ->

523− return (DotRef () accessExpr (Id () "ctor"))

516+ return $ JS.DotRef accessExpr (JS.Id "ctor")

524517

525518 DT.Literal (L.Chr _) ->

526− return (DotRef () accessExpr (Id () "valueOf") `call` [])

519+ return $ JS.Call (JS.DotRef accessExpr (JS.Id "valueOf")) []

527520

528521 DT.Literal _ ->

529522 return accessExpr

530523

531524

532−pathToExpr :: String -> DT.Path -> Opt.Expr

525+pathToExpr :: Text -> DT.Path -> Opt.Expr

533526pathToExpr root fullPath =

534527 go (Opt.Var (Var.local root)) fullPath

535528 where

@@ -567,11 +560,11 @@ binop func left right =

567560-- BINARY OPERATOR HELPERS

568561

569562

570−binopHelp :: Var.Canonical -> Expression () -> Expression () -> Expression ()

563+binopHelp :: Var.Canonical -> JS.Expr -> JS.Expr -> JS.Expr

571564binopHelp qualifiedOp@(Var.Canonical home op) leftExpr rightExpr =

572565 let

573566 simpleMake left right =

574− ref "A2" `call` [ Var.canonical qualifiedOp, left, right ]

567+ JS.Call (ref "A2") [ Var.canonical qualifiedOp, left, right ]

575568 in

576569 if home == basicsModule then

577570 (Map.findWithDefault simpleMake op basicOps) leftExpr rightExpr

@@ -585,52 +578,52 @@ binopHelp qualifiedOp@(Var.Canonical home op) leftExpr rightExpr =

585578

586579listModule :: Var.Home

587580listModule =

588− Var.Module (ModuleName.inCore ["List"])

581+ Var.Module (ModuleName.inCore "List")

589582

590583

591584listModuleInternals :: Var.Home

592585listModuleInternals =

593− Var.TopLevel (ModuleName.inCore ["List"])

586+ Var.TopLevel (ModuleName.inCore "List")

594587

595588

596589basicsModule :: Var.Home

597590basicsModule =

598− Var.Module (ModuleName.inCore ["Basics"])

591+ Var.Module (ModuleName.inCore "Basics")

599592

600593

601−basicOps :: Map.Map String (Expression () -> Expression () -> Expression ())

594+basicOps :: Map.Map Text (JS.Expr -> JS.Expr -> JS.Expr)

602595basicOps =

603596 Map.fromList (infixOps ++ specialOps)

604597

605598

606−infixOps :: [(String, Expression () -> Expression () -> Expression ())]

599+infixOps :: [(Text, JS.Expr -> JS.Expr -> JS.Expr)]

607600infixOps =

608601 let

609602 infixOp str op =

610− (str, InfixExpr () op)

603+ (str, JS.Infix op)

611604 in

612− [ infixOp "+" OpAdd

613− , infixOp "-" OpSub

614− , infixOp "*" OpMul

615− , infixOp "/" OpDiv

616− , infixOp "&&" OpLAnd

617− , infixOp "||" OpLOr

605+ [ infixOp "+" JS.OpAdd

606+ , infixOp "-" JS.OpSub

607+ , infixOp "*" JS.OpMul

608+ , infixOp "/" JS.OpDiv

609+ , infixOp "&&" JS.OpLAnd

610+ , infixOp "||" JS.OpLOr

618611 ]

619612

620613

621−specialOps :: [(String, Expression () -> Expression () -> Expression ())]

614+specialOps :: [(Text, JS.Expr -> JS.Expr -> JS.Expr)]

622615specialOps =

623− [ (,) "^" $ \a b -> obj ["Math","pow"] `call` [a,b]

616+ [ (,) "^" $ \a b -> JS.Call (obj ["Math","pow"]) [a,b]

624617 , (,) "==" $ \a b -> BuiltIn.eq a b

625− , (,) "/=" $ \a b -> PrefixExpr () PrefixLNot (BuiltIn.eq a b)

626− , (,) "<" $ cmp OpLT 0

627− , (,) ">" $ cmp OpGT 0

628− , (,) "<=" $ cmp OpLT 1

629− , (,) ">=" $ cmp OpGT (-1)

630− , (,) "//" $ \a b -> InfixExpr () OpBOr (InfixExpr () OpDiv a b) (IntLit () 0)

618+ , (,) "/=" $ \a b -> JS.Prefix JS.PrefixLNot (BuiltIn.eq a b)

619+ , (,) "<" $ cmp JS.OpLT 0

620+ , (,) ">" $ cmp JS.OpGT 0

621+ , (,) "<=" $ cmp JS.OpLT 1

622+ , (,) ">=" $ cmp JS.OpGT (-1)

623+ , (,) "//" $ \a b -> JS.Infix JS.OpBOr (JS.Infix JS.OpDiv a b) (JS.Int 0)

631624 ]

632625

633626

634−cmp :: InfixOp -> Int -> Expression () -> Expression () -> Expression ()

627+cmp :: JS.InfixOp -> Int -> JS.Expr -> JS.Expr -> JS.Expr

635628cmp op n a b =

636− InfixExpr () op (BuiltIn.cmp a b) (IntLit () n)

629+ JS.Infix op (BuiltIn.cmp a b) (JS.Int n)

src/Generate/JavaScript/Foreign.hs+37−31

@@ -1,26 +1,32 @@

1+{-# OPTIONS_GHC -Wall #-}

2+{-# LANGUAGE OverloadedStrings #-}

13module Generate.JavaScript.Foreign (encode, decode) where

5+import Prelude hiding (maybe)

36import qualified Data.List as List

4−import Language.ECMAScript3.Syntax

7+import qualified Data.Text as Text

8+import Data.Text (Text)

610import qualified AST.Expression.Optimized as Opt

711import qualified AST.Literal as Literal

812import qualified AST.Type as T

913import qualified AST.Variable as Var

10−import Generate.JavaScript.Helpers ((<|), (==>), function, ref, var)

14+import qualified Generate.JavaScript.Builder as JS

15+import qualified Generate.JavaScript.Helpers as JS (function, ref)

1116import qualified Generate.JavaScript.Variable as Var

17+import Generate.JavaScript.Helpers ((<|), (==>))

1218

1319

1420

1521-- ENCODE

1622

1723

18−encode :: T.Canonical -> Expression ()

24+encode :: T.Canonical -> JS.Expr

1925encode tipe =

20− function ["v"] [ ReturnStmt () (Just (encodeHelp tipe (ref "v"))) ]

26+ JS.function ["v"] [ JS.Return (Just (encodeHelp tipe (JS.ref "v"))) ]

2127

2228

23−encodeHelp :: T.Canonical -> Expression () -> Expression ()

29+encodeHelp :: T.Canonical -> JS.Expr -> JS.Expr

2430encodeHelp tipe expr =

2531 case tipe of

2632 T.Aliased _ args t ->

@@ -38,7 +44,7 @@ encodeHelp tipe expr =

3844 | Var.isPrim "Bool" name -> expr

3945 | Var.isPrim "String" name -> expr

4046 | Var.isJson name -> expr

41− | Var.isTuple name -> NullLit ()

47+ | Var.isTuple name -> JS.Null

4248 | otherwise -> error "encodeHelp: bad type"

4349

4450 T.App (T.Type name) [arg]

@@ -58,45 +64,45 @@ encodeHelp tipe expr =

5864

5965 T.Record fields Nothing ->

6066 let

61− convert (name, tipe) =

62− name ==> encodeHelp tipe (DotRef () expr (var name))

67+ convert (k, t) =

68+ k ==> encodeHelp t (JS.DotRef expr (JS.Id k))

6369 in

64− ObjectLit () (map convert fields)

70+ JS.Object (map convert fields)

6571

6672

67−fromMaybe :: T.Canonical -> Expression () -> Expression ()

73+fromMaybe :: T.Canonical -> JS.Expr -> JS.Expr

6874fromMaybe tipe expr =

69− CondExpr ()

70− (InfixExpr () OpStrictEq (DotRef () expr (var "ctor")) (StringLit () "Nothing"))

71− (NullLit ())

72− (encodeHelp tipe (DotRef () expr (var "_0")))

75+ JS.If

76+ (JS.Infix JS.OpStrictEq (JS.DotRef expr (JS.Id "ctor")) (JS.String "Nothing"))

77+ (JS.Null)

78+ (encodeHelp tipe (JS.DotRef expr (JS.Id "_0")))

7379

7480

75−fromList :: T.Canonical -> Expression () -> Expression ()

81+fromList :: T.Canonical -> JS.Expr -> JS.Expr

7682fromList tipe expr =

7783 let

7884 array =

7985 Var.coreNative "List" "toArray" <| expr

8086 in

81− DotRef () array (var "map") <| encode tipe

87+ JS.DotRef array (JS.Id "map") <| encode tipe

8288

8389

84−fromArray :: T.Canonical -> Expression () -> Expression ()

90+fromArray :: T.Canonical -> JS.Expr -> JS.Expr

8591fromArray tipe expr =

8692 let

8793 array =

8894 Var.coreNative "Array" "toJSArray" <| expr

8995 in

90− DotRef () array (var "map") <| encode tipe

96+ JS.DotRef array (JS.Id "map") <| encode tipe

9197

9298

93−fromTuple :: [T.Canonical] -> Expression () -> Expression ()

99+fromTuple :: [T.Canonical] -> JS.Expr -> JS.Expr

94100fromTuple types expr =

95101 let

96102 convert subType n =

97− encodeHelp subType $ DotRef () expr (var ('_':show n))

103+ encodeHelp subType $ JS.DotRef expr (JS.Id (Text.pack ('_':show n)))

98104 in

99− ArrayLit () (zipWith convert types [0..])

105+ JS.Array (zipWith convert types [ 0 .. length types ])

100106

101107

102108

@@ -146,24 +152,24 @@ decode tipe =

146152-- DECODE HELPERS

147153

148154

149−inJsonDecode :: String -> Var.Canonical

155+inJsonDecode :: Text -> Var.Canonical

150156inJsonDecode name =

151− Var.inCore ["Json","Decode"] name

157+ Var.inCore "Json.Decode" name

152158

153159

154−to :: String -> Opt.Expr

160+to :: Text -> Opt.Expr

155161to name =

156162 Opt.Var (inJsonDecode name)

157163

158164

159−field :: String -> Opt.Expr -> Opt.Expr

165+field :: Text -> Opt.Expr -> Opt.Expr

160166field name decoder =

161167 to "field" <== [ Opt.Literal (Literal.Str name), decoder ]

162168

163169

164170index :: Int -> Opt.Expr -> Opt.Expr

165−index index decoder =

166− to "index" <== [ Opt.Literal (Literal.IntNum index), decoder ]

171+index i decoder =

172+ to "index" <== [ Opt.Literal (Literal.IntNum i), decoder ]

167173

168174

169175(<==) :: Opt.Expr -> [Opt.Expr] -> Opt.Expr

@@ -179,7 +185,7 @@ toMaybe :: T.Canonical -> Opt.Expr

179185toMaybe tipe =

180186 let

181187 maybe tag =

182− Opt.Var (Var.inCore ["Maybe"] tag)

188+ Opt.Var (Var.inCore "Maybe" tag)

183189 in

184190 to "oneOf" <==

185191 [ Opt.List

@@ -204,12 +210,12 @@ toTuple types =

204210 zipWith (,) [ 0 .. size - 1] types

205211

206212 toVar i =

207− 'x' : show i

213+ Text.pack ('x' : show i)

208214

209215 makeTuple =

210216 to "succeed" <==

211217 [ Opt.Ctor

212− ("_Tuple" ++ show size)

218+ (Text.pack ("_Tuple" ++ show size))

213219 (map (Opt.Var . Var.local . toVar . fst) pairs)

214220 ]

215221

@@ -219,7 +225,7 @@ toTuple types =

219225 List.foldr andThen makeTuple pairs

220226

221227

222−toRecord :: [(String, T.Canonical)] -> Opt.Expr

228+toRecord :: [(Text, T.Canonical)] -> Opt.Expr

223229toRecord fields =

224230 let

225231 toFieldExpr (key, _) =

src/Generate/JavaScript/Helpers.hs+23−35

@@ -1,68 +1,56 @@

11module Generate.JavaScript.Helpers where

3−import Language.ECMAScript3.Syntax

3+import Data.Text (Text)

4+import Generate.JavaScript.Builder

7−localRuntime :: String

8−localRuntime =

9− "_elm"

8+-- DECLARATIONS

109

1110

12−varDecl :: String -> Expression () -> VarDecl ()

11+varDecl :: Text -> Expr -> VarDecl

1312varDecl x expr =

14− VarDecl () (var x) (Just expr)

13+ VarDecl (Id x) (Just expr)

1514

1615

17−refOrObject :: String -> Expression ()

16+refOrObject :: Text -> Expr

1817refOrObject name =

19− InfixExpr () OpLOr (ref name) (ObjectLit () [])

18+ Infix OpLOr (ref name) (Object [])

2019

2120

2221

23−-- Creating Variables

22+-- VARIABLES

2423

2524

26−var :: String -> Id ()

27−var name =

28− Id () name

29−

30−

31−ref :: String -> Expression ()

25+ref :: Text -> Expr

3226ref name =

33− VarRef () (var name)

27+ VarRef (Id name)

3428

3529

36−(==>) :: String -> Expression () -> (Prop (), Expression ())

30+(==>) :: Text -> Expr -> (Prop, Expr)

3731(==>) name expr =

38− ( PropId () (var name), expr )

32+ ( IdProp (Id name), expr )

3933

4034

41−obj :: [String] -> Expression ()

35+obj :: [Text] -> Expr

4236obj vars =

43− case vars of

44− x:xs ->

45− foldl (DotRef ()) (ref x) (map var xs)

37+ case vars of

38+ x:xs ->

39+ foldl DotRef (ref x) (map Id xs)

4640

47− [] ->

48− error "dotSep must be called on a non-empty list of variables"

41+ [] ->

42+ error "dotSep must be called on a non-empty list of variables"

4943

5044

5145

52−-- Function Calls

46+-- FUNCTION CALLS

5347

5448

55−(<|) :: Expression () -> Expression () -> Expression ()

49+(<|) :: Expr -> Expr -> Expr

5650(<|) f x =

57− CallExpr () f [x]

51+ Call f [x]

5852

5953

60−function :: [String] -> [Statement ()] -> Expression ()

54+function :: [Text] -> [Stmt] -> Expr

6155function args stmts =

62− FuncExpr () Nothing (map var args) stmts

63−

64−

65−call :: Expression () -> [Expression ()] -> Expression ()

66−call =

67− CallExpr ()

68−

56+ Function Nothing (map Id args) stmts

src/Generate/JavaScript/Variable.hs+36−39

@@ -1,4 +1,5 @@

11{-# OPTIONS_GHC -Wall #-}

2+{-# LANGUAGE OverloadedStrings #-}

23module Generate.JavaScript.Variable

34 ( fresh

45 , canonical

@@ -12,14 +13,16 @@ module Generate.JavaScript.Variable

1213 where

1314

1415import qualified Control.Monad.State as State

15−import qualified Data.List as List

16+import Data.Monoid

1617import qualified Data.Set as Set

17−import qualified Language.ECMAScript3.Syntax as JS

18+import qualified Data.Text as Text

19+import Data.Text (Text)

1820

1921import qualified AST.Helpers as Help

2022import qualified AST.Module.Name as ModuleName

2123import qualified AST.Variable as Var

2224import qualified Elm.Package as Pkg

25+import qualified Generate.JavaScript.Builder as JS

2326import qualified Generate.JavaScript.Helpers as JS

2427

2528

@@ -27,25 +30,25 @@ import qualified Generate.JavaScript.Helpers as JS

2730-- FRESH NAMES

2831

2932

30−fresh :: State.State Int String

33+fresh :: State.State Int Text

3134fresh =

3235 do n <- State.get

3336 State.modify (+1)

34− return ("_v" ++ show n)

37+ return (Text.pack ("_v" ++ show n))

3538

3639

3740

3841-- DEF NAMES

3942

4043

41−define :: Maybe ModuleName.Canonical -> String -> JS.Expression () -> [JS.Statement ()]

44+define :: Maybe ModuleName.Canonical -> Text -> JS.Expr -> [JS.Stmt]

4245define maybeHome name body =

43− if not (Help.isOp name) then

46+ if not (Help.isOp (Text.unpack name)) then

4447 let

4548 jsName =

4649 maybe unqualified qualified maybeHome name

4750 in

48− [ JS.VarDeclStmt () [ JS.varDecl jsName body ] ]

51+ [ JS.VarDeclStmt [ JS.varDecl jsName body ] ]

4952

5053 else

5154 case maybeHome of

@@ -58,10 +61,10 @@ define maybeHome name body =

5861 getOpsDictName (Var.TopLevel home)

5962

6063 lvalue =

61− JS.LBracket () (JS.ref opsDictName) (JS.StringLit () name)

64+ JS.LBracket (JS.ref opsDictName) (JS.String name)

6265 in

63− [ JS.VarDeclStmt () [ JS.varDecl opsDictName (JS.refOrObject opsDictName) ]

64− , JS.ExprStmt () (JS.AssignExpr () JS.OpAssign lvalue body)

66+ [ JS.VarDeclStmt [ JS.varDecl opsDictName (JS.refOrObject opsDictName) ]

67+ , JS.ExprStmt (JS.Assign JS.OpAssign lvalue body)

6568 ]

6669

6770

@@ -69,10 +72,10 @@ define maybeHome name body =

6972-- INSTANTIATE VARIABLES

7073

7174

72−canonical :: Var.Canonical -> JS.Expression ()

75+canonical :: Var.Canonical -> JS.Expr

7376canonical (Var.Canonical home name) =

74− if Help.isOp name then

75− JS.BracketRef () (JS.ref (getOpsDictName home)) (JS.StringLit () name)

77+ if Help.isOp (Text.unpack name) then

78+ JS.BracketRef (JS.ref (getOpsDictName home)) (JS.String name)

7679

7780 else

7881 case home of

@@ -93,32 +96,32 @@ canonical (Var.Canonical home name) =

9396 JS.ref (qualified moduleName name)

9497

9598

96−unqualified :: String -> String

99+unqualified :: Text -> Text

97100unqualified =

98101 safe

99102

100103

101−qualified :: ModuleName.Canonical -> String -> String

104+qualified :: ModuleName.Canonical -> Text -> Text

102105qualified moduleName name =

103− moduleToString moduleName ++ "$" ++ name

106+ moduleToText moduleName <> "$" <> name

104107

105108

106−native :: ModuleName.Canonical -> String -> JS.Expression ()

109+native :: ModuleName.Canonical -> Text -> JS.Expr

107110native moduleName name =

108− JS.obj [ moduleToString moduleName, name ]

111+ JS.obj [ moduleToText moduleName, name ]

109112

110113

111−coreNative :: String -> String -> JS.Expression ()

114+coreNative :: Text -> Text -> JS.Expr

112115coreNative moduleName name =

113− native (ModuleName.inCore ["Native",moduleName]) name

116+ native (ModuleName.inCore ("Native." <> moduleName)) name

114117

115118

116−staticProgram :: JS.Expression ()

119+staticProgram :: JS.Expr

117120staticProgram =

118− native (ModuleName.inVirtualDom ["Native","VirtualDom"]) "staticProgram"

121+ native (ModuleName.inVirtualDom "Native.VirtualDom") "staticProgram"

119122

120123

121−getOpsDictName :: Var.Home -> String

124+getOpsDictName :: Var.Home -> Text

122125getOpsDictName home =

123126 let

124127 moduleName =

@@ -128,39 +131,34 @@ getOpsDictName home =

128131 Var.Module name -> name

129132 Var.TopLevel name -> name

130133 in

131− moduleToString moduleName ++ "_ops"

134+ moduleToText moduleName <> "_ops"

132135

133136

134−moduleToString :: ModuleName.Canonical -> String

135−moduleToString (ModuleName.Canonical (Pkg.Name user project) moduleName) =

137+moduleToText :: ModuleName.Canonical -> Text

138+moduleToText (ModuleName.Canonical (Pkg.Name user project) moduleName) =

136139 let

137140 safeUser =

138− map (swap '-' '_') user

141+ Text.replace "-" "_" user

139142

140143 safeProject =

141− map (swap '-' '_') project

144+ Text.replace "-" "_" project

142145

143146 safeModuleName =

144− List.intercalate "_" moduleName

147+ Text.replace "." "_" moduleName

145148 in

146− '_' : safeUser ++ "$" ++ safeProject ++ "$" ++ safeModuleName

147−

148−

149−swap :: Char -> Char -> Char -> Char

150−swap from to c =

151− if c == from then to else c

149+ "_" <> safeUser <> "$" <> safeProject <> "$" <> safeModuleName

152150

153151

154152

155153-- SAFE NAMES

156154

157155

158−safe :: String -> String

156+safe :: Text -> Text

159157safe name =

160− if Set.member name jsReserveds then '$' : name else name

158+ if Set.member name jsReserveds then "$" <> name else name

161159

162160

163−jsReserveds :: Set.Set String

161+jsReserveds :: Set.Set Text

164162jsReserveds =

165163 Set.fromList

166164 -- JS reserved words

@@ -177,5 +175,4 @@ jsReserveds =

177175 -- reserved by the Elm runtime system

178176 , "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"

179177 , "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"

180− , JS.localRuntime

181178 ]