Conditional "use"

[ion1]

The proposal

It might be nice to have syntactic sugar for a conditional use <- something, for example use <- iterator.yield(...).

This video demonstrates the desugaring for a proposed syntax in which the final use <- foo(args) within each branch of the case expression becomes foo(args, next) where next stands for the code following the case expression as a function.

use-within-case.mp4

noop is just a function such that noop(next) becomes next() in order not to do yield anything within that branch.

fn noop(next: fn() -> a) -> a {
  next()
}

Alternatives

As I realized during the following discussion, the same can be achieved in the current language as follows:

  use <- iterator.yield("foo")
  use <- case add_bar {
    True -> fn(next) {
      use <- iterator.yield("bar 1")
      iterator.yield("bar 2", next)
    }
    False -> noop
  }
  use <- iterator.yield("baz")
  iterator.empty()

Or in the case of a single iterator.yield in a branch, not needing a block:

  use <- iterator.yield("foo")
  use <- case add_bar {
    True -> iterator.yield("bar", _)
    False -> noop
  }
  use <- iterator.yield("baz")
  iterator.empty()

It is not too bad without the additional syntactic sugar, just a bit asymmetric with the explicit "next" parameter.

noop

Whether the syntactic sugar is added or not, the noop function might be useful for anyone utilizing a conditional use. Should it perhaps be in the standard library?

Original message

EDIT: Updated the message to hopefully be clearer, as the original message resulted in confusion in the following discussion.

The original message

Is there a nice way to do a conditional use <- something, for example use <- iterator.yield(...)? I'm new to the language and I didn't get suggestions when I asked on the Discord server.

In case there isn't, my proposal follows.

I would like to be able to write code such as

use <- iterator.yield("foo")
case add_bar {
  True -> use <- iterator.yield("bar")
  False -> use()
}
use <- iterator.yield("baz")
iterator.empty()

where the use() stands in for whatever syntax would be adopted for a no-op "use".

My proposal is the syntactic sugar where

case VALUE {
  PATTERN1 -> use <- fn1(...)
  PATTERN2 -> use <- fn2(...)
  PATTERN3 -> {
    // ...
    use <- fn3(...)
  }
  PATTERN4 -> use()
}

would desugar into

use <- fn(cont) {
  case VALUE {
    PATTERN1 -> fn1(..., cont)
    PATTERN2 -> fn2(..., cont)
    PATTERN3 -> {
      // ...
      fn3(..., cont)
    }
    PATTERN4 -> cont()
  }
}

Given a result value,

let result = case VALUE {
  PATTERN1 -> use <- fn1(...) // Note: not "use result <- fn1(...)"
  PATTERN2 -> use(result_value)
}

would desugar into

use result <- fn(cont) {
  case VALUE {
    PATTERN1 -> fn1(..., cont)
    PATTERN2 -> cont(result_value)
  }
}

[lpil]

Use doesn't have any particular semantics, it's just sugar for a function call. Given the function could do anything how would we know what the no-op could be?

What would your example look like rewritten using the regular function call syntax instead of use?

[ion1]

iterator.yield("foo", fn() {
  fn(cont) {
    case add_bar {
      True -> iterator.yield("bar", cont)
      False -> cont()
    }
  }(fn() {
    iterator.yield("baz", fn() {
      iterator.empty()
    })
  })
})

The no-op "use" would only have a meaning within case expressions if they were to be desugared into the use <- fn(cont) { } form, I suppose.

The no-op "use" would be equivalent to:

use <- fn(cont) { cont() }

or in the case of a result value:

use result <- fn(cont) { cont(value) }

[lpil]

How would the compiler know what function to use as cont? It seems which one you want would be different depending on what function you "use"

[ion1]

use <- fn(cont) { cont() } works in Gleam right now. cont will be the rest of the code following the use expression.

In my proposed desugaring for use-within-case, cont will be the rest of the code following the case expression.

Let's forget the no-op "use" for the moment, as the main point is the conditional "use". For now, let's use

