been a bit since I've touched c++, but is there any reason to use trailing return types in that manner aside from solving scope issue with decltype on templates? I assumed this was a way to write functions to deal with that case and not for "regular" functions.

On another note, anything with "->" is just painful to write, same thing with the (in his proposal) ":_" instead of "=" for function arguments. Just annoying.

:_ appears to mark it as a generic type parameter, the `hello` function in the example ought to be equivalent to this straight C++:

  template<typename T>
  void hello(T msg) {
    std::cout << "Hello " << msg << "\n";
  }

  hello: (msg: _) = {
    std::cout << "Hello " << msg << "\n";
  }

I kind of like this, actually, because so many people I've worked with are afraid of templates in C++, but they seem to have no trouble with essentially equivalent code using generics (in other statically typed languages) or dynamically typed languages where it "just works" (until it doesn't). Not that we'll be adopting this any time soon, but I suspect they'd be more amenable to this form when `template` seems to make them quake in their boots.

The syntax:

   void hello(auto msg){
      ...
   }

Is legal today (since C++20 IIRC) and it is equivalent to your first example.

Ah actually missed that, good catch, it does seem to be a step forward in regards to dealing with the syntactical clunkyness of templates. Now if we could have keyword arguments in functions calls without having to deal with some kludge...

I actually prefer trailing return type for the simple reason that they often get very verbose with templates, and then it can be difficult to find the function name in the declaration. With the -> syntax, the function name is always in the same spot visually.

As for -> being painful to write - that's obviously subjective, but more importantly, given that it's the operator you use to access members via pointer-like things (including smart pointers and iterators), it's already pervasive in C++.

You have to use it for lambdas, so using it everywhere makes some code more consistent and readable

Why does it need both the keywords "auto" and "int" when declaring main()? Just seems extra confusing..

This is cruft. Without auto it wouldn't be parsed as a function declaration

Allow me to hijack a little. I'm working on a new language.

Would you people object to ':' for assign and single '=' for equality ?

  int i:42
  if i=42 print "ok"

Maxima does something like this. It's weird to use. I think := for assignment makes more sense if you want = for equality (i.e. like Pascal etc.).

Golang uses : to assign in struct initialization and := for new variable assignments so there is some prior art.

Practically speaking I find : to be challenging to quickly scan out of source visually. In golang this objection is muted slightly because struct initialization usually ends up being clearly indented by the formatter.

ouch is it just me that feels

int i = 0; // pretty

i : int = 0; // ugly

i will stick to c++03 thank u very much.

I have been using C and related languages since 1980. Switched to C++, later Java. Then about 7 years ago, I went all in on Scala, and have never looked back.

Something like "i: int" is superior (at least in Scala), because the type annotation is optional. You can drop it, and just say "val i = 42". I believe it simplifies the parser as well.

There is a reason many modern languages are adopting the style.

Most new languages use postfix types. I grew up using C and C++, but now that I've learned and use Python with types and Typescript, I'm used to and prefer postfix syntax

No, it should read grammatically as English.

int x = 0 "There is an integer x with value 0"

x: int = 0 "x is an integer with value 0"

x: int 0 = "x is an integer that is zero valued"

The last one is awkward, the first one is harder to read.

They said postfix types, not postfix syntax.

Now consider how this works out in C++:

   int i;     // i is a local int
   int i();   // i is a global function returning an int
   int i(0);  // i is a local int initialized to 0.

Yes, there's uniform initialization now. But this whole thing was a problem in the first place because of poorly designed declarator syntax that doesn't extend well and is difficult to parse unambiguously.

It can actually get worse, to the point where it's impossible to tell whether a given line of code is a declaration or not. E.g. "a<b>c" can be a declaration "a<b> c", or it can be an expression "((a < b) > c)", depending on what "a" is, exactly. This can be taken to 11 with templates:

   template<size_t N = sizeof(void*)> struct a {
       template<int> struct b {};
   };

   template<> struct a<sizeof(int)> {
       enum { b };
   };

   enum { c, d };

   a::b<c>d;

The meaning of this code now depends on whether sizeof(int)==sizeof(void*) for a given implementation on which it runs. Now, granted, this isn't the kind of thing you'd find in real world code outside of IOCCC and the likes; but it's legal, so the tooling has to be able to process it anyway. And by "tooling" I mean anything that has to parse C++ at some point - not just the compilers, but also debuggers, IDEs etc.

the ugly way is easier for the parser on some edge cases. https://en.m.wikipedia.org/wiki/Most_vexing_parse

syntax "beauty" is just a matter of how used to it you are (excl brainfuck ofcourse). Admitting this, is quite a big present one can give to him/her self.

That colon is going to be quite burdensome to type, due to the need to hold the Shift key on a line where you otherwise might not need to. It might sound silly but I do think little things like this can really hinder adoption without people necessarily realizing it.

No more burdensome than using capitol letters (camel case), underscore (snake case), curly braces or quote marks.

Been using Scala for 7 years, and it has never even occurred to me this was a "burden".

