9 ms·

That's like the function composition operator [1] in Haskell, right? Very neat :D I wonder if there's an equivalent macro in Scala ... [1]: http://lambda.jstol

• emillon 10y ago
  It's more like the pipe operator in ocaml (http://blog.shaynefletcher.org/2013/12/pipelining-with-operator-in-ocaml.html http://blog.shaynefletcher.org/2013/12/pipelining-with-opera...). The lisp version has the extra advantage that you don't have to repeat it between all the intermediate functions. ((->> 2 (* 100) str count) vs 2 |> (* 100) |> str |> count).
  • greggyb 10y ago
    I understand how a lisp implementation would work here to require only the single operator (I'm assuming a fairly simple macro). Would it not be possible to do something similar in another functional language to take a <pipe function> and apply it sequentially to a list of function calls?
    • emillon 10y ago
      There are no semantic problems with this, but typing will get in the way: you can express it fairly easily if all the functions have the same type (such as Int -> Int): actually it's just 'foldr ($)'. But it is difficult to type a list of functions such as each member's return value has the same type as the next one's parameter (symbolically, [an-1 -> an, ..., a1 -> a2, a0 -> a1]). It's easier to refer to the composition of such functions, which is why you would see it as 'h . g . f'.
• kilotaras 10y ago
  |> from scalaz. API is not that usable though. F# have List.map, List.filter functions for example, which are not present in scala.
  • premium-concern 10y ago
    It doesn't seem to have worked out for F# as they have recently adopted what Scala has been doing for years.