Behavior of loop (and friends) with a fiber

[afranchuk]

Hi all! I'm somewhat new to Janet. However I was surprised by some behavior I observed.

I have a codebase where some compiled code is executed which might yield some values. All of those expressions are run within a single fiber, and I use seq at the top level to collect all the yielded values. This works as expected.

However, I wanted to wrap each compiled expression (there are many) in a fiber to check whether they individually yield any values, and then yield the value up to the parent fiber again.

I started with

(def fiber (fiber/new f :iy))
(var yielded false)
(loop [v :in fiber]
    (set yielded true)
    (yield v))

but I found that this didn't work! For some reason, the loop was never executed (not even for the returned value from f). After scratching my head a lot, I thought that maybe loop did something different than I expect, so I replaced it with

(while (fiber/can-resume? fiber)
    (def v (resume fiber))
    (set yielded true)
    (yield v))

and this worked!

So my question here is, what is the actual behavior of loop, and why does it differ from the while loop I wrote? I started to look into the implementation to figure out the difference (maybe something to do with the next/in implementation which seems to be used?) but I figured it might be faster to ask.

[ianthehenry]

Consider this:

(defn returns-value [] "returned this value")
(defn yields-and-returns-value [] (yield "yielded this value") "returned that value")

(print "# returns-value loop:")
(def fiber (fiber/new returns-value :iy))
(loop [v :in fiber]
  (print v))

(print "\n# yields-and-returns-value loop:")
(def fiber (fiber/new yields-and-returns-value :iy))
(loop [v :in fiber]
  (print v))

(print "\n# returns-value resume:")
(def fiber (fiber/new returns-value :iy))
(while (fiber/can-resume? fiber)
  (print (resume fiber)))

(print "\n# yields-and-returns-value resume:")
(def fiber (fiber/new yields-and-returns-value :iy))
(while (fiber/can-resume? fiber)
  (print (resume fiber)))

# returns-value loop:

# yields-and-returns-value loop:
yielded this value

# returns-value resume:
returned this value

# yields-and-returns-value resume:
yielded this value
returned that value

loop is calling (next), and (next) will only return values that the fiber yields -- the final return value of the function passed to the fiber is not actually yielded; it's a separate thing.

(resume) meanwhile will return yielded values or the final return value (and you can differentiate them by checking (fiber/status) after calling (resume).

[afranchuk]

@ianthehenry thanks for the response. That's a very good difference to note! I actually left out a detail here, which is that I am filtering to only yielded values (sorry for the not-so-accurate example) in the while loop by checking that fiber/status is not :dead in the loop body. Ultimately I'm seeing different behavior in the case where I know there is in fact something yielded. In other words, I know some expressions yield values, and in the case where I'm using loop I never see the loop body execute.

[ianthehenry]

There are plenty of other statuses that a fiber could take on, but given the signal mask you included I don't think that could explain it. I don't know of another reason why resume would behave differently than next if you're only catching :y. Do you have code that demonstrates the difference you're seeing?

[afranchuk]

You know what, I revisited the code in question, cleaned some extraneous bits up, and it works now. I had been futzing around with things a lot, so I think I had accidently done something else that was preventing the loop from running (like having an extra :when on the loop checking the fiber status). Thanks for your help and the clarification of the difference of resume and next!