Meaning no offense but if you aren't exaggerating you might want to invest some time in typing lessons. I'm not even remotely close to being an expert typist and I spend most of the day going back and forth between a C style language (C#) and modern style that uses the colon (Typescript). The difference needed to type a colon doesn't even register.

I write both C++ and Python all the time and I type enough underscores and caps all day just fine, thank you. The colon doesn't register for me when I'm writing those either. When it did register for me was precisely when I started designing my own language, attempted to design declarations with this exact syntax, played around with it, and realized this is a burden I'd never noticed before, and that this was one thing that made languages more pleasant to write in.

Think of it like font kerning. Some people notice it, some don't, but most people prefer good kerning even if they never think about it.

You must not have used Python or classes in C++, where the colon is ubiquitous?

Does `{` not require shift on your keyboard?

> You must not have used Python or classes in C++, where the colon is ubiquitous?

You misread my comment. I'm talking about cases where existing prevalent syntax for that construct does NOT already require holding Shift. Python is better in this respect since ":" requires fewer presses of Shift than "{" or "}". This is not the case when you go from "int x = 1;" to "x: int = 1;".

Moreover, the inconvenience of going from 1 Shift to 2 is not the same as the burden of going from 0 to 1. Especially because you can often combine the 2 into 1 without releasing the modifier key in between.

And furthermore, variable declarations are far more common than class or function declarations, so you can't weight them equally.

You could just change your keymap if you really need to. I used to remap / in my Spanish keyboards because normally it is shift+7.

In many non-US keyboard layouts typing the ";" requires holding shift as well, so not sure how bad this issue is in actuality.

Most non-US keyboards are terrible for programming in general. I only use my native Norwegian keyboard layout when I need to type a significant amount of text in Norwegian. Whenever I need to type some code, I switch back to US layout. I believe most other programmers do the same.

Yes, programming with anything other than the US layout is simply unbearable. I simply switched to the US layout for everything. Although to be fair my native language is Italian, which doesn't need many special characters.

Most programmers I know use native+US layouts (like you), a minority always uses US (like me), almost nobody uses a native layout to code.

I'm an English speaker, so I'm curious: Italian technically requires some accent marks, right? Do you have a quick way to do those from a US layout, or do you just ignore them in casual conversation the way people tend to ignore capitals and (some) punctuation?

Yeah, technically it requires diacritical marks, but unlike French they are only written explicitly when they fall on the final letter of a word. Italian only has seven vowels, so these are the only common ones: è é ì ó ò ù à.

What I would do is this:

- Replace them with a single quote -> E' instead of È or É and so on.

- Ignore all uncommon marks.

In most contexts, it is perfectly acceptable to do that. A native speaker would understand without giving it a second thought or considering it impolite. I write emails to my boss like that.

If I had to make something meant for the public (say a UI, or a document), then I'd switch to the Italian layout for that purpose only and then go back to the US one.

Not for Italian, but I use a US keyboard layout with the addition of German umlauts behind right alt + letters (as well as right alt + ' and right alt + ` being dead keys to put accents on letters for foreign words). I find this much better than the standard German layout which puts all of @{[]}\~ behind right alt - and most of them on the right side of the keyboard too so you have to akwardly hit the right alt + combo with a single hand.

Tell this to people using Python. Every function, if, and loop has a colon at the end.

You misread my comment. I'm not saying "colons are bad", I'm saying "excessive holding of keys is bad".

if (cond) { } requires 4 presses of Shift (or 2, if you combine them).

if cond: foo requires 1 press of Shift.

I'm not sure what part of my comment makes you believe that I think the latter comes out worse than the former. If anything, the fewer keypresses probably strongly helped Python's success without people necessarily realizing it. Moreover, this might very well be one thing hindering more widespread adoption of Python's type annotations.

You also need to consider how common each construct is. A class declaration requiring 20 excessive keystrokes is not necessarily worse than a variable declaration requiring 1 excessive keystroke.

The number of excessive keystrokes is largely irrelevant (as long as it isn't an order of magnitude too much), because typing the code on keyboard is generally far from the limiting factor for the speed of writing code.

Most of the time you spend thinking about what you should be typing.

So optimizing for the number of keystrokes is optimizing for the wrong metrics

But Scala and lots of other programming languages use ":" with no hindrance to adoption.

Also consider this: lots of hugely frequent characters and symbols that don't require SHIFT in EN-US keyboards do in other keyboards layouts, for example Spanish. So this cannot be a consideration, at least not a major one.

> But Scala and lots of other programming languages use ":" with no hindrance to adoption.

It's kind of weird to see you assert that with no attempt to establish its truth when Scala is something like... the ~20th most popular language? Whereas Python, C, C++, Java, VB, C#, etc. are right at the top. So either this is one of the (obviously many) factors hindering wider adoption of Scala, in which case the relative popularity is entirely consistent with this, or it isn't a factor, in which case the it would make sense to present at least some evidence to the contrary given that your assertion goes against the popularity rankings.

> Also consider this: lots of hugely frequent characters and symbols that don't require SHIFT in EN-US keyboards do in other keyboards layouts, for example Spanish. So this cannot be a consideration, at least not a major one.

I'm pretty sure the popularity of {most software technologies} outside the US and inside the US are very far from being independent variables.

> It's kind of weird to see you assert that with no attempt to establish its truth when Scala is something like... the ~20th most popular language? Whereas Python, C, C++, Java, VB, C#, etc. are right at the top

The barrier to adoption of Scala has to do its functional programming side, as well as its complex libraries and types.

Kotlin also uses ": type" syntax, by the way. As does Python!

> I'm pretty sure the popularity of {most software technologies} outside the US and inside the US are very far from being independent variables.

It's hard to understand your point. Are you arguing that programming languages are less popular outside the US? Or "most software technologies"?

So let's sum it up: SHIFT concerns are very minor in comparison to other programming language ergonomics (in which need I remind you, C++ never fared very well), and the ": type" syntax is very common and mainstream in programming languages, with no hindrance to adoption.

No emacs user would even notice.

Or Vim and Python users. They type ":" a lot.

I actually have <space> mapped to : in Vim precisely because it's easier to press.