Block Expressions with Consistent Syntax to Declarations

[msadeqhe]

Preface

I suggest to make Cpp2 to be Expression Oriented Programming Language as much as it doesn't harm similarity with C++. In a way that every control structure (such as if and for) can be used inside expressions.

My suggestion is based on the new declaration syntax as suggested in issue #824 and discussion #757.

Briefly the new syntax changes = {...} to {...}:

nsp1: namespace { /*...*/ }
cls1: type { /*...*/ }

nsp2: namespace = /*...*/;
cls2: type = /*...*/;

fnc1: (x) -> void { print(x); }
fnc1: (x) { print(x); }
fnc1: (x) print(x);

fnc2: (x) -> i32 = x + 1;
fnc2: (x) = x + 1;

var1: i32 = 10;
var2: = 10;

Also the terser function syntax is changed from : (x) x to : (x) = x.

This new syntax for declarations is required. It leads to have definitions uniformly with either statement notation {...} or expression notation = ...;. Control structures (such as if and for) can be syntactically and semantically similar to declarations in the same way.

First, please read discussion #643 and paper P2806R1 about do Expressions. Let's name it Block Expressions. The syntax of a block expression is like this:

var1: i32 = {
    // do return 0;
    // result 0;
    = 0;
};  // var1 = 0;

