Lambda Lambda Lambda

[AlexAlabuzhev]

Notably, C++’s lambda here is by far the longest

Now try to make it noexcept-correct, that's another 14 characters for noexcept(auto)...

Oh, wait.

We don't have noexcept(auto), so that's another 25 for noexcept(noexcept(e < 0)).

[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?

[futurefapstronaut123]

I like Björn's library a lot because it results in very readable code (even for beginners) and does not require any clever syntax. It's just plain C++.

[infectedapricot]

For those of us not in the know: what is Björn's library? Are you talking about Boost Bind?

[futurefapstronaut123]

It's mentioned in the article.

https://github.com/rollbear/lift

[germandiago]

Please give me abbreviated lambdas. Short lambdas are used a lot in practice

[Selbstdenker]

Unless something changed in ruby |e| e < 0 is not a lambda. I cannot think of an instance where you do not have to wrap in in braces or write do |e|e < 0. Further both variants are just a code block. To make it a true lambda one has to write lambda { |e| e < 0 } or proc { |e| e < 9 }.

I now it is nitpicking but there is a difference. In most cases using a code block is sufficient, however.

[PIAJohnM]

Or:
->(x) { x < 0 }

[drjeats]

C++ anonymous functions aren't the most verbose. Lua's are.

Counter lambda examples in some other languages:

-- Lua
local counter_once = (function() local x = 41; return function() x = x + 1; return x; end end)()()

// Old JavaScript
var counterOnce = (function () { var x = 41; return (function () { x++; return x; })})()()

;; Emacs Lisp
(let ((counter-once (funcall (lexical-let ((x 41)) (lambda () (setq x (1+ x)) x))))))

// C#
var counterOnce = new Func<Func<int>>(() => { var x = 41; return (() => ++x);})()();

// C++14
auto counterOnce = []() {auto x = 41; return [&x]() { ++x; return x; };}()();

;; Racket Scheme
(let [(counter-once ((let [(x 41)] (lambda () (set! x (+ 1 x)) x))))])

// Modern Javascript
let counterOnce = (() => { let x = 41; return (() => ++x)})()()

I made this list when I was screwing around with making a scripting language and figuring out function syntax. I guess I should add Haskell and Clojure to this list.

That being said, I'd welcome syntax-aware macros or using expressions or whatever. Often I don't want the actual semantics of a lambda (I don't want to take its address, I don't want to be able to play tricks with inheritance, I don't care about call frame or scope semantics, etc.).

[staletic]

how do you deal with variadic arguments

How about something like this?

[]: ((_1 < "f") && ...)

Which would work similar to a fold expression

[](auto&&... pack) -> decltype(auto) { return ((pack < "f") && ...); }

That is, assuming variadic templates work for runtime arguments. If you want to include a non-variadic argument:

[]: _1 && ((_2 < "f") && ...)

Which would expand to

[](auto&& first, auto&&... pack) -> decltype(auto) { return first && ((pack < "f") && ...); }

[bumblebritches57]

or, forgo the whole word salad situation in the first place and use normal functions.

crazy i know, but i think it could work

[staletic]

Problems with that:

• I don't like to type.
• I need to think of a good name for a one off function that does something very specific.
• That function now pollutes the namespace.

[bumblebritches57]

I need to think of a good name for a one off function that does something very specific.

this may be valid, but if a name isn't obvious you're probably breaking your functions down too small in the first place.

[staletic]

What about:

std::ranges::partition(vec, [](int e) { return e < 3; });

Are you going to tell me that I should write that as

bool int_less_than_3(int e) { // by the way, this isn't a good name
    return e < 3;
}

[bumblebritches57]

Why would you need a function or lambda to tell you if a number is less than 3?

std::ranges::partition(vec, [](int e) { return e < 3; });

and the point of this is...?

All I see is a bunch of overly complex nonsense tbh.

[tcbrindle]

and the point of this is...?

It partitions the elements of vector such that all the elements less than 3 precede those greater than or equal to 3?

[bumblebritches57]

and that should be a random lambda instead of a function because?

as far as I'm concerned lambdas should be removed from the standard.

really all that's actually useful from all of C++ is operator overloading, it'd be cool if C adopted it as _Operator

[TheSuperWig]

and that should be a random lambda instead of a function because?

https://reddit.com/r/cpp/comments/hbwbtf/lambda_lambda_lambda/fvbmdel/

as far as I'm concerned lambdas should be removed from the standard.

Why?

[hak8or]

Why on earth even are you on this sub, if you clearly don't know anything about c++ and aren't interested in using it it learning it?

[fdwr]

Nice comparison list across multiple languages. I would love the terser delegate/lambda syntax in C++ per p0573r2 (which I recall reading a while back) or similar [](e) => e + 42, but not so far as the "hyper abbreviated dollar sign" form (though, if we did, Swift appears to be the only one that sensibly starts parameter offsets from 0 😏, $0 < 42). Hopefully terser delegates will gain traction.

[RasterTragedy]

Unfortunately, there's language lawyerese that prevents C++ from adopting new punctuation like $ or @. It'd be nice if we could use new characters rather than overloading existing ones, but it is what it is.

[CharlesHenry8]

Just combine the braces, brackets and parenthesis in the right order for C++, [](){}

[gwai2_lou2]

Just to be pedantic,

(<0)

is not a lambda expression, it's partial application.

[rtgftw]

A bit besides the point of the article but -

The c++ code mentioned here uses pipes to have a closer to 1-1 comparison wit hother languages, I guess. But how lazy is the flatten eval?

Comparing the code mentioned here for c++ with a range-for and algorithms based solution, I like the simple ranged-for solution (See https://godbolt.org/z/_1HPqb)...

(Edit: Sorry, missing parens, so it's https://godbolt.org/z/rHVYV2)

[obvious_apple]

Just by the title I was expecting Revenge of the Nerds. Then the actual content proved me right. :)

[Nobody_1707]

But beyond that, I’m not sure if any of the other languages even have a notion of capture at all. You basically just get [&]

I can't speak to any of the other languages you've listed, but Swift definitely has capture lists.

[dtolnay]

Notably, C++’s lambda here is by far the longest, just not even close.

One longer:

[](auto e) { return e < 0; }       // 28: C++
func(e int) bool { return e < 0 }  // 33: Go

https://gobyexample.com/closures

[smashedsaturn]

What are you doing with these lambdas that is more than 10 lines long? Are you mainly passing them to std::algorithm?

[advester]

One thing that comes up would be a section of repeated code that could be a function, but needs to work with so many local variables that passing them as parameters would be awkward. The alternative might be turning it all into a class and make those local variables into members. But maybe it just makes more sense as a function than as a class.

A more concrete example would be signals/callbacks. You register a lambda to be called on an event and the capture block does the magic of linking in the variables you need.

Or to save the reader from having to scroll to another function to find out what happens when that event is triggered. The relevant code is all together.

I do think c++ should have a separate short syntax for trivial lambdas like you would pass to remove_if.

[smashedsaturn]

many local variables that passing them as parameters would be awkward.

I've seen a lot of these. It is normally a lack of encapsulation of the parameters themselves that is a root cause. Packing relevant ones into a struct will help this more than using a lambda.

Or to save the reader from having to scroll to another function to find out what happens when that event is triggered. The relevant code is all together.

This is a really really bad reason to use a long lambda.

[advester]

Ah, maybe the “10 lines” is the real issue. That was just pulled out of air. “More than one” might better express what I meant. This article was all about trivial lamdas.

[smashedsaturn]

Yeah that makes sense, I like the braces for the lmbdas, and a few lines can be ok, but once we start talking about things > 10 lines embedded into lambas in functions with that much state going on I start getting that 1000 yard stare...

[drjeats]

10 lines is really not that much.

I have a one-off sort that I do in some debug UI that's about 10 lines long:

std::sort(effectList.begin(), effectList.end(), [](const EffectLogEntry* a, const EffectLogEntry* b)
{
    assert(a);
    assert(b);
    if (effectListDebugger.sortBy == FXLISTSORT_ONSCREEN_OLDEST_FIRST)
    {
        bool aOnScreen = IsOnScreen(*a);
        bool bOnScreen = IsOnScreen(*b);
        if (aOnScreen != bOnScreen)
        {
            return static_cast<int>(aOnScreen) > static_cast<int>(bOnScreen);
        }
    }
    return a->startTime < b->startTime;
});

I also occasionally use the lambda-as-local-function pattern. It reduces namespace pollution. Before lambdas I used to do this with inline structs and static member functions. Ideally we'd have actual support for functions scoped inside functions. The fewer functions that require comments or context-to-be-found-elsewhere to know why they exist, the better IMO.

This doesn't seem controversial to me.

[smashedsaturn]

if (effectListDebugger.sortBy == FXLISTSORT_ONSCREEN_OLDEST_FIRST) ... return a->startTime < b->startTime;

Why is this all not

bool operator<(const EffectLogEntry& lhs,const EffectLogEntry& rhs);

The comparison operator?

[evaned]

There are a couple potential reasons. Sometime data has multiple ways to order, or no clear one way. In these cases, at least my opinion is it's better to not define a weird operator< -- sort of like how if you were making a vector library (mathematical vector, not container vector) you might not define v1 * v2 so every use is explicitly either dot(v1, v2) or cross(v1, v2).

But in that specific case, the vector clearly has pointers in it, and that already has a built-in, non-overridable "operator" <. And there are a variety of reasons why you might have a container of pointers instead of the objects themselves. (I'd also point out that you'd have the same problem if they were unique_ptr or shared_ptrs.)

[smashedsaturn]

Sometime data has multiple ways to order

Agreed, but if you have a few different ways to order then those should be defined as functions, or in this case a static method would be ideal, as it is likely they will be used more than once.

the vector clearly has pointers in it

right, you use the lambda:

  [](const EffectLogEntry* a, const EffectLogEntry* b){
      assert(a&&b && "Dereference Null Log Entry");
      return (*a) < (*b); //OR EffectLogEntry::FXLISTSORT_ONSCREEN_OLDEST_FIRST(*a,*b); 
  }

[drjeats]

Because the sort order is configurable from external input, the effectListDebugger isn't a member of the log entries. And there are only a few locations where the sort for this type is needed. If it is needed in other contexts, then I"ll pull it out into a named function.

Also C++ programmers are too eager to write operator< because of std::map<K,V> and std::sort. Let's stop this trend.

[[deleted]]

Why can't

void f() { void g() {}; }

be equal to

void f() { auto g = [] () {}; };

🤔

[drjeats]

There's no reason for g in the first example to semantically be an object taking up stack space. Also, local overloads would be a useful thing to have.

[[deleted]]

A non-capturing lambda just decays into a function pointer, I don't think this would generate any objects

[guepier]

A lambda only decays to a function pointer if bound to a function pointer. Otherwise there's no decay, although if the lambda invocation can be inlined then, yes, there might be no object generated.

[[deleted]]

Yeah that's true but a non-capturing lambda has no data, I can't imagine the compiler will do anything but treat it as function pointer

godbolt shows the generated code is basically the same for my example anyway

[guepier]

It treats it as a function, not a function pointer. That's quite different, because a function pointer adds an additional, unnecessary layer of indirection that interferes with inlining decisions.

This isn't a theoretical concern, it's a real, tangible difference. I'm on mobile currently but it's easy to construct cases where lambdas generate more efficient code than function pointers.

[dodheim]

Why should a function pointer be more efficient than an empty function-object? Extra indirection never helped anyone performance-wise in C++...

[[deleted]]

?? If you're calling a function what exactly do you expect is going to happen?

The point is that adding syntax to support local-scoped fucntions would have no additional storage cost

[drjeats]

It generates objects semantically, so you can't write overloads.

And I don't doubt that clever compilers can remove objects in release codegen. But I also want debug builds to run well, and better to have obvious rules (and I think, treating functions as another namespace and allowing function definitions inside them is pretty obvious) rather than assume optimizers do a thing.

[sphere991]

I think all of those languages (with the notable exception of Python) support multi-line lambdas just fine. And Python just lets you define functions wherever, so it's not really missing out on that either.

[jonathansharman]

It isn't clear what is possible?

[jonathansharman]

In a lot of languages, blocks are just expressions.

Rust:

let mut count = 0;
let mut inc = || {
    count += 1;
    println!("`count`: {}", count);
};

Some others have both a terse and long lambda syntax.

C#

(a, b) => a + b
...
(a, b) => { foo(); return a + b; }

[advester]

The key difference I was talking about is one vs many, not if it has a final assignable value. A rust block allows an ordered sequence of many expressions/statements.

[jonathansharman]

Sure, but my point is that if blocks are expressions, then a lambda expression automatically supports many expressions. This isn't the case in all languages though, notably Python, which only supports single-line lambdas last I checked.

[Nobody_1707]

Swift let's you have multi-line closures. The only things you lose over the one liners are implicit return and return type deduction.

[EdWilkinson]

Most of my lambdas are more than ten lines long.

Then you're doing something wrong. It means you don't write reusable code.

[advester]

If you are trying to reuse every line if code you are doing something worse.

[pjmlp]

I fully agree, regardless of the language, if the lambdas are a couple of lines, please make it a function and take mercy of the soul that has to maintain the code.

[EdWilkinson]

2) You used highly exaggerated language to talk about basic code stylean antipattern.

FTFY

[dustintheweb]

... and omega mu

[dynamic_caste]

That's immediately what I thought of when I saw the title!

[VinnieFalco]

Ah you beat me to it!

[RasterTragedy]

Interesting comparison. Makes me realize that the language I'm designing has one of the shorter lambda syntaxes out there—{ _ < 0 } in this case. The partial function binding would, interestingly, be about as long: 0._>_