This is currently not well supported in squint yet

you can hack around it with js* perhaps:

(js* "function* () {}")

issue welcome

That's what I've been trying, but I'm not sure how to actually get a body into the function :thinking_face: This get's close:

(defmacro my-fn [[& params] & body]
  `(js* "function* ~{} {\n~{}\n}"
        ~params
        (do ~@body)))

I think you need to write ~'js* in the macro, else js* will get namespaced

this won't solve your issue though

I think it would be better to solve this in squint than hack around it

It actually produced the same output without un-namespacing the *js :thinking_face:

I'm opening an issue now 🙂

Thanks for your time 🙏

for now you can make use (js/eval "function* ...) or write the function in JS

At that point it's better to just not use squint for now. I'm only playing so I can come back to it later 🙂

sure. the function* might be difficult in combination with do and let expressions since they use IIFEs. I haven't tested this yes, but something like:

(defn ^:* foo []
  (js-yield 1)
  (js-yield* [1 2 3])
  (let [x 1 _ (js-yield 2)]
    (js-yield x)
  (do 1 2 (js-yield 3) 4))

will compile into:

function* foo() {
  yield 1;
  yield* [1 2 3];
  (function() ...)()
  (function() ...)()
}
 

and I'm. not sure if you can use yield in those IIFEs

Yeah, that's not ideal :thinking_face:

I don't think you can, my editor complains at the very least

the same is true for async but that is a solved problem, the solution in squint it to make those IIFEs async too

but for yield that may not work well

If that were the route you went down I think you could prefix the iife with a yield* too

yeah perhaps

it is a similar problem with async, except with a generator IIFE I don't know for sure if a user is going to be using the return value of the IIFE or simple will use yield. e.g.:

(let [x (let [y (do (js-yield 1) 5)] y)] (js-yield x))

in the async case I simply added a await before the IIFE which is sufficient to cover all cases, even if you don't use js-await inside of the IIFE

This could be a solution for the return value:

function* foo () {
  yield 1;
  yield* [2, 3];
  let x = (function* () {
    yield 6;
    yield* [7, 8, 9];
    return "This is X";
  })();
  while(true) {
    const { value, done } = x.next();
    if (done) {
      x = value;
      break;
    } else {
      yield value;
    }
  }
  console.log('x', x);
}

so x is the IIFE that we don't know if it contains yields or not

yeah that's it

Some thoughts: • Would it be possible for a user to have access to x while it's still a generator, say if something in it threw an exception? • If a js-yield is the last statement in the do would it generate return yield value? This is fine but x ends up undefined

If it's possible: this depends on how it gets implemented. Write out the JS and we'll find out :)

I liked your expansion into

(function () {
yield ...
x = /* return value */
})()

(let [x (do (js-yield ..) 1)] ...)

if you want that, then explicitly define a ^:gen function yourself

These seemed like some fairly natural expansions: https://gist.github.com/Akeboshiwind/f55646c8e98793ec27af84506bd7969d

Wrapping the do with a try seemed like a problem case :thinking_face:

But maybe I'm missing something better

I suppose in that case I would expect the catch to set the value of x so that should be fine too :thinking_face:

I think your try/catch case works like expected, since in the catch there is no return value so x remains undefined

Yup, if I put a 7 at the end of the catch then I can see how that'd work as I expected 👍

👍

there's now also an nrepl server, maybe this works better for you

gotta catch some 💤 but will check back tomorrow