fn noop(cont: fn() -> a) -> a {
  cont()
}

instead.

If you desugar

case True {
  True -> use <- iterator.yield("hello")
  False -> use <- noop()
}
iterator.empty()

into

use <- fn(cont) {
  case True {
    True -> iterator.yield("hello", cont)
    False -> noop(cont)
  }
}
iterator.empty()

and (using the existing desugaring rules) further into

fn(cont) {
  case True {
    True -> iterator.yield("hello", cont)
    False -> noop(cont)
  }
}(fn() {
  iterator.empty()
})

there is no ambiguity about what cont is at any point.

[lpil]

Sorry, I don't understand. Can you show what this would desugar to (so without "use" at all).

[ion1]

Sorry for failing to explain clearly enough and thanks for your patience! Here is a full program in which example1 demonstrates the desugaring of example0 I'm proposing, and example2 demonstrates how Gleam desugars example1 right now AFAIU. example2 is without "use" at all.

import gleam/iterator.{type Iterator}

pub fn main() {
  // let assert [] = example0(False) |> iterator.to_list()
  let assert [] = example1(False) |> iterator.to_list()
  let assert [] = example2(False) |> iterator.to_list()

  // let assert ["hello"] = example0(True) |> iterator.to_list()
  let assert ["hello"] = example1(True) |> iterator.to_list()
  let assert ["hello"] = example2(True) |> iterator.to_list()

  let assert "foo" = {
    use <- noop()
    "foo"
  }
}

// Proposed syntax:
// fn example0(add_hello: Bool) -> Iterator(String) {
//   case add_hello {
//     True -> use <- iterator.yield("hello")
//     False -> use <- noop()
//   }
//   iterator.empty()
// }

// After desugaring the case expression:
fn example1(add_hello: Bool) -> Iterator(String) {
  use <- fn(cont) {
    case add_hello {
      True -> iterator.yield("hello", cont)
      False -> noop(cont)
    }
  }
  iterator.empty()
}

// After desugaring the remaining use expression:
fn example2(add_hello: Bool) -> Iterator(String) {
  fn(cont) {
    case add_hello {
      True -> iterator.yield("hello", cont)
      False -> noop(cont)
    }
  }(fn() {
    iterator.empty()
  })
}

fn noop(cont: fn() -> a) -> a {
  cont()
}

[ion1]

I realized that it can be achieved this way without the syntactic sugar for a non-block expression:

  use <- iterator.yield("foo")
  use <- case add_bar {
    True -> iterator.yield("bar", _)
    False -> noop
  }
  use <- iterator.yield("baz")
  iterator.empty()

given the function

fn noop(cont: fn() -> a) -> a {
  cont()
}

One drawback I can think of is that the mandatory _ capture makes it look a bit different from the unconditional yields.

Another is that doing two yields in the branch requires something like:

  use <- iterator.yield("foo")
  use <- case add_bar {
    True -> fn(cont) {
      use <- iterator.yield("bar 1")
      iterator.yield("bar 2", cont)
    }
    False -> noop
  }
  use <- iterator.yield("baz")
  iterator.empty()

while with the proposed syntactic sugar it would look more consistent:

  use <- iterator.yield("foo")
  case add_bar {
    True -> {
      use <- iterator.yield("bar 1")
      use <- iterator.yield("bar 2")
    }
    False -> use <- noop()
  }
  use <- iterator.yield("baz")
  iterator.empty()

[lpil]

That first version is a lot clearer to me, I'm still not quite getting how the proposal works. Given use is the most complex and confusing thing in Gleam I think we wanna keep it as simpler as possible, and we generally only want to add new features that enable new things you could not write previously in Gleam.

[ion1]

I think we wanna keep it as simpler as possible, and we generally only want to add new features that enable new things you could not write previously in Gleam.

Fair enough. However, hoping to at least manage to explain what I had in mind, here's one more attempt at doing so:

use-within-case.mp4