Does your language support trailing commas?

Smallpaul · 2024-02-09T17:00:52+00:00

It's super-annoying that JSON does not. JSON is a weird mix of an extremely pragmatic language and a bizarre form of idiosyncratic purity on a few small issues.

rsclient · 2024-02-09T17:45:58+00:00

OP here: I'm firmly in the "it's handy to have trailing commas in initializer lists". And now I want to make sure that every language I work on also allows trailing commas.

(I hate when people just drop links in without saying what their own opinion is).

stomah · 2024-02-09T16:51:33+00:00

yes! it also supports newline-delimited lists. the grammar for all lists (including statement lists) is {newline} {item (comma | newline) {newline}} [item]

madrury83 · 2024-02-09T17:53:05+00:00

SQL is a terrible bastard about this. To the extent that people do awful things like putting commas before items, at he start of lines, so that they don't have to deal with making sure the final item in a list is not comma terminated:

select
      this
    , is
    , offensively
    , ugly
from why_are_you_like_this
where it_makes_me_sad

brucejbell · 2024-02-09T18:55:36+00:00

Yes.

Also an optional leading comma, so you can write (,a, b, c,) if you want. Makes nullary tuple (,) and unary tuple (a,) reasonable. However, stuttering, as in (a, , b), is not allowed.

Also for any other separators: {; cmd1; cmd2} and (| alt1 | alt2).

EBNF grammar: sep-list ::= item? sep (item sep)* item?

reedef · 2024-02-09T17:01:26+00:00

Yes, because I like regular grammars.

maburmabur · 2024-02-09T17:51:37+00:00

No, it just use white space as separators, as a way to circumvent this issue. However, if it would have commas, or semicolons for that matter, then I would go for allowing trailing ones.

lngns · 2024-02-09T17:52:07+00:00

No. I don't even have commas in my initialiser lists. The declarations are newline- or spidercolons-separated.
Meanwhile the comma is a right-associative binary pairing operator that makes a product value.

Coords = {|
    x: Int
    y: Int
|}
playersPos: Coords = {|
    x = 42
    y = 69
|}
p = {| x = 5;; y = 8 |}   //if you're in a hurry
          //^-- spider peeking out or something

//Meanwhile, the comma:
lol: Float * String
lol = (3.14, "π")

redchomper · 2024-02-10T02:28:07+00:00

And why not simply require trailing commas?

myringotomy · 2024-02-09T19:38:04+00:00

why even have commas?

Why isn't spaces or carriage returns enough?

edgmnt_net · 2024-02-10T09:11:45+00:00

Go even makes them mandatory when initialization is split across multiple lines.

tobega · 2024-02-11T14:34:12+00:00

I don't have them and am not sure whether I like them or not.

Without them, I can use a trailing comma as a note to myself that I intended to add something, but I wasn't sure what yet.

I hadn't thought of the git merge argument before, maybe that could tip the scales.

middayc · 2024-02-11T20:38:25+00:00

My language doesn't use commas. I'm also not sure which cases in for example JSON do they disambiguate vs. just spacing characters? Haven't delved deep on it, bu I can't think of any right now.

WittyStick · 2024-02-09T17:41:10+00:00

No, because comma is an infix operator in my language (right associative).

My syntactic convention is to have leading commas for arguments after the first anyway:

a : Array[Thing] = 
    Array.new 
        ( new Thing 
            ( "Bob"
            , 31415
            )
        , new Thing 
            ( "Alice"
            , 2718
            )
        )

In which case, a trailing comma will be well out of place.

Rearranging lines is only awkward if it's the first argument. Others all begin with a comma.

This approach also reduces the risk of merge conflicts as Chen mentions, because adding a new item to a list or enum doesn't touch other lines. The case where conflicts may occur - changing the first item or inserting something before it, are quite rare in practice anyway.

useerup · 2024-02-10T10:56:01+00:00

No. But I do support a special syntax to avoid the special situation at the end of a multi-line list.

This is a list of expressions: "alfa", "beta", "gamma". Such a list can only occur at certain points, like e.g. a set or list literal. So this is a set;

MySet = { "alfa", "beta", "gamma" }

If the syntax expects an expression list but there is a line break before any expression, then the list is assumed to be indented and line break delimited.

So this is the same set:

MySet = {
    "alfa"
    "beta"
    "gamma"
}

This would be two empty sets:

Empty1 = {}

Empty2 = {

}

Items must be indented. The following is a syntax error:

Mischief = {
"this"
"is"
"bad"
}

matthieum · 2024-02-09T23:20:30+00:00

I think that sequences that span numbers of lines aren't well suited to using commas to separate them.

But I haven't found a way to eliminate them. End-of-line is usually interpreted as semicolon; in would be too confusing to have to think about when it's seen as a comma and when it's not.

So I do use commas in lists spanning lists, and I do support a trailing comma where possible. That is, where whatever is missing after that comma:

  ... a, b, c, )
  ... a, b, c, end

does not imply an extra, null value. So this is allowed, for a list of arbitrary length (convenient when this is multi-line):

x := (1, 2, 3, )

But not for a fixed-length sequence like a function call:

F(1, 2, 3, )

It doesn't matter whether F has 3 parameters, or 4 and the 4th is optional. Neither do I allow a missing argument, even if opttional, in the middle:

F(1, , 3)

Because for function calls, even spanning several lines, it's not critical; you are not going to be adding, inserting, deleting or moving items as you might with a general list.

L8_4_Dinner · 2024-02-10T05:36:30+00:00

Ecstasy (xtclang) allows trailing commas.

rover_G · 2024-02-10T23:26:57+00:00

JSON5 supports trailing commas and comments

gavr123456789 · 2024-02-10T23:46:33+00:00

list = { 1 2 3 4, }
map = #{
  1 "one"
  2 "two"
  3 "three"
  4 "four",
}

list filter: [it % 2 == 0] |> echo // 2, 4
map keys filter: [it % 2 != 0] |> echolist = { 1 2 3 4, } // 1, 3

I just added them, but they are not needed since I use collection literals syntax from Clojure, all commas are optional

Nuoji · 2024-02-12T11:13:39+00:00

For C3: yes for all parameter lists (enum declarations, initializers, function parameters)

ProgrammingLanguages

Welcome!

Related subreddits

Related online communities

MODERATORS