[rust-dev] Arrays, vectors...

Graydon Hoare graydon at mozilla.com
Sat Mar 24 09:40:52 PDT 2012

On 23/03/2012 10:10 PM, Steven Blenkinsop wrote:

> mentioned yet – which is the following case:  [str/10]. What type is
> this? Of course you could make it a fixed size vector of 10 strings, and
> make [(str/10)] be a slice of fixed size string of 10 bytes, but I think
> the ambiguity is worth considering before introducing it.

Ah, good catch. I guess, to disambiguate, we'd need fixed-size vec types 
to be [int]/10 then. Which is good, because it acquires symmetry with 
the literal form; but it's getting less and less appealing-looking.

Visual survey time:

   disambiguated proposal:                [int]/10        str/10
                                          [1,2,3]/_       "hi"/_

   (still, I think, my preference)

Other possibiltiies:

   different suffixes for str vs. []:     [int x 10]      str/10
                                          [int/10]        str[10]
                                          [int x 10]      str[10]
                                          [int * 10]      str<10>

   same suffix, some other choice:        [int].10        str.10
                                          [int]'10        str'10
                                          [int]#10        str#10
                                          [int]!10        str!10
                                          [int]%10        str%10
                                          [int]^10        str^10
                                          [int]|10        str|10
                                          [int]*10        str*10

   ... or prefixes:                       10.[int]        10.str
                                          10'[int]        10'str
                                          10#[int]        10#str
                                          10![int]        10!str
                                          10%[int]        10%str
                                          10^[int]        10^str
                                          10|[int]        10|str
                                          10*[int]        10*str

   straight juxtaposition:                [int] 10        str 10
                                          [int] _         str _
                                          10 [int]        10 str

   trailing brackets:                     [int]<10>       str<10>
                                          [int]<_>        str<_>

                                          [int](10)       str(10)
                                          [int](_)        str(_)

                                          [int][10]       str[10]
                                          [int][_]        str[_]

                                          [int]{10}       str{10}
                                          [int]{_}        str{_}

   C-style numbers in square brackets:    int[]           str
                                          int[10]         str(10)

   ... or as prefixes (Go-style):         []int           str
                                          [10]int         (10)str

   switch vec to a named tycon:           vec[10]<int>    str[10]
                                          vec[_]<int>     str[_]
                                          vec<int>        str

Keep in mind, any such syntax needs to handle:

   - 'Slice' case for type, literal and pattern syntaxes
   - 'Referent' explicit fixed-size case for same
   - 'Referent' implicit fixed-size (counting elements) literals

Suggestions welcome. I still think the /N version offends my eyes the 
least, but this whole page is a bit tragic to behold. Maybe the 
trailing-() version is also .. tolerable?


More information about the Rust-dev mailing list