Can't declare empty arrays

[skyrpex]

I tried this

Tried creating empty arrays, using both automatically inferred types and explicitly defining the types.

let x: Array<num> = [];

let y = [];

Expected

let x: Array<num> = [];

The code above should work as is.

let x = [];

The code above should, maybe, infer an array of anys.

Instead, this happened

There was a compilation error:

Compilation failed with 2 errors
Error at code.w:1:21 | Cannot infer type of empty array
Error at code.w:2:9 | Cannot infer type of empty array

Component

Compiler

Environment

- Wing Version: 0.4.26
- OS: MacOS
- Node version: 18.12.1

Sub tasks

• let x: Array<num> = []; should compile correctly
• let arr = new Array<num>(); should compile correctly

[staycoolcall911]

since this works:

let x = Array<num>[];

There's a way to declare an empty array and the priority of this is not high.

[Chriscbr]

@staycoolcall911 Is that syntax defined in the spec anywhere? Feels to me like it should be a syntax error, since the language doesn't have any type casting mechanisms yet.

I would expect an alternate array initialization might look like

let arr = new Array<num>();

[Chriscbr]

That said it doesn't look bad honestly (also it's shorter to type) so maybe we just add it to the spec... curious what others think

[staycoolcall911]

First of all @Chriscbr, you're absolutely right! The spec defines the syntax you mentioned rather than the one currently implemented (which omits the new keyword).

BTW, omitting new for resources was discussed a couple of months ago here #361. The final decision was to keep new for now.

So to sum up, this issue is actually about 3 things:

1. Empty untyped array:

let y = []; // Fails with message: Cannot infer type of empty array

That current behavior actually makes sense to me. An alternative was to infer y's type as Array<any>, but we're still trying to figure out if we can avoid introducing any at all (track #434 ). So I regard this as a non-issue.

2. Empty typed array declaration:

let x: Array<num> = []; // Fails with message: Cannot infer type of empty array

This is a bug - it should have worked.

3. Empty array initialization:

let arr = new Array<num>(); // Fails with messages: Unknown parser error, Unknown symbol "Array" (parser errors)

This is a bug - it should have worked.

Bumping up the priority of this so we'll deal with 2 and 3.

[Chriscbr]

I wanted to summarize part of a discussion our team had today - from what I understand, I think there are at least two-ish overarching designs we are considering regarding for the syntax of collections:

Design 1: All collection types can be initialized with new Collection<T>(). Collection literals like [1, 2, 3], {1, 2, 3}, and {"a": 1, "b": 2} can be used to initialize immutable arrays, sets, and maps. [] and {} correspond to an empty array and empty map respectively, and their type can only be inferred through variable assignment (let x: Array<num> = [];). In this design, Array<num>[] and Map<num>{} are invalid syntax.

Examples:

// valid wing
let a = [1, 2, 3]; // Array<num> inferred
let b = new Array([1, 2, 3]); // maybe allowed?
let c = new Array<num>([1, 2, 3]);
let d = { "apple", "banana", "orange" }; // Set<str> inferred
let e = { "apples": 3, "bananas": 4 }; // Map<num> inferred

// invalid wing
let x = MutSet<num>(); // missing "new"
let y = new Array<num>[1, 2, 3]; // [] should be wrapped in ()
let z: MutArray<num> = [1, 2, 3]; // array literals only refers to Array, not MutArray
let w = []; // type of Array cannot be inferred
let d = { "apple", 6 }; // type of Set cannot be inferred

Design 2: All collection types are initialized with either Collection<T>[] or MapOrSet<T>{}. [] and {} can be used as literals, but only if their type can be inferred from the contents (the container will always be immutable by default - i.e. Array, Set, or Map). In this design, new Array<num>() is invalid syntax.

Examples:

// valid wing
let a = [1, 2, 3]; // Array<num> inferred
let b = Array<num>[1, 2, 3];
let c = MutArray<num>[1, 2, 3];
let d = { "apple", "banana", "orange" }; // Set<str> inferred
let e = { "apples": 3, "bananas": 4 }; // Map<num> inferred
let f = MutSet<str>{};
let f = Map<num>{};

// invalid wing
let x = Array[1, 2, 3]; // missing type parameter on Array
let y = new Array<num>(); // Array is not a class, it cannot be initialized with "new"
let z = []; // type of Array cannot be inferred
let d = { "apple", 6 }; // type of Set cannot be inferred

@yoav-steinberg brought up a neat point which is that design 2 makes collection initialization look similar to struct initialization:

let options = BucketProps { public: true };
let regions = MutArray<str> ["NA", "EU"];

Thoughts?

cc @staycoolcall911 @MarkMcCulloh @hasanaburayyan @3p3r

[staycoolcall911]

Great summary @Chriscbr, thank you!
I'll just add that the team currently votes for design 2, so this issue is actually about updating the spec to reflect this design. I suggest we wait a bit for #172 to be done and then make the changes to the spec.