Idiomatic way to build a list?

[willowell]

Howdy!

I'm checking out Koka from Scala and Haskell - what is the idiomatic way to build a list in Koka?

i.e., is there something like a list effect that enables something like do notation with the List Monad:

do
  x <- [1..3]
  y <- [1..3]
  pure (x, y)

-- => [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]

I am aware that Unison has something like this with their Each ability, and that this do notation is of course syntax sugar for bind / flatMap and map, etc.

Thank you!

[chtenb]

If you're looking for a list comprehension idiom, you can create one yourself:

pub effect each
  ctl each(elems : list<a>) : a
  ctl fail() : ()

pub fun guard(pred : bool) : each ()
  if pred then () else fail()

pub fun list-comp(action : () -> each a) : list<a>
  with handler
    return (x) [x]
    ctl each(elems) elems.flatmap(resume)
    ctl fail() []
  action()

pub fun main()
  val l = list-comp
    val x = each(list(1,1000))
    val y = each(list(1,1000))
    val z = x+y
    guard (z != 3)
    z * z
  l.sum()

[TimWhiting]

Alternatively, if you want to stay in the pure subset of the language - without algebraic effects (similar to Unison's abilities) - you can use flatmap + pure for this case: Adding some syntax sugar using Koka's with construct, makes it feel almost like do notation.

fun for(low: int, high: int, f: int -> list<b>): list<b>
  list(low, high).flatmap(f)

fun pure(a: a): list<a>
  [a]

fun guard(a : bool, f: () -> list<a>): list<a>
  if a then f() else []

fun main()
  val res : list<int> = 
    with x <- for(1, 4)
    with y <- for(1, 10)
    with guard(x + y != 5)
    pure(x + y)
  res.println

The benefit of this approach is it is likely slightly more performant. The disadvantage is that the semantics are baked into the computation's description - you always get the behavior of the typical list monad. In the approach with algebraic effects you could decide to make interpret the effects such that guard fails the entire computation tree, or do backtracking search to find the first thing that doesn't fail, return a full search tree instead of a flat list, or many more strategies.