Generator functions

[lilactown]

Proposal

(defn ^:gen my-generator []
  (yield 1)
  (yield 2)
  (yield 3))

Potential alternatives: defn*, defn ^:generator

Rationale

Generators are a fundamental construct in JS that enables novel evaluation semantics. Fundamentally they are lazy, stateful state machines written with a single keyword yield. The following use cases use generators as a building block

• Building infinite sequences (see LazyIterable in this project)
• js-csp, a port of core.async to JS
• crank.js, a React alternative that uses generators for stateful components

Considerations

Building lazy iterables

In Clojure, there is lazy-seq for building custom lazy sequences. We could provide a simple alternative: a lazy function that accepts a generator functions

(defn ^:gen -foo []
  (yield 1)
  (yield 2)
  (yield 3))

(def foo (lazy -foo))

(vec (map inc (foo)))
;; => [1 2 3]

(vec (filter even? (foo)))
;; => [2]

Async generators

Whatever syntax we pick should interop with async functions.

(defn ^:async ^:gen fetch-pages []
  (loop [page 0]
    (let [data (await (fetch-page page)]
      (yield data)
      (recur (inc page)))))

[borkdude]

@lilactown Looks good to me, but I propose we write (js/yield ...) and (js/await ...), since those symbols would be unresolved with clj-kondo otherwise?

[borkdude]

[lilactown]

We can add custom support for Clava :)

[borkdude]

Maybe eventually, but I'd rather delay that until we have fleshed out things more.
Another option could be this:

(:require [clavascript.core :refer [await yield]])

so teach kondo where they come from.

[borkdude]

(which would just be a no-op for clavascript)

[borkdude]

If we would have a specific extension for clavascript, .clvs, we could teach clj-kondo eventually, or so.