I'm currently a student of FP. As I look around different syntax offer by different functional languages, I've come across a pattern in Elm sample code. I am curious about it.
Here is the sample code
myList = [{foo = "bar1"},{foo = "bar2"}]
foos = myList |> List.map .foo
In the last line here, List.map is being passed .foo. I believe this style is called point-free but what about the specific pattern of passing in an attribute to the List.map function?
Is this a more common thing? Is it possible to do this in Haskell? F#? Scala? Thanks for any help.
What is the (or is there a) formal (or informal ?) name for the pattern here? The property of an object is used as a short hand for a function that takes an object and calls said property on it?
This is actually not point free, but rather syntactic sugar and the pipe forward operator. For point free see this article.
This can be written in fsharp as follows:
let foos = myList |> List.map (fun x -> x.foo)
And you can see immediately that this is equivalent to
List.map (fun x -> x.foo) myList
So the pipe operator just flips the arguments and makes it easy to chain operations together. So you pass your function and a list to the map. And the syntactic sugar in Elm allows you to skip the function parameter, by just writing out .foo. I think that feature is quite handy, btw.
Point-free would be when you avoid specifying the parameters of the function. It's typical FP but can be difficult to read once it gets complicated.
An example:
let mySum x y = x + y
//val mySum : x:int -> y:int -> int
mySum 4 7 //11
This is point free:
let mySum2 = (+)
//val mySum2 : (int -> int -> int)
mySum2 4 7 //11