Syntax sugar for record with same type name

[0komo]

Sometimes writing a record with same name for the type is unconvenient, especially if it's repetitive. For example

pub type User {
  User(id: Int, verified: Bool)
}

pub type Pool {
  Pool(name: String, votes: List(User))
}

pub type Message {
  Message(id: Int, owner: User, pools: List(Pool))
}

Instead of writing repetitive type A { A(B) }, we can just have type A(B).

pub type User(id: Int, verified: Bool)
pub type Pool(name: String, votes: List(User))
pub type Message(id: Int, owner: User, pools: List(Pool))

There's might be a better form for this syntax, since it's ambiguous for generic syntax.

[lpil]

Could be good! Though as you've pointed out that syntax is already in use for type parameters. We'd need to use some other syntax.

[LuckShiba]

Maybe the classic cpp-like Type<Parameter> could be used

[lpil]

What would that look like?

[LuckShiba]

pub type User(id: Int, verified: Bool)
pub type Pool(name: String, votes: List<User>)
pub type Message(id: Int, owner: User, pools: List<Pool>)

[lpil]

Breaking changes are not possible now the language is v1, and we deliberately use the same syntax for both type and value construction.

[0komo]

I'd prefer something like this.

pub type record User(id: Int, verified: Bool)
type record Vector(T) (vect: List(T))

It's like the opaque keyword, except this is record keyword and it's after type keyword. This will distinguish ambiguity with type syntax. This will also add another additional syntax, if there's two parentheses: The first one will be the generic type and the second will be the record field, if there's only one: the only parentheses is the record field.

[inoas]

This hides the difference between type and constructor/variant and makes things harder to grasp. Things like say use (or optional args provide) benefits at the call site, this provides only benefits at the definition site and personally I prefer the clarity instead, here.