Convenient syntax for "list of type"

[jobarr-amzn]

When working with ISL recently I had several occasions where I had to define a list of a given type of things.
E.g.:

type::{
    name: TodoList,
    type: { 
        type: list,
        element: text,
    },
}

I can define my own list types, but this grows cumbersome as types multiply:

type::{
    name: texts,
    type: list,
    element: text,
}

type::{
    name: TodoList,
    type: texts,
}

It would be more convenient if there was an easy way to express "list of something", e.g. something like:

type::{
    name: TodoList,
    type: list_of::text,
}

The same syntactic sugar could exist for other container types as appropriate, and should be usable in any context where a type might be expected.

[popematt]

Another possible solution that is more succinct, but also more specialized (and therefore limited in applicability), would be a syntactical sugar that expands to a union of the type or a list of that type. E.g. Foo and Bar are equivalent:

type::{
  name: Foo,
  type: list_of_or::number,
}

type::{
  name: Bar,
  type: { one_of: [ number, { type: list, element: number } ] },
}

If we want to go ahead with any annotation-based solution, we need to be careful to define how this would interact with $null_or. The easiest choice would be to say that these annotations are mutually exclusive, but if they are not mutually exclusive, does the order of the annotations matter? Consider, for example, $null_or::list_of::number vs list_of::$null_or::number. (What about $null_or::list_of::$null_or::number?)

On the other hand, if we use a S-Exp based syntax, then we can avoid any confusion around annotation ordering. E.g.:

type::{
  name: Foo,
  type: $null_or::(list_of number),
}

type::{
  name: Bar,
  type: (list_of  $null_or::number),
}

[popematt]

We could even take this premise a step further and define a macro system that would allow you to create your own syntactical sugar. For example:

schema_header::{
  macros:[
    (list_of 
      ($type) 
      { type: list, element: $type }),
    (sexp_of 
      ($type) 
      { type: sexp, element: $type }),
  ]
}

But that would complicate things because people might want to import macros (or do other things with them that I can't think of right now), and we'd need to figure out how to handle importing macros and whatever else.

[popematt]

I think that this can be solved by Ion 1.1 macros, but if we release a new version of Ion Schema before that, we can add list_of::<type> that is mutually exclusive with $null_or::.