<d1b2>
<TiltMeSenpai> does it? I might have just been looking at pysim
<whitequark>
pysim is extremely different from glasgow
<d1b2>
<TiltMeSenpai> ok, fair
<d1b2>
<TiltMeSenpai> oh wait, no I was talking about nmigen
<whitequark>
and the problem with pysim is that you do things like `yield x` to read signals
<whitequark>
which you just can't do with async/await
<d1b2>
<TiltMeSenpai> sorry, trying to figure out where I was in the convo
<d1b2>
<TiltMeSenpai> in python 3.6, they added async iterators, they're yields in async functions that you access with async for..
<whitequark>
nope, won't work
<d1b2>
<TiltMeSenpai> ok, you know your code better than me
<whitequark>
async iterators are a composition of async code and coroutines
<whitequark>
what i want is an `await nonfrom` basically
<whitequark>
(normal `await` is equivalent to `yield from`)
<d1b2>
<TiltMeSenpai> thanks for explaining
<whitequark>
pysim at some point will migrate to using async/await
<whitequark>
but it's going to be a fairly significant breaking change
<awygle>
can you elaborate on "await nonfrom"?
<whitequark>
okay, how much do you know about coroutines and async/await in python?
<awygle>
... nothing.
<awygle>
ok that's not fair, i know what a coroutine _is_
<awygle>
idk what python does, not even whether they're stackless or stackful
<whitequark>
okay
<whitequark>
so. coroutines. if you use a `yield` or `yield from` construct, that function becomes a coroutine, aka a generator
<awygle>
right
<whitequark>
`yield` lets you suspend a coroutine, exchanging a value either direction
<whitequark>
`yield from x` semantically works the same as `for y in x: yield y`, but it's done on the interpreter level
<whitequark>
[well not quite because yield returns a value, but you get the concept]
<whitequark>
i think this is classified as "stackless" but you can compose them
<awygle>
okay
<whitequark>
now, async/await. they started out as the exact same thing. in fact `async` used to be a decorator
<whitequark>
`async` is a way to say "this function must be an IO coroutine, even if it doesn't have any yield points"
<whitequark>
(by "IO coroutine" here I mean the kind of coroutine used by async/await)
<whitequark>
so with just the `yield`/`yield from` syntax, you don't have an easy way to say that. you could do something silly like `if 0: yield`
<whitequark>
`await` is the same as `yield from` for IO coroutines
<whitequark>
and it used to be just `yield from`
<awygle>
okay
<whitequark>
there's no equivalent of `yield` for IO coroutines.
<whitequark>
so you can have IO coroutines yield to other IO coroutines... but the surface syntax doesn't expose any way to actually request the reactor to do some useful work
<awygle>
okay
<awygle>
i see what you're saying
<awygle>
this is maybe related to my longstanding discomfort with async/await generally and in C# and Rust specifically, but let's not pull that into this discussion lol
<whitequark>
also the reason I'm saying "IO coroutines" is that since async/await became a core feature, they baked it in deeper, and now you can have a function that is *both* an IO coroutine and a normal coroutine / generator
<whitequark>
the `async for` stuff TiltMeSenpai mentioned earlier
<awygle>
so in the "legacy" yield/yieldfrom syntax, you want to be able to yield out of, like, sim modules and stuff
<awygle>
and there's no good way to do that in the async/await syntax (at least not at the level we've discussed to this point)
<whitequark>
yeah. migen used yield/yield from since it predates async/await
<whitequark>
much less async/await in core
<whitequark>
rjo suggested that Values and Assign become awaitables