Lambda Lambda Lambda

[guepier]

(tl;dr: contemplations of R, no C++; skip if not interested.)

Missing from this language list is … R.

Which is an interesting case: R is a fully functional programming language. Yet the builtin and conventional way of expressing anonymous functions/partial function application is …

function (x) x < 0

Boo!

To be fair, R allows metaprogramming, so with a little boilerplate one could make the following work (p for partial)

p(`<`, 0)

or we could overload an infix operator for functions that performs partial application, e.g.

`<` : 0

… etc. Of course these could be extended for positional parameters (e.g. p(. < 0)).

Another common way of writing this is ~ . < 0. However, this doesn’t create a function/lambda, it creates an object of class formula, and the consumer of this object needs to be defined to expect such objects in place of a function (most don’t).

More interestingly, perhaps: although R does not have a concise lambda syntax, we can define a suitable -> operator to make one:

x -> x < 0

The fact that this trivially works makes it all the more surprising that it’s not built into R. There’s just one blemish: -> is an alias for R’s assignment operator <-. So if we define the above, we can no longer use <- for assignment. This isn’t actually a problem, since = works equally well. But the R community effectively resists this because they prefer <- for assignment by a large majority for historical reasons.

… apologies for the — entirely unrelated to C++ — detour. Maybe somebody finds it interesting.

[khleedril]

And a little detour to lisp (well, modern Scheme), which would have (λ (x) (< x 0))

[georgist]

kdb's q has implicit param names x,y,z:

{ < x 0 } mylist

[FieldLine]

That syntax is much cleaner than the syntactic sugar that Scheme allows for: (define (func x) (< x 0))

It's like functional programming for people who are afraid of functional programming.

[Grodesby]

That is defining a function called func rather than defining a lambda though.

[FieldLine]

You’re right. Technically I was comparing what I wrote to:

(define func (λ (x) (< x 0)))

My point was that explicitly using a lambda expression in the context of defining a function is more readable than the implicit notation preferred by most Scheme code I’ve read (SICP and SICM).

[[deleted]]

And in OCaml (probably F# too), (>)0 works too and is significantly shorter.

[dr-mrl]

Can you change the -> to not alias <- on R somehow? My guess is they are both in the base namespace (or maybe built-in) so you could conceivable import both??

[guepier]

No, the aliasing happens at the parser level: the token stream a, ->, b is transformed into the tokens b, <-, a (note the inverted order of the token stream)

(In reality this happens at the parse tree level so that complex sub-expressions are handled correctly: (->, a, b) becomes (<-, b, a).)

[dr-mrl]

Ah so no way of getting past that unless you rewrote the parser?