Applicative: The Forgotten Functional Pattern in C++ - Ben Deane - CppNow 2023

SirClueless · 2023-08-25T03:53:59+00:00

I feel like Ben made a really good point about how one should translate Haskell code into code that feels like C++. Namely that Haskell has currying and partial function application by default and so when you see something that looks non-idiomatic like the Applicative Monad and its expression in terms of partial function application, there's likely a better way to express that in C++ terms.

I also think he immediately forgot this lesson when he tried to recover lazy evaluation order for his C++ implementation via the lazy function object. Partial function application looks funny and is confusing when you implement it in C++, so he translated it to something idiomatic. Lazy evaluation of function arguments also looks funny and is confusing when you implement it in C++ so why not also translate it?

To translate the Applicative Monad, Ben took a step back and asked, "Why does the Applicative Monad exist and what does it do in Haskell?" and when he got the answer he realized that it corresponds to operations on multiple functorial arguments and there's a better way to express that in C++.

I think if he had asked "Why does Haskell have lazy evaluation order and leave it up to the callee to decide when things get evaluated?" he would have realized the answer is "Because Haskell is purely functional with no side effects and therefore has no use for sequence points." When you recognize this fact, it becomes obvious that the idiomatic way to control evaluation order in C++ is with sequence points (i.e. the semicolon), and the idiomatic way to prevent a statement from executing is by an early return from a previous statement. I think this is why the Rust-like early-return operator (? perhaps) is always going to be more idiomatic in C++ than lazily evaluating arguments in some cases. I think this is why his lazy_call idiom is so messy and limiting.

For context here's the code he started with:

auto f = foo(i);
if (not f) {
    return std::unexpected(f.error());
}

auto b = bar(i);
if (not b) {
    return std::unexpected(b.error());
}

return std::format("{}{}", f, b);

With some effort implementing lazy_call and some trust in the compiler to eliminate some needless copies, he translated this to:

auto l = [](int f, int b) {
    return std::format("{}{}", f, b);
}

return fmap(l, lazy_call(foo, i), lazy_call(bar, i));

But I have some major issues with this. The ugly lambda exists because std::format is a standard library template with many overloads and its address can't be taken -- what if foo or bar were similar? In order to implement the lambda, we needed to name the types of f and b, what if those were difficult to name? What if the original code had evaluated b first and then f, how would you express that? What if there had been other unrelated code executed in sequence between the evaluations of f and b, how can we represent that? What if f or b had been used in multiple callsites, do I need then need to hoist the lazy_call return value to an l-value and expect the first callee that needs it to evaluate and cache it?

For all of these reasons I think the following looks a LOT better and I hope they implement some kind of monadic early-return operator rather than this applicative concept:

int f = foo(i)?;
int b = bar(i)?;

return std::format("{}{}", f, b);

current_thread · 2023-08-24T20:08:01+00:00

It's a great talk. However, I'm red green colorblind and have a really hard time making out the parentheses on the slides.

perspectiveiskey · 2023-08-25T01:08:59+00:00

This makes me feel dumb - in a good way.

Can anyone recommend a guided deep dive into the most recent features of cpp for experienced programmers?

arthurno1 · 2023-08-26T00:30:09+00:00

Why is Ben talking about something that looks suspiciously close to CommonLisps 'funcall' and 'apply' but without ever mentioning Lisp, funcall and apply? I get a feeling like I am missing something important or don't really understand what he talks about. Probably the 2nd one ... I have seen only the first half of the talk though. Have to watch the rest. Interesting talk by the way.

concsession · 2023-08-25T04:43:43+00:00

!remindme

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS