bf8334c · elk · git.iko.soy

228 :: Env.Environment

229 -> Valid.Expr

230 -> Env.Canonicalizer [Doc] Canonical.Expr

231−expression env (A.A ann expr) =

231+expression env (A.A ann validExpr) =

232 let go = expression env

233 tipe' environ = format . Canonicalize.tipe environ

234 throw err =

239 format = Env.onError throw

240 in

241 A.A ann <$>

242− case expr of

242+ case validExpr of

243 Literal lit ->

244 return (Literal lit)

245

246− Range e1 e2 ->

246+ Range lowExpr highExpr ->

247− Range <$> go e1 <*> go e2

247+ Range <$> go lowExpr <*> go highExpr

248

249− Access e x ->

249+ Access record field ->

250− Access <$> go e <*> return x

250+ Access <$> go record <*> return field

251

252− Remove e x ->

252+ Remove record field ->

253− flip Remove x <$> go e

253+ flip Remove field <$> go record

254

255− Insert e x v ->

255+ Insert record field expr ->

256− flip Insert x <$> go e <*> go v

256+ flip Insert field <$> go record <*> go expr

257

258− Modify e fs ->

258+ Modify record fields ->

259− Modify <$> go e <*> mapM (\(k,v) -> (,) k <$> go v) fs

259+ Modify

260+ <$> go record

261+ <*> mapM (\(field,expr) -> (,) field <$> go expr) fields

260

262

261− Record fs ->

263+ Record fields ->

262− Record <$> mapM (\(k,v) -> (,) k <$> go v) fs

264+ Record

265+ <$> mapM (\(field,expr) -> (,) field <$> go expr) fields

263

266

264− Binop (Var.Raw op) e1 e2 ->

267+ Binop (Var.Raw op) leftExpr rightExpr ->

265 do op' <- format (Canonicalize.variable env op)

268 do op' <- format (Canonicalize.variable env op)

266− Binop op' <$> go e1 <*> go e2

269+ Binop op' <$> go leftExpr <*> go rightExpr

267

270

268− Lambda p e ->

271+ Lambda arg body ->

269− let env' = Env.addPattern p env

272+ let env' = Env.addPattern arg env

270 in

273 in

271− Lambda <$> format (pattern env' p) <*> expression env' e

274+ Lambda <$> format (pattern env' arg) <*> expression env' body

272

275

273− App e1 e2 ->

276+ App func arg ->

274− App <$> go e1 <*> go e2

277+ App <$> go func <*> go arg

275

278

276− MultiIf ps ->

279+ MultiIf branches ->

277− MultiIf <$> mapM go' ps

280+ MultiIf <$> mapM go' branches

278 where

281 where

279− go' (b,e) = (,) <$> go b <*> go e

282+ go' (condition, branch) =

283+ (,) <$> go condition <*> go branch

280

284

281− Let defs e ->

285+ Let defs body ->

282− Let <$> mapM rename' defs <*> expression env' e

286+ Let <$> mapM rename' defs <*> expression env' body

283 where

287 where

288+ env' =

284− env' = foldr Env.addPattern env $ map (\(Valid.Definition p _ _) -> p) defs

289+ foldr Env.addPattern env $ map (\(Valid.Definition p _ _) -> p) defs

290+

285 rename' (Valid.Definition p body mtipe) =

291 rename' (Valid.Definition p body mtipe) =

286 Canonical.Definition

292 Canonical.Definition

287 <$> format (pattern env' p)

293 <$> format (pattern env' p)

291 Var (Var.Raw x) ->

297 Var (Var.Raw x) ->

292 Var <$> format (Canonicalize.variable env x)

298 Var <$> format (Canonicalize.variable env x)

293

299

294− Data name es ->

300+ Data name exprs ->

295− Data name <$> mapM go es

301+ Data name <$> mapM go exprs

296

302

297− ExplicitList es ->

303+ ExplicitList exprs ->

298− ExplicitList <$> mapM go es

304+ ExplicitList <$> mapM go exprs

299

305

300− Case e cases ->

306+ Case expr cases ->

301− Case <$> go e <*> mapM branch cases

307+ Case <$> go expr <*> mapM branch cases

302 where

308 where

303 branch (p,b) =

309 branch (p,b) =

304 (,) <$> format (pattern env p)

310 (,) <$> format (pattern env p)

307 Input name tipe ->

313 Input name tipe ->

308 Input name <$> tipe' env tipe

314 Input name <$> tipe' env tipe

309

315

310− Output name st signal ->

316+ Output name tipe expr ->

311− Output name <$> tipe' env st <*> go signal

317+ Output name <$> tipe' env tipe <*> go expr

312

318

313− Loopback name st maybeExpr ->

319+ Loopback name tipe maybeExpr ->

314− Loopback name <$> tipe' env st <*> T.traverse go maybeExpr

320+ Loopback name <$> tipe' env tipe <*> T.traverse go maybeExpr

315

321

316 GLShader uid src tipe ->

322 GLShader uid src tipe ->

317 return (GLShader uid src tipe)

323 return (GLShader uid src tipe)