What are some options for generic syntax?

Question

In languages like C++ and Rust, generics use angle brackets. For example, Vec<f64> for a vec of floats, HashMap<String, i64> for a map from strings to ints, or Option<Box<char>> for a boxed char that can be None. This isn't universal, however. For example, Haskell uses spaces.

What are some different syntaxes for generics? What are their pros and cons?

Answer 1

First-class types

In this case, we introduce a type for types: U, then we have List : U -> U, so naturally we would use the function call syntax for generics: List(Int) or like in Haskell/ML: List Int.

In case of the Map<Thing<String, int>, Option<Box<char>>> example in the other answer, we would have

• Map : (U, U) -> U
• Thing : (U, U) -> U
• Option : U -> U
• Box : U -> U
• char : U

So it would be Map(Thing(String, int), Option(Box(char))).

Answer 2

Square Brackets

Python's optional typing module uses square brackets for this, such as list[int]. The PEP that added this syntax has a lengthy analysis of why they chose that syntax, primarily that it didn't clash with any other syntax whereas angle brackets could be confused with less than and greater than signs.

Answer 3

Just, parentheses

This is what D does. For example, the following class in C#:

public class Bar<T>
{
    public T member;
}

looks like this in D:

class Bar(T)
{
    T member;
}

Source

Templates are instantiated with an exclamation point, to avoid confusion with regular function calls:

T square(T)(T t)
{
    return t * t;
}
writefln("The square of %s is %s", 3, square!(int)(3));

This has the obvious con of still being confused with a function call, and it also precludes postfix ! from having another meaning (e.g. non-null assertion, as in Swift, C#, and TypeScript).

One thing it has going for it is that it's impossible to confuse with comparisons (see also Rust's turbofish).

Answer 4

Spaces

This would look like List float, Map String int, or Option Box char.

Pros:

• Looks nicer (in my opinion), reduces clutter
• Faster to type
• Angle brackets can be inconvenient due to ambiguity or text editors failing to highlight matched pairs

Cons:

• Prefix notation can be difficult to read with nested multiple-argument generics (for example, Map<Thing<String, int>, Option<Box<char>>> would be Map Thing String int Option Box char, which takes some work to mentally parse)
• Incompatible with variadic generics

Answer 5

Specialised syntax

Like Haskell, you could use specialised syntax for specific kinds of types. For example: (A -> B) for a function that receives an argument of type A and returns a value of type B, [A] for a list of type A, (A, B) for a tuple of an A and a B. And there are other possibilities, like {A} for sets of A and {A: B} for dictionaries with A keys and B values.

Pro:

• These tend to make commonly used types less verbose. Instead of something like Func<List<A>, Func<List<B>, List<Tuple<A, B>>>> you would write [A] -> [B] -> [(A, B)].

• It can visually couple expressions and their types. For example, say [42] has type [Int], and (True, False) has type (Bool, Bool)

Con:

• This requires a more complex grammar for every kind that has a special syntax.

• User-defined types need to still have their own syntax, so you will still need one of the other answers here.

Answer 6

A pairing that you're willing to give up on using for any other purpose

Angle brackets have a strong history in this role, but < and > are also common comparison operators. Square brackets are used in a number of languages, but often overlap with an indexing operator. So are parentheses, which often have overlapping uses for function application or precedence. Braces don't come up a lot for this use, but are heavily used elsewhere for scoping and collection literals.

These overlapping uses create parsing difficulties, particularly for partially-complete code that needs syntax highlighting. At what point do you know whether x < y * z is a type expression or not? Is list[string] *z declaring a pointer to a list of strings or multiplying a value? The language implementation itself probably knows, or knows what error to throw, but other systems need to parse the code as well, as do people.

Not every language has all of those complications - perhaps all comparisons are done with methods, indexing uses parentheses, application uses juxtaposition, etc. If there's a "keyboard pair" that isn't in use elsewhere, use that one, and if there's more than one, pick your favourite.

What if they're all gone?

If you do need to use angle brackets, parentheses, square brackets, and braces all for other purposes, doubling up is a good option. list[[string]] is a little more typing, but if [[ never appears anywhere else in code then you've immediately got a clearer understanding of what's going on with only a local view. Find a pair that can't ever show up in normal code and use that.

Alternatively, shift one of the other uses to a double if that is less common. If indexing is expected to be rare but types are ubiquitous, maybe it doesn't need to squat on prime real estate.

Answer 7

Lisp-style

Another option which would work with any choice of brackets is a more lisp-style syntax: (Map String Int), (Option (Box char)), etc. One advantage of this would be that it's more visually distinct from function application.

Omitting the outermost parens feels like the most optimal mix of systems to me. Here are some examples:

• String
• Option String
• Option (Box String)
• Map String int
• Map String (Option int)
• Rc (Map String int)

One disadvantage would be that if your language has tuple types, this would be ambiguous without extra clutter.

---

Bonus wackiness: You could apply some sort of macro to a generic type using this syntax. E.g., if DBL were a macro that used a generic param twice, ((DBL Map) (Box (Option (Rc (Option char))))) would be a shorthand for (Map (Box (Option (Rc (Option char)))) (Box (Option (Rc (Option char)))))

Answer 8

Ada's approach to generic programming consists in having a generic block before the procedure being declared:

generic
  type Element_T is private;  -- Generic formal type parameter
procedure Swap (X, Y : in out Element_T);

It binds Element_T to a type name locally, making the whole syntax quite uniform.

See Generics.

Answer 9

Keyword, and then parentheses

Borrowing from Zig's comptime, how about a comptype keyword, to annotate that some names are really syntax for an compile time only type name.

// Declaration

class HashMap comptype K, V
{
    public HashMap() {}
    public put( K key, V item ) {}
}

// Use

var map = new HashMap(String, i64);
map.put( "64", 64 );