Odtnhj

To explain why I've come up with this question, I'll explain python3's commonly used multiline list/dictionary notations and what actual syntax definition looks like.

This is the most commonly used multiline list notation in python3:

list_variable = [
 'value1',
 'value2',
 # The last comma after 'value2' is sometimes omitted.
]

And, to understand how this notation is recognized by parser, we need to look at grammar definition(link).

In the definition of python, list-like definitions are defined similar to this:

list_like: '[' [element (',' element)* [','] ] ']'

Let me explain this a little bit more, just in case you're not familiar with syntax definition or I'm a bad summarizer:

1. '' means it is actually a character. For example, '[' and ']' are list's ending or beginning in pure character, which will be [ 'value1', 'value2', ] in actual code.




2. element is their type's expected elements. for example, If it's a list, it will be a single variable. If it's a dictionary, it will be key ':' value.




3. means all things inside that are optional.




4. () means all things inside that are in one set. i.e. It all comes together.




5. * means a syntax set preceding that may occur 0 or more times. In this example, (',' element) may be omitted, but it also may occur 3 times.




6. I almost forgot to mention, that these rules are applied after whitespace managing is done.

Okay, so let's have a look at list's parsing example:

1. 
   

   [1]

   
   
   

   will be parsed into '[' element ']'

   
   


2. 
   

   [1, ]

   
   
   

   will be '[' element ',' ']'

   
   


3. 
   

   [1, 2]

   
   
   

   will be '[' element (',' element) ']'

   
   


4. 
   

   [1, 2, ]

   
   
   

   will be '[' element (',' element) ',' ']'

   
   

So, as you see, in the example 3 the comma is paired with 2, not 1.
Also, in the example the last comma is not paired with 2 - it actually is paired with nothing in terms of syntax definition.

Now the actual question is:
Is there more reasons to use comma before newline, except for the fact that most languages were using that commonly?
I think it is sensible to use comma after newline, for these reasons:

1. It's more similar to actual syntax definition.




2. It ensures that there will be always exact number of commas(number of elems - 1), and that helps when you're dealing with languages that hates additional leading comma, for example SQL.



3. 
   

   It also is git-friendly, like comma-before notation: If you add a new element to the list, git diff will show + , new_element only.

   
   
   

   In fact, in comma-before-newline notation if someone forgot to add a comma after old_element(Or because the language doesn't allow additional comma), someone who adds an element after that will see a git log like this:

   
   

- old_element
+ old_element,
+ new_element,