[cfe-dev] Help getting started

Dave Abrahams dave at boostpro.com
Tue Jan 3 04:00:25 PST 2012

on Mon Jan 02 2012, John Bytheway <jbytheway+llvm-Re5JQEeQqe8AvxtiuMwx3w-AT-public.gmane.org> wrote:

> On 02/01/12 17:57, Dave Abrahams wrote:
>> on Mon Jan 02 2012, David Blaikie <dblaikie-Re5JQEeQqe8AvxtiuMwx3w-AT-public.gmane.org> wrote:
>>> Sorry, was a bit tired I guess. I meant polymorphic lambdas (template
>>> type parameters) - I wasn't intending to suggest some other construct
>>> you hadn't suggested.
>>> I'm still not sure I follow the ambiguity resolution. Are you saying
>>> this named function template syntax would diverge from lambdas? (in the
>>> sense that a single identifier specifies an unnamed parameter in a
>>> lambda, but an untyped on in this syntax you're proposing)
>> It's not surprising that you didn't follow, because what I said didn't
>> make any sense (sorry).  I guess I see the problem you're referencing, and I
>> don't know what the solution should be yet.
> I think you're conflating two new language features that ought to be
> considered in isolation:
> 1. Automatic polymorphization of parameter types.
> 2. Automatic deduction of return types for non-lambda functions.

I agree that in principle they ought to be considered separately.
However, I want to prove that the terse syntax is achievable.

> Thinking about how to add feature 1 in isolation, in a way that works
> for all functions, function templates, and lambda functions, without the
> above-mentioned ambiguity between parameters without names and those
> without types, the solution that first occurs to me is the one suggested
> by Robert Frunzke in a comment on your C++Next article: use "auto" in
> place of the type name rather than omitting it.
> So we would write
> auto min(auto x, auto y)->decltype(x < y ? x : y)
> { return x < y ? x : y; }
> which is equivalent to
> template <class T, class U>
> auto min(T x, U y)->decltype(x < y ? x : y)
> { return x < y ? x : y; }
> And then, independently of that, we also allow the "->decltype..." to be
> omitted by following the same rules as for lambdas.

These syntax choices should probably be available to users, but they
don't quite achieve the same goal of terseness, which is especially
important where lambdas are concerned.

> Indeed, one might even want to omit both the type and the name of the
> parameter, e.g.
> void ignore(auto&&...) {}
> This also expands more easily to more general pattern-matching, such as:
> void f(std::vector<auto> const&);
> which can fill in the type in the same way that function templates do.
> Though of course it's less clear what to do with:
> void f(std::pair<auto, auto> const&);
> (my instinct is that the two autos should spawn independent template
> parameters, but one might argue that they should be the same type)

...but one would be wrong to do so :-)

Dave Abrahams
BoostPro Computing

More information about the cfe-dev mailing list