Instead of return 0;, we write = 0;. It means the value of {} is equal to 0 inside the expression. In this way, = ...; will be a uniform syntax in all declarations and control structures. Also ; is required after {}, because {} is an expression (it's not a block statement), and the whole code is a single statement.

Description

Considering if control flow:

var1: i32 = 0;

if x < 10 {
    var1 = x;
}
else {
    var1 = x - 10;
}

With the help of block expressions, we can write the above example like this:

var1: i32 = {
    if x < 10 {
        = x;
    }
    else {
        = x - 10;
    }
};

As you see, the whole if control flow is put inside a block expression with {}. It ends with ;, so you can assume we replaced 0 with { if ... }, and we replaced all var1 =s with =s. That's it.

{} is optional in if when it contains = ...; in block expressions, so let's drop them:

var1: i32 = {
    if x < 10
        = x;
    else
        = x - 10;
};

Let's compact it:

var1: i32 = {
    if x < 10 = x;
    else = x - 10;
};

And compact it again to a single line:

var1: i32 = { if x < 10 = x; else = x - 10; };

Finally, we have used if control flow inside an expression to set the value of var1. It's syntactically similar to inspect expression in Cpp2:

var1: i32 = inspect x < 10 -> bool { is true = x; is _ = x - 10; };

The expression value is defined with = ...; in both if and inspect expression. Also {} in both of them is not a block statement.

In the same way we can use for and while in block expressions:

var1: generator<i32> = { for numbers do (n) = n + 1; };
var2: generator<i32> = { (copy i: i32 = 0) while i < 10 next i++ = i; };

Consistency

Now I write function declarations and control structors when they are used in block expressions to see how much they are consistent.

A function declaration:

fnc1: (x) = x + 1;

A for loop inside block expression:

var1: = { for numbers do (x) = x + 1; };

They are consistent with = ...;. They both end with ;.

A function declaration:

fnc1: (x) { print(x); }

A for loop:

for numbers do (x) { print(x); }

They are consistent with {}. They don't end with ;.

The same consistency can be checked for all declarations and control flows. Thanks.

[msadeqhe]

Another example:

var1: i32 = {
    print("Hello!");
    print("Say something:");

    while true {
        var2: string = get_user_input();

        if var2.to_lowercase() == "exit" {
            print("Goodbye.");
            = "";
            break;
        }
        else if var2 != "" {
            print("Thanks.");
            = var2;
            break;
        }

        print("Try again!");
   }
};

If a statement starts with =, it means it set's the value of {} (block expression).

[msadeqhe]

I have to explain that = ...; doesn't end the block expression, it just sets its value. If inside for and while loop, = ...; is followed by a break statement, they won't be like a yield return, hence the type of the block expression won't be generator<TYPE>. The example can be written like this too:

var1: i32 = {
    print("Hello!");
    print("Say something:");

    while true {
        var2: string = get_user_input();

        if var2.to_lowercase() == "exit" {
            print("Goodbye.");
            = "";
        }
        else if var2 != "" {
            print("Thanks.");
            = var2;
        }
        else {
            print("Try again!");
            continue;
        }

        break;
    }
};

Briefly:

• = ...; sets the value of block expression, and it doesn't end it.
• If = ...; is inside a loop, it yields the value and the type of block expression is generator<TYPE>, but if all = ...;s inside the loop are followed by a break statement, they won't yield the value, they simply set the value of block expression like the first case above.

[AbhinavK00]

I think changing declarations is a big change, but I do want do expressions in cpp2. Thet can just translate to IILEs on the cpp side. Other than that, if expressions are also great (idk about the for comprehensions).

[msadeqhe]

for comprehensions are similar to writing a coroutine function and yield from it:

// I assume the syntax of coroutine functions are like this:
loop1: (numbers: vector<i32>) -> generator<i32> {
    for numbers do (n) {
        yield n + 1;
    }
}

loop2: (numbers: vector<i32>) -> generator<i32>
       = { for numbers do (n) = n + 1; };

Now I combine it with if control flow:

loop3: (numbers: vector<i32>) -> generator<i32>
       = { for numbers do (n) { if n % 2 == 0  = n + 1; } };

But {} is already optional in for control flow, so we can write it like this:

loop3: (numbers: vector<i32>) -> generator<i32>
       = { for numbers do (n) if n % 2 == 0  = n + 1; };

If we get numbers from a local variable instead of an argument, and use the default type in loop4 declaration, and make the last ; optional in block expressions:

// It's type is `generator<i32>`.
loop4: = { for numbers do (n) if n % 2 == 0  = n + 1 };

It'll be similar to Python comprehensions:

loop4  = ( n + 1 for n in numbers if n % 2 == 0 )

The previous example is similar to this one without block expressions:

loop4: (numbers: vector<i32>) -> generator<i32> {
    for numbers do (n) {
        if n % 2 == 0 {
            yield n + 1;
        }
    }
}

It may be reasonable to have a keyword before {} to make it clear (for both programmers and tools) they yield a value instead:

loop4: = yield { for numbers do (n) if n % 2 == 0  = n + 1 };

Or any other keyword or any other notation instead of yield will do the job.

[AbhinavK00]

The = syntax is a little wierd. I found it okay but these examples involving equality comparison do look kinda bad with it.

[msadeqhe]

At first glance, it may look weird.

Let's put the condition inside parentheses for readability:

loop4: = yield { for numbers do (n) if (n % 2 == 0) = n + 1 };

But generally, it's a natural syntax in Cpp2.

[msadeqhe]

I've to explain the reason of why = ...; syntax is natural within control flows.

Currently Cpp2 has inspect expression:

var1: i32 = inspect x < 10 -> bool { is true = x; is _ = x - 10; };

The assignment operation is right to left (as it's the behavior in Cpp1 too):

• = x; sets the value of inspect expression from is true part.
• = x - 10; sets the value of inspect expression from is _ part.

Considering = ...; with if control flow:

var1: i32 = { if x < 10 = z = y = x; else = 0; };

In a similar way:

• = x; sets the value of y.
• = y = x; sets the value of z.
• = z = y = x; sets the value of block expression from if x < 10 part.
• = 0; sets the value of block expression from else part.

In a nutshell, x is the value of y, y is the value of z, and z is the value of block expression from if x < 10 part. That's because = operator has a lower precedence than < operator.

I mean if we read the assignment operation from right to left (as it's the behavior in Cpp1 too), it'll be a natural syntax in Cpp2.

EDIT: Let's assume if x < 10 is a single entity, and = ...; sets its value! The value of if x < 0 is the value of block expression!

[ntrel]

Should we support multiple statements in each branch? If so we could use a parameterized out expression:

    var1: i32 = (out r) if x < 10 {
        foo(x);
        r = x;
    } else r = x - 10;

Note r is not declared with an initializer, so it becomes the result of the expression. Initialization of r would be required on all branches.

[msadeqhe]

If we compare them with the new syntax in a way that FUNCTION: () {...} has a void return type:

r: i32;

//    (copy x: i32 = 10) -> void   if x < 10 { r = x; } else { r = x - 10; }
fnc1: (     x: i32     ) -> void   if x < 10 { r = x; } else { r = x - 10; }
//  : (     x: i32     ) -> void { if x < 10 { r = x; } else { r = x - 10; } }

//    (copy x: i32 = 10)           if x < 10 { r = x; } else { r = x - 10; }
fnc2: (     x: i32     )           if x < 10 { r = x; } else { r = x - 10; }
//  : (     x: i32     )         { if x < 10 { r = x; } else { r = x - 10; } }

The first one is a parameterized if control flow.
The second and third one are function declarations.

So a labeled parameterized control flow is a function! fnc1 and especially fnc2 can be both a function and a label. Is it an acceptable behavior? If we replace if with for or while loop, it means we can break inside the loop with the name of the function. It depends on if this unification is natural in Cpp2 or not.

EDIT: A labeled parameterized control flow is syntactically different from a function, because the label is immediately before the keyword label: keyword in current Cpp2 (today). See my next comments for explanation.

[msadeqhe]

On the other hand, to fix the ambiguity problem, we can currently write a label directly before a block statement or a control flow:

fnc1: () {
    // They're function declarations.
    something1: (copy i: i32 = 10)           while x < 10 next i++ { print(i); }
    something2: (copy i: i32 = 10)         { while x < 10 next i++ { print(i); } }
    something3: (copy i: i32 = 10) -> void { while x < 10 next i++ { print(i); } }

    // They're labeled block statements or control flows.
    (copy i: i32 = 10)         something4:   while x < 10 next i++ { print(i); }
    (copy i: i32 = 10)         something5: { while x < 10 next i++ { print(i); } }
    (copy i: i32 = 10) -> void something6: { while x < 10 next i++ { print(i); } }
}

It's also more readable to see the label near the keyword of control flow.

[msadeqhe]

In a nutshell:

             // They're labeled control flows.
(PARAMS) -> RET SOMETHING: if/for/while/do ...
(PARAMS)        SOMETHING: if/for/while/do ...
                SOMETHING: if/for/while/do ...

             // They're labeled statements.
(PARAMS) -> RET SOMETHING: { ... }
(PARAMS)        SOMETHING: { ... }
                SOMETHING: { ... }

             // They're variable declarations.
                SOMETHING: TYPE-NAME       = ...;
                SOMETHING:                 = ...;

             // They're function declarations.
                SOMETHING: (PARAMS) -> RET { ... }
                SOMETHING: (PARAMS) -> RET = ...;
                SOMETHING: (PARAMS)        { ... }
                SOMETHING: (PARAMS)        = ...;
                SOMETHING: (PARAMS)        STATEMENT

             // They're type declarations.
                SOMETHING: type            { ... }
                SOMETHING: type            = ...;

             // They're namespace declarations.
                SOMETHING: namespace       { ... }
                SOMETHING: namespace       = ...;

             // It's concept declaration.
                SOMETHING: concept         = ...;

They won't conflict with each other. Additionally, all declarations may have template parameter list.

[msadeqhe]

I've corrected my previous comment about labeled parameterized control flow.

Thanks to @hsutter for the syntax of named break and continue in current Cpp2 (today).

It works well with parameterized block statements:

(copy i: i32 = 0) something: while i < 10 next i++
{
    // ...
    break something;
    // ...
}

So the suggested syntax doesn't conflict with labeled break and continue.

[msadeqhe]

@ntrel, your idea will work if discussion #626 may be approved to make out parameters to be implicit return values.

[msadeqhe]

Block expressions make it possible to have loop with a half or loop with test in the middle (AKA Dahl loop):

(copy name: string = "", copy x: i32 = 0)
while { name = get_name();
        = x < 10 && name != ""; } next x++
{
    print("(name)$: (x)$\n");
}

Without block expressions, it would be like this using infinite loops:

(copy name: string = "", copy x: i32 = 0)
while true next x++
{
    name = get_name();
    if ! (x < 10 && name != "")
    {
        break;
    }
    print("(name)$: (x)$\n");
}

I'm not saying we need this feature in while loops, on the other hand I mean block expressions will bring flexibility to the way we write Cpp2 code.

[msadeqhe]

The alternative syntax using parameterized style (please read the previous comment from @ntrel):

(copy name: string = "", copy x: i32 = 0)
while (out r) { name = get_name();
                r = x < 10 && name != ""; } next x++
{
    print("(name)$: (x)$\n");
}

or with return type style:

(copy name: string = "", copy x: i32 = 0)
// () -> (r: bool) { ... }
while -> (r) { name = get_name();
               r = x < 10 && name != ""; } next x++
{
    print("(name)$: (x)$\n");
}

EDIT: I've to mention that block expressions are not functions, hence empty () can be optional on the left side of -> in parameterized block expressions in -> (r).