Optional trailing comma for list entities

[beutlich]

Proposal: Allow optional trailing comma in lists

It could be beneficial to allow an optional trailing comma in array, vector, matrix, enumeration, and other list-like constructs in Modelica, similar to features in Python and Julia. This improves readability, diff-friendliness, and consistency in multi-line definitions.

Proposed Grammar Updates

enum-list :
  enumeration-literal { "," enumeration-literal } [ "," ]

import-list :
  IDENT { "," IDENT } [ "," ]

argument-list :
  argument { "," argument } [ "," ]

component-list :
  component-declaration { "," component-declaration } [ "," ]

expression-list :
  expression { "," expression } [ "," ]

Note: output-expression-list remains unchanged:

output-expression-list :
  [ expression ] { "," [ expression ] } 

Benefits

1. Diff-friendly: Adding or removing elements in multi-line lists no longer requires editing the previous line, reducing unnecessary version control noise.

type Color = enumeration(
  Red,
  Green,
  Blue,  // optional trailing comma
);

2. Consistency: Aligns with common practices in modern languages like Python, Julia, and Go.

3. Tooling-friendly: Simplifies code generation and parser implementation by removing the “special case” for the last element.

This enhancement is fully backward-compatible, as all existing code without trailing commas continues to parse correctly.

[henrikt-ma]

This is a good proposal, but from where I come an optional leading comma could be considered even more desirable. When written like this,

type Color = enumeration(
, Red // optional leading comma
, Green
, Blue
);

all the comma boilerplate is nicely aligned and does not add clutter to the actual entries.

Fortunately, I think it should be possible to allow both an optional leading and an optional trailing comma at the same time.

[beutlich]

I have to admit I never typed an optopnal leading comma so far, but use optional trailing comma whenever allowed, e. g. in C++ enumerations or in Python wich also has a linter to enforce it.

[HansOlsson]

I have to admit I never typed an optopnal leading comma so far, but use optional trailing comma whenever allowed, e. g. in C++ enumerations or in Python wich also has a linter to enforce it.

Same.

However, I realized that we could generalize it for matrices as well.

The obvious would be to generalize to semi-colon, which seems useful for the same reasons:

X=[ 
      A , B;
      C,  D;
     ]

and comma also make sense in simple cases:

X=[ 
       A , 
       B, 
       C, 
     ]

but I'm not sure the combination will be useful:

X=[ 
       A, B, C, ;
       D, E, F, ;
     ]

Note: In generally don't put opening brackets on their own line, but the formatting is a bit off here.

[HansOlsson]

following this separator vs terminator discussion.

Note that output-expression-list is syntactically unchanged, but semantically it would be a backwards compatible change.

Currently (,b,)=foo(); indicates that you use the second argument and ignore the first and third output argument, which requires that foo has at least three output arguments. If we allow trailing commas it should be legal even if foo only has two output arguments.

This also indicates that the output-expression-list would cause semantic issues with a leading comma; and to me that would make leading comma confusing.