Suggestion for minimizing usage of var/let/fn/? keywords

[L4stR1t3s]

I am not fond of the Carbon syntax of declaring variables/constants/functions/? because of the var/let/fun/? keywords being used so much, but I do understand why they exist. I would like to suggest the following syntax however to minimize the usage of those keywords when declaring/defining multiple variables/constants/functions/?:

// Declare multiple variables:
var (
    name1 : type1 = value1;
    name2 : type2 = value2;
    name3 : type3 = value3;
)
// Declare multiple constants:
let (
    name1 : type1 = value1;
    name2 : type2 = value2;
    name3 : type3 = value3;
)
// Declare multiple functions:
fn (
    name1(arg1 : type1, arg2 : type2) -> ret_type1;
    name1(arg1 : type1, arg2 : type2) -> ret_type2;
    name1(arg1 : type1, arg2 : type2) -> ret_type3;
)
// Define multiple functions:
fn (
    name1(arg1 : type1, arg2 : type2) -> ret_type1 {
        ...
    }

    name2(arg1 : type1, arg2 : type2) -> ret_type2 {
        ...
    }

    name3(arg1 : type1, arg2 : type2) -> ret_type3 {
        ...
    }
)

This can be used for classes as well when declaring/defining variables/constants/functions/?
The keywords var/let/fn/? immediately followed by a '(' indicate that until the matching ')' is found any root expression is the name of a variable/constant/function. So the compiler/IDEs/... are able to determine right away what they are dealing with.
[] are a possible alternative if this would work better or people would prefer it. {} are not a possible alternative because that would indicate a new scope.
I am not sure whether a semi-colon after the closing ')' would make sense. If this makes it easier to parse the code, definitely. Otherwise I guess it would depend on what people prefer. Personally I think I would prefer no semi-colon.
This syntax is optional so it is allowed to declare multiple sequential variables/constants/functions/? by prefixing them all with var/let/fn/? just like is done now.
An empty multi-declaration is allowed:

var (
)
let (
)
fn (
)

As well as a single declaration using multi-declaration:

var (
    name : type = value;
)
let (
    name : type = value;
)
fn (
    name(arg : type, arg : type) -> ret_type;
)

EDIT: Forgot to mention that function declarations and definitions can occur in the same fn ().

[OlaFosheimGrostad]

I think it might make sense for let and var, but I would dislike this for fn. On the other hand the keywords let and var are very short to type, so maybe stuff like this should wait until we see what real world Carbon code looks like?

[mossaiby]

Even:

var x, y, z: i32 = 0;

or:

fn test(x, y, z: i32) -> i32 {...}

Good old Pascal days!

[L4stR1t3s]

That only works for variables of the same type, and once you start declaring a lot of them in the same place, you probably want to look into using a container anyway.

[benilaunchers]

that's a great idea, but I think it will interfere with the function definition and parameters of a function. I am right with you just for multiple variables definition not for function

[CJ-Johnson]

@L4stR1t3s I believe what you are requesting is roughly what Carbon landed on. You can use Tuple destructuring to define multiple variables at the same time.

let (a: i32, b: i32, c: i32) = (0, 1, 2);

var (
  x: X,
  y: Y,
  z: Z,
) = (
  X.Make(),
  Y.Make(),
  Z.Make(),
);