Universal collection syntax

[dvdvgt]

While writing tests for the newly added array function in the stdlib (#839), I have found myself using the array::fromList function quite often. We also have briefly discussed this in one of the previous Effekt meetings and here; what if we had a shared syntax for creating collections?

Idea

We re-use the emit effect:

array#[1, 2, 3]

is converted to

collectArray {
  do emit(1)
  do emit(2)
  do emit(3)
}

Note that collectArray and other functions for collecting (ha!) collections are already implemented in stream.effekt
such this would merely be a change in the parser similar to #743.

Of course, this would also work for bytearray:

bytes#[1.toByte, 2.toByte, 3.toByte]

is converted to

collectBytes {
  do emit(1.toByte)
  do emit(2.toByte)
  do emit(3.toByte)
}

(We should probably rename collectBytes to just bytes and collectArray to array for consistency.)

Caveats

• Possible performance & overhead penalty.
• Possibly confusing error messages similar to Add basic string interpolation / string templates #743.
• The syntax does not work for maps, sets and other collections that need a comparison function. I can see this changing if and once Effekt has type classes.

Benefits

• Nice and unique usage of effects!
• Better ergonomics

To Discuss

• Weigh pro and cons
• Decide on syntax

[jiribenes]

A few weeks ago, we realised that if we allow dot notation on computations, we could also have [1, 2, 3].array (where [1, 2, 3] would be a computation by default) :^)

[dvdvgt]

Ah yes, that would be even nicer. Then, this should also work for maps: [(1, "a"), (2, "b")].toMap { (x, y) => x == y }. Though, I admit this looks a bit confusing and ambiguous.

Is there an issue for this? What are the complications with allowing this syntax?

[jiribenes]

@marzipankaiser talked about UFCS on computations a while back in the context of extension methods:

interface State[T] {
  def get(): T
  def set(x: T): Unit
}

def increment() { st: State[T] }: Unit = {
  val current = st.get()
  st.set(current + 1)
}

def st: State[T] = ...

increment() {st}

~>

st.increment()

@phischu talked about UFCS support for streams (which is very similar here). myStream.map { x => x + 2 }.collectList...

[jiribenes]

Just to add to this, we technically have stream literals already: [1, 2, 3].each :)
If we had UFCS on computations, you could get a set with [1, 2, 3].each.collectSet.

We could invert it, have [1, 2, 3] as a stream literal, and have [1, 2, 3].collectList as a list literal, [1, 2, 3].collectSet as a set literal, [1, 2, 3].collectArray as a array literal, etc.
(Yes, we could bikeshed the exact names later)