The F# syntax is an incredibly simple bit of syntactic sugar.

Just replace this:

    x |> f

With this:

    f(x)

For the join example, you must do this:

    xs
    |> (x => x.join(' '))

It de-sugars to:

    (x => x.join(' '))(xs)

... which of course is simply:

    xs.join(' ')

Sure, I know. What I actually mean is that I don't grok curried functions.

Does join(a)(b) mean join(a, b) or join(b, a)? Does it mean a.join(b) or b.join(a)? And is a or b the delimiter? I don't really feel confident without looking it up or trying it out. I have a similar problem with Haskell's function syntax a -> a -> a.

If the function was called makeJoinerBy(sep)(array), it would be somewhat clearer:

    join = makeJoinerBy(' ')
    result = join(array)

in F# syntax the right side is always a unary expression, so `|> join(' ')` means `|> join(' ')(x)`

(the requirement being that join(' ') returns a function that takes one arg)

The top example relies on Lodash/fp having curried functions you can use.

The middle example would be using native stuff which is why you have the wrapper function (kinda like you'd have a function wrapping a callback)

Your example wouldn't work as the function would need to be unary.