3a37470 · elk · git.iko.soy

git.iko.soy/elk

on master help sign in

Use F# style function composition

3a37470Evan Czaplicki12 years ago

changelog.md+1

compare with master

unifiedsplit

@@ -17,6 +17,7 @@

18 * Unambiguous syntax for importing ADTs and type aliases (whoo!)

19 * sqrt and logBase both only work on Floats now

20+ * (.) is replaced by (<<) and (>>) as in F#

21## 0.12.3

22## 0.12.3

compiler/Generate/JavaScript.hs+16−6

@@ -369,13 +369,17 @@ binop :: Region -> Var.Canonical -> Canonical.Expr -> Canonical.Expr

369 -> State Int (Expression ())

370binop region func@(Var.Canonical home op) e1 e2 =

371 case (home, op) of

372− (Var.Module "Basics", ".") ->

372+ (Var.Module "Basics", ">>") ->

373+ do es <- mapM expression (collectLeftAssoc [e2] e1)

374+ return $ ["$"] ==> List.foldl' (\e f -> f <| e) (ref "$") es

375+

376+ (Var.Module "Basics", "<<") ->

373− do es <- mapM expression (e1 : collect [] e2)

377+ do es <- mapM expression (e1 : collectRightAssoc [] e2)

374 return $ ["$"] ==> foldr (<|) (ref "$") es

378 return $ ["$"] ==> foldr (<|) (ref "$") es

375

379

376 (Var.Module "Basics", "<|") ->

380 (Var.Module "Basics", "<|") ->

377 do e2' <- expression e2

381 do e2' <- expression e2

378− es <- mapM expression (collect [] e1)

382+ es <- mapM expression (collectRightAssoc [] e1)

379 return $ foldr (<|) e2' es

383 return $ foldr (<|) e2' es

380

384

381 (Var.Module "List", "++") ->

385 (Var.Module "List", "++") ->

@@ -399,12 +403,18 @@ binop region func@(Var.Canonical home op) e1 e2 =

399 return (ref "A2" `call` [ Var.canonical func, e1', e2' ])

403 return (ref "A2" `call` [ Var.canonical func, e1', e2' ])

400

404

401 where

405 where

402− collect es e =

406+ collectRightAssoc es e =

403 case e of

407 case e of

404− A _ (Binop (Var.Canonical (Var.Module "Basics") ".") e1 e2) ->

408+ A _ (Binop (Var.Canonical (Var.Module "Basics") "<<") e1 e2) ->

405− collect (es ++ [e1]) e2

409+ collectRightAssoc (es ++ [e1]) e2

406 _ -> es ++ [e]

410 _ -> es ++ [e]

407

411

412+ collectLeftAssoc es e =

413+ case e of

414+ A _ (Binop (Var.Canonical (Var.Module "Basics") ">>") e1 e2) ->

415+ collectLeftAssoc (e2 : es) e1

416+ _ -> e : es

417+

408 basicOps = Map.fromList (infixOps ++ specialOps)

418 basicOps = Map.fromList (infixOps ++ specialOps)

409

419

410 infixOps =

420 infixOps =

libraries/Basics.elm+22−10

@@ -46,7 +46,7 @@ which happen to be radians.

46@docs fst, snd

48# Higher-Order Helpers

49−@docs id, always, (<|), (|>), (.), flip, curry, uncurry

49+@docs id, always, (<|), (|>), (<<), (>>), flip, curry, uncurry

51-}

@@ -301,21 +301,32 @@ isInfinite = Native.Basics.isInfinite

301

302-- Function Helpers

303

304+{-| Function composition, passing results along in the suggested direction. For

304−{-| Function composition. For example, the following code checks if the square

305+example, the following code checks if the square root of a number is odd:

305−root of a number is odd:

306

307− not . isEven . sqrt

307+ not << isEven << sqrt

308

309You can think of this operator as equivalent to the following:

310

311− (f . g) == (\x -> f (g x))

311+ (g << f) == (\x -> g (f x))

312

313−So our example is expanding things out to this:

313+So our example expands out to something like this:

314

315− \number -> not (isEven (sqrt number))

315+ \n -> not (isEven (sqrt n))

316-}

317−(.) : (b -> c) -> (a -> b) -> (a -> c)

317+(<<) : (b -> c) -> (a -> b) -> (a -> c)

318+(<<) g f x = g (f x)

319+

320+{-| Function composition, passing results along in the suggested direction. For

321+example, the following code checks if the square root of a number is odd:

322+

323+ sqrt >> isEven >> not

324+

325+This direction of function composition seems less pleasant than `(<<)` which

326+reads nicely in expressions like: `filter (not << isRegistered) students`

327+-}

328+(>>) : (a -> b) -> (b -> c) -> (a -> c)

318−(.) f g x = f (g x)

329+(>>) f g x = g (f x)

319

330

320{-| Forward function application `x |> f == f x`. This function is useful

331{-| Forward function application `x |> f == f x`. This function is useful

321for avoiding parenthesis and writing code in a more natural way.

332for avoiding parenthesis and writing code in a more natural way.

@@ -344,7 +355,8 @@ This can also be written as:

344(<|) : (a -> b) -> a -> b

355(<|) : (a -> b) -> a -> b

345f <| x = f x

356f <| x = f x

346

357

347−infixr 9 .

358+infixr 9 <<

359+infixl 9 >>

348infixr 0 <|

360infixr 0 <|

349infixl 0 |>

361infixl 0 |>

350

362