Basic streaming, request for comments

[phischu]

No description provided.

[marzipankaiser]

I'd want the program to either panic or act as if it is 0. (This is not something where I'd expect forever, and this is a place where I could see myself accidentally passing a negative number when e.g. implementing pad*).

[b-studios]

Yes, please check and panic

[phischu]

If we panic, we have to call it unsafeRepeat. I'm doing nothing for now. I wish we had Nat.

[b-studios]

Same for this, this should be in effekt.effekt somewhere in the toplevel documentation.

[jiribenes]

It would be really nice to have a couple of examples showcasing the various features so that I can get an idea of how to use it :)

[jiribenes]

By the way, here's Unison's Stream effect and Each effect (lazy nondeterminism from a stream)

Each.toList do
  use Nat <
  a = Each.range 0 5
  b = each [1, 2, 3]
  guard (a < b)
  (a, b)

[b-studios]

Can we maybe translate some Unison examples to Effekt to compare? That would be nice. @phischu could you please look into the Unison implementation as well?

[b-studios]

If you comment out the broken functions you can actually write an example which might look like this:

  val (_, l) = gatherList[Int, Unit] {
    for[Int, Unit] { range(0, 5) } { i =>
      for[Int, Unit] { range(1, 3) } { j =>
        do emit(i + j)
      }
    }
  }

  println(l)

Please note the explicit type arguments which are necessary because I need to say WHICH stream I want to handle.

This prints:

Cons(1, Cons(2, Cons(2, Cons(3, Cons(3, Cons(4, Cons(4, Cons(5, Cons(5, Cons(6, Nil()))))))))))

As you might guess, I really do not like having to annotate the types... I also don't like binding and ignoring unit in this example. It is very easy to get this example to something like:

val l = List[Int].collect {
  with i = Stream[Int].for { range(0, 5) }
  with j = Stream[Int].for { range(1, 3) }
  do emit(i + j)
}
println(l)

using a bit of phantom magic.

[phischu]

Please note the explicit type arguments which are necessary because I need to say WHICH stream I want to handle.

How about

on[Int].for { ...

Or we try to fix this at the language level.

[phischu]

(lazy nondeterminism from a stream)

This is planned in Phase 3

[phischu]

could you please look into the Unison implementation as well?

I am looking at the streaming library, which is great.

[b-studios]

on the language level probably means fixing type inference which is planned but will take a while