►
From YouTube: .NET Design Reviews: IAsyncEnumerable & IAsyncDisposable
A
B
The
abstractions
yeah,
so
I've
got
four
issues
here
and
I'll
probably
hop
around
between
them
little
bit,
but
I
can
provided
the
overview
and
sort
of
highlight
how
they
all
fit
together.
So
I'm
sure
most
people
are
generally
familiar
with
the
ideas
here,
but
I'll
go
over
them
again.
Today
we
have
innumerable
einem
right
or
I
disposable,
and
the
language
has
two
primary
features:
that
injury
interact
with
them
for
each
for
consuming
new
levels
and
iterators
for
producing
the
food,
but
one
of
the
biggest
asks
we've
had
around
a
second.
C
B
B
Instead
of
ienumerable,
it
has
a
kid,
a
sink,
a
numerator
instead
of
getting
numerator
and
I
think
a
numerator
instead
of
a
numerator,
and
it's
got
to
move
next,
a
sink
instead
of
to
it.
Next
we
have
a
sink
in
the
name
of
the
interfaces
for
obvious
reasons.
Otherwise
it
describes
what
it
does
and
we
can't
conflict
with
these
interface
names.
B
There
was
some
discussion
about
whether
we
would
want
a
sink
and
the
method
names
themselves
and
I
think
we
primarily
did
that
for
two
reasons:
one,
for
example,
get
a
sink
and
a
writer
returns
in
a
sink
a
numerator,
so
it
logically
matches
between
the
method
thing
of
the
return
type
and
two.
We
want
to
make
sure
that
these
interface
is
completely
implemented
on
the
same
class.
That
has
the
synchronous
implementation
as
well
and
not
having
to
run
one
of
them
explicitly,
and
if
we
want
the
both
field
to
be
implemented.
B
B
B
The
language
will
allow
you
to
add
the
await
keyword
in
front
of
the
for
each,
at
which
point
it
expects
to
be
given
an
async
enumerable.
Similarly,
the
production
side
when
you're
implementing
an
iterator,
rather
than
having
a
return
type,
the
ienumerable
and
in
the
body
having
a
yield
causing
that
to
be
a
an
iterator.
C
B
D
C
F
F
E
H
Talking
with
Christoph
this
morning
and
he'll
be
late,
so
that's
this
is
a
question
for
the
beginning
of
the
thing.
I'll
ask
it
for
him
in
the
beginning,
in
that
one:
oh,
we
have
the
GC
and
it
ate
things
whatever
it
felt
like
it,
and
then
people
wanted
the
ability
to
control
that
I'm
saying
free
resource
right
now,
so
we
added
disposable
and
that.
B
Means
for
your
resource
right
now.
What
does
a
sink
disposable
mean
in
terms
of
an
object?
How
do
you
design
it?
How
do
you
use
it
and
do
we
even
need
it,
for
this
proposal
doesn't
reversal
a
yes,
we
need
for
the
proposal
for
the
same
reason
we
were
talking
about
before
the
meeting
started,
if
nothing
else,
if
you,
if
you
decide
to
exit
out
of
your
for
each
loop,
for
your
wake
for
each
loop,
for
example,
and
the
thing
you
were
iterating
over
had
a
using
block
or
try.
B
Finally,
we
need
to
be
able
to
clean
up
the
resources
that
were
explicitly
being
disposed
of,
for
example,
in
the
finally
block
in
your
iterator
or
abandoned
well,
I'll,
dispose
is
never
required
for
correctness,
and
if
it
is
required
for
correctness,
we
need
to
redesign
most
of.
Why
do
we
have
disposed
in
meant
to
begin
with,
to
allow
for
people
to
do
opportunistic
clean
up
the
GCS,
not.
E
J
B
C
B
Is
always
a
functional
argument
too?
If
you,
if
you
dispose,
you
has
some
resource,
that's
being
used
and
then
you
want
to
use
it
again
and
you
don't
dispose
it.
You
have
race
conditions,
you
have
functional
bugs
and
if
you
don't
dispose
it
that's
a
problem.
If
you
rely
and
the
finalize
our
guest,
your
resources
will
be
cleaned
up
eventually,
but
not
in
time
for
you
to
predictably
use
them
again.
Yeah.
B
B
G
B
N
B
The
other
thing
that's
interesting
from
these
signatures
is
they
return?
No
initial,
initially
look
at
the
interfaces.
These
were
returning
tasks
and
task
of
T
or
tasks
a
pool.
We
switched
this
in
our
minds
and
designs
around
the
time.
We
were
shipping
down
that
core
to
one
when
we
added
some
additional
support
to
value
test.
So
in
general
tasks
is
still
a
much
more
usable,
robust,
consumable
type
than
value
task.
Is
you
can
do
a
lot
more
that
you
can?
You
know
be
guarantee
that
you
can
awaited
multiple
times.
B
You
can
store
it
into
a
dictionary
and
use
it
later
without
fear
that
something
is
going
to
change
in
general
with
value
tasks.
We
recommend
that
it,
basically
you
just
directly
await
it
and,
if
you're
not
going
to
directly
await
it,
you
call
as
test
to
get
back
a
task
which
raises
the
question:
why
would
we
use
it
in
these
signatures
and
the
answer
is
a
few
fold.
B
Second
there's
a
significant
performance
advantage
that
comes
with
being
able
to
use
value
tasks
here,
and
that
is
with
task.
If
move
next
async
actually
completed
synchronously
without
the
a
synchronously,
then
we
could
have
returned
a
cash
task
for
tasks
of
true
and
task
of
false.
However,
if
it
completed
asynchronously,
we
would
always
need
to
allocate
a
new
task
that
represented
the
promise.
That's
handed
back
to
the
caller
that
could
be
eventually
completed
value
tasks
in
2.1.
B
We
added
the
ability
to
construct
it
not
only
from
a
tea
and
a
task
of
tea,
but
also
from
an
interface
an
AI
value
test
source
of
tea,
and
we
can
implement.
In
fact,
the
compiler
does
implement
the
enumerable
that
it
gives
you
get
back
from
the
iterator.
It
can
do
the
same
trick
that
it
does
today
with
synchronous
enumerables,
where
get
a
numerator
will
often
give
you
back
the
same
object
as
the
ANU
will
give
you
back
to
this,
but
it
blends
both
interfaces,
but
we
can
take
it
a
step
further
here.
B
We
can
actually
reuse
that
same
object
and
give
it
back
as
the
return
value
of
move
next
async,
because
this
is
it's
never
valid,
to
call
move
next,
async
again
on
an
object
that
already
has
a
pending
move
next
I
think
so
we
can
repeatedly
hand
back
that
same
object
for
the
lifetime
of
the
enumerate
or
from
every
move
next
async
that
yields
asynchronously,
which
means
for
the
entire,
like
this
anymore,
enumerator.
No
more.
How
many
times
move
next
async
is
called
the
number
how
many
times
it
completes
asynchronously.
D
You
already
have
the
enumerable
over
when
you
start
reaching
over
it
and
in
the
common
case,
it's
not
going
to
be
multiple
concurrent
reaches.
So
you
only
in
the
case
of
a
second
concern
for
each
would
you
allocate
a
new
one
for
the
enumerator
right,
so
the
common
case
is
zero
or
when
the
delegate
yeah
common.
B
B
So
those
are
those
sort
of
the
key
details
of
the
interfaces.
Then
there
are
a
few
other
pieces
here.
So
if
you
look
at
async
methods
today
for
a
single
oi,
async
task
facing
tasks
of
T,
async
value,
task
of
T,
etc,
the
compiler
relies
on
library
support
for
some
of
the
boilerplate
related
to
the
methods
implementation.
B
It
has
these
things
called
builders
which
it
creates
at
the
beginning
of
an
async
method.
When
you
call
when
you
call
the
method
and-
and
it
relies
on
that
builder,
to
do
things
around
managing
execution
context
around
giving
allocating
returning
the
tasks
and
so
on.
So
we
have
one
of
these
for
all
of
our
all
of
our
various
forms
of
async
methods,
while
it's
possible
and
the
compiler
that
shipping
in
preview
one
does
this
it's
possible
for
it
to
build
on
top
of
the
existing
types.
B
But
it's
a
little
bit
happy
and
we
feel
like
it's
cleaner
if
we
introduce
a
specific
builder
for
async
iterators,
which,
in
its
initial
implementation,
just
sits
on
top
of
internally
the
other
builders
we
have.
But
we
can
change
that
and
it
gives
us
the
flexibility
to
change
things
in
the
future
and
it's
a
little
bit
cleaner.
So
if
you
scroll
down
just
a
little
bit,
Nemo.
B
B
It
uses
a
weight
completely
really
unsafe
on
completed
and
the
Builder
handles
hooking
up
the
continuations
and
doing
everything
off
and
then,
when
it's
done
it
calls
completely
technically
complete,
isn't
necessary
right
now,
but
I've
added
it
in,
because
I
believe
there
will
be
things
that
we'll
want
to
do
around
being
able
to
do
some
tracing
or
each
of
W
logging
or
things.
You
know
it
if
you
neglect
to
complete
to
finish
your
enumeration
and
you
don't
dispose
of
you
know
to
anything
we
might
want
to
log
like
you
do
at
a
sub
methods.
B
Today,
that's
a
diamond
quote
to
one,
so
this
sits
in
the
pilot
services.
There's
no
reason
for
someone
to
use
this
directly.
It's
just
there
for
the
compiler
are
the
things
in
caballo
services
not
painted
as
that
a
new
browser
will
never
work.
They're
not
and
compiler
service
is
a
sort
of
a
mix
of
things
that
we
kind
of
in
general.
B
We
put
them
there
because
they're
there
for
the
compiler,
but
everyone
once
know
allows
the
things
shows
up
there
that
people
end
up
using
just
like
strongboxes
there,
and
people
have
used
for
that
in
their
own
code.
But
this
is
one
I
have
trouble.
Thinking
of
a
reason,
someone
would
want
to
use
this.
B
We
could
add
it.
I,
don't
think
it's
necessary
I
think
that
consistency
is
good.
There's
one
other
piece
that
the
compiler
relies
on.
So
there's
the
interfaces
that
you
know
generally
consumable
with.
Obviously
the
compiler
requires
them.
There's
this
iterator
method
builder
that
the
compiler
uses
as
the
boilerplate
and
there's
one
other
things.
Even
if
you
go
to
the
next
tab,
yeah.
B
So
I
mentioned
the
iterators,
implement
this
interface
I
value
tasks,
I've
a
test
source
that
lets
it
the
same
object
behind
value
pass.
There
is
a
non-trivial
amount
of
logic
associated
with
implementing
that
interface,
because,
basically,
you
have
to
be
able
to
handle
all
of
the
logic
around
race
conditions
between
someone
coming
up
and
hooking
up
an
uncompleted
and
some
in
the
operation,
completing
and
handling
execution
context
and
handling,
synchronization
context
and
so
on.
We
don't
want
to
have
to
have
the
compiler
generate
that
at
all,
never
there's
a
lot
of
policy.
B
Thank
You
Reba,
so,
in
addition,
anyone
who
wants
to
implement
this
manually
has
to
implement
similar
logic
themselves.
In
fact,
we
have
I
believe
three
different
implementations
of
this,
currently
that
we
hopefully
consolidate
in
net
core
I'm,
proposing
that
we
add
a
public
type
that
handles
all
that
for
you
and
in
fact,
that
preview,
one
of
the
compiler
uses
this
today.
It
just
requires
you
to
basically
this
little
CS
file.
You
have
to
including
your
project
that
includes
you
know
all
this
stuff,
but
eventually
in
the
library.
B
Basically,
this
type
is
a
struct
and
the
idea
is
you
put
it
on
to
whatever
object.
You
have
that
implements
the
interface,
and
then
you
delegate
this
guy
from
all
your
interface
calls,
and
that
allows
you
to
have
that
single
object.
This
handles
all
the
logic
and
you
just
delegate
to
this
for
that
interface,
implementation.
So
the
for
the
four
methods.
Sorry,
the
three
methods
on
the
bottom
get
status
get
result
on
completed.
Those
are
all
directly
related
to
the
interface
you
know,
pins,
just
don't
gates
for
those.
B
Don't
love
the
name,
it's
a
mouthful,
but
the
idea
is
of
value
task
source
because
it's
helps
in
implementing
I
value
test
source
manual
reset
because
it's
about
manually
resetting
just
like
we
have
a
manual
reset
event
and
then
logic
because
I
was
thinking.
Maybe
we'll
have
a
last
version
of
this
that
just
wraps
this
rough
version
and
it
would
be
called
manual
reset
value
task
source,
and
so
this
is
the
logic
behind
implementing
the
interface
but
I'm
totally
open
to
better
name.
Suggestions
that
I
could
come
up
with.
B
The
various
members
here
are,
should
be
relatively
self-explanatory.
Reset
reset
sit
back
to
be
used
again,
sent
results
that
exception,
complete
it
with
either
a
result.
For
an
exception,
run
continuations
asynchronously
dictates
how
the
implementation
handles
revoking
can
Asians
that
have
already
been
registered
with
the
instance
when
you
call
sent
result
or
set
exceptions.
So
if
you,
you
await
an
object,
you're,
basically
giving
it
a
callback
to
invoke,
and
then
at
some
point
later,
when
that
operation
completes,
should
the
completion,
the
cook,
the
invocation
of
set
result
or
set
exception.
B
B
H
B
B
G
B
Won't
be
this,
that's
my
hope.
There
is
the
other
alternative
that
is
Auto
reset,
rather
than
manual
reset.
I
haven't
figured
out
a
great
way
to
encapsulate
that
yet,
and
my
thinking
is
it'll
likely
be
layered.
On
top
of
this,
the
auto
comes
into
play,
so
there
are
two
scenarios
where
you
can
imagine
these
being
used.
One
is
the
scenario
that
we
have
with
I
anymore
bolt,
which
is
basically
there's
only
ever
one
consumer
at
a
time,
you're
not
worried
about
race
conditions.
B
It
can
be
using
currently
why
you
would
do
that.
I,
don't
really
know,
but
you
can't
have
any
number
of
outstanding
receives
a
sinks
all
pending
at
the
same
time,
and
so
what
we
do
is
we
basically
say
the
first
one
comes
along
gets
the
reusable
object,
anyone
else
who
comes
along
while
it's
in
use
we
allocate
for
them
and
then,
when
the
first
one
completes,
it
basically
signals
it
effectively.
B
Auto
resets
the
reusable
objects
such
that
anyone
else
who
comes
along
after
that
can
get
the
reusable
objects
so
that,
as
long
as
you
only
have
one
receive
a
sink
at
a
time,
you're
always
using
the
reusable
object.
Anyone
else
that
comes
along
while
someone
else
is
pending
gets
a
new
one
that
doesn't
exactly
work
with
manual
reset,
but
I
believe
we
can
build
it
on
top.
So.
G
I
think
this
will
be
the
workhorse
okay,
I
was
thinking.
If
this
was
the
primary
me
be
able
to
make
the
name
somewhere.
What
would
you
recommend?
I
was
just
thinking
like
you
could
draw
logic
entirely
and
if
a
clock,
if
the
class
wrapper,
is
really
like
a
wrapper,
then-
and
it's
the
uncommon
case,
then
that's
the
one
that
merits
like
extra.
B
It's
nothing
extra
soft
light
source
on.
So
let
me
clarify
my
answer.
This
will
be
the
common
case,
I
believe
for
someone
who
already
has
an
object,
that
they
want
to
reuse,
as
in
automatic
is
their
will.
There
are
cases
today
where
people
use
task
completion
source
and
in
some
of
those
cases
it's
not
sitting
on
some
other
object.
B
B
M
P
B
B
Know
yeah,
so,
ok!
So
now
we
have
the
situation
where,
in
libraries
we
encourage
developers
to
use
configure,
wait
false
because
we
want
to
have
libraries
avoid
capturing
the
current
synchronization
context,
current
task,
scheduler
and
whatnot,
but
here
you're
not
directly
awaiting
test
you're.
Doing
that
that
should
be
reverse.
We
change
the
syntax.
It
should
be
awake
for
each
so
you're
doing
a
wait
for
each
key
item
and
source
you're
not
explicitly
awaiting
any
task.
B
O
H
So
I
noticed
that
this
takes
a
a
bull
called
something
complicated
that
no
one
understands
and
having
last
night
read
the
section
of
framework
design
guidelines
that
talked
about
boolean
parameters.
I
have
to
recommend
that
we
added
a
to
value
e
to
variation
for
this
and
then
change
the
existing
API.
To
also
take
one.
R
R
It
would
be
so
the
thing
that
would
let's
say
there
is
never
solution.
We
never
solved
this
problem.
Sure
we
just
keep
going.
It
would
be
kind
of
unfortunate
if
we
use
configure
wait,
falls
here,
there's
an
extension
method
and
the
next
iteration
came
up
with
a
solution
that
actually
addresses
the
problem
in
a
nice
way,
because
we
would
kind
of
now
have
legacy
in
both
places.
So.
D
R
A
But,
like
my
argument
is
different,
I
mean
did
this,
there
is
two
sides
to
this.
What
does
you
code
look
like
and
what
does
offender
look
like
right,
better
worst-affected
everybody
has
configure
away,
and
the
vast
majority
of
people
writing
a
synchronous
code
today,
don't
use
it
and
then
there's
the
other
population
that
uses
it
aggressively
and
their
code
base
is
just
suck
right
good,
but
I
think
the
question
is
so.
A
If
we
do
this
here,
so
we
add
like
what
one
method
and
effectively
one
stock
type
in
compiler
services,
which
realistically
nobody
actually
cares
about,
so
if
we
actually
solve
it
holistically,
I
would
also
I
give
you
have
to
solve
it
for
both
IA
sync
blah
plus
the
plus
the
normal
task
situation.
That's.
R
P
O
B
B
B
Implements
I
think
innumerable
by
a
sink
or
a
lead
to
a
source
and
whatever
else
and
it's
I,
async
Annamarie
tour,
yet
basic
enumerator
method
with
some
synchronization
those
right
but
like
my
source,
is
not
going
to
be
class.
Compiler
right.
My
class
is
going
to
be
like
database
database
where
your
method
is
going
to
be
I
most
likely
going
to
be.
I
async
a
memorable
food.
P
H
B
O
B
And
it's
even
more
for
the
async
version
that
you're
having
to
deal
with
you
know
async,
continuations
and
the
like.
So
I
doubt
we'll
see
you
know.
Maybe
five
percent
will
be
for
manually
imported
one
percent,
but
I
think
the
vast
majority
of
implementations
will
either
be
ones
that
we
provide
or
that
system
dot
rx
that
link
or
system
attracted
that
we
provide,
which
were
mostly
be
important,
that
I
expect
using
this
or
ones
in
the
wild
that
are
implanted
using
the
compiler.
B
G
B
N
B
The
key
here
is
that
when
the
compiler
binds
to
this
by
pattern-
and
it
ends
up
learning
the
code
that
doesn't
wait,
move
next
async,
it's
actually
awaiting
a
configured
value
task
away,
double
which
does
the
relevant
thing
regarding
the
configure
weight.
But
if,
if
you
actually
used
the
interface,
if
you
like,
did
not
configure
weight,
dot,
select
async,
something
that
took
the
interface,
that
interface
call
would
be
going
to
the
thing
that
just
returns
value
tasks,
source
our
value
tasks,
not
a
configured
value
task,
and
so
it
won't.
S
B
Weight
problem
inside
someone's
awaiting
and
yielding
code
are
they
waiting,
configure
Li
false
everything
they
do
or
does
this
wrap
that
and
they
don't
need
to
do
that,
are
waiting
configure
it.
The
weight
code
that
they
write
inside
their
iterator
is
just
like
a
weight
code.
They
write
anyone
else.
I
found
that
configuring
the
waiting,
if
they're
in
a
library
and
if
they're,
in
a
contact,
if
they're
in
a
generic
library
they
can
be
used
anywhere
or
oh
yeah.
It's
not
a
generic
library
that
can
used
anywhere
they're
using
configure
awake
false
everywhere.
B
Okay,
let's
keep
going
through
the
next
one.
I
want
to
talk
about,
highlight
some
of
the
issues
that
I
pay
so
I've
implemented
all
of
this
in
two
pr's,
one
in
core
CLR
and
core
FX.
For
the
most
part,
it
went
very
seamlessly
with
one
exception,
and
that
is
there's
some
real
weirdness
around
async
disposable.
So
let's
go
to
that
last
tab.
B
Yeah,
so
I
went
through
the
VCL
and
looked
at
everything
we
have
that
influenced
by
disposable
and
the
vast
number
of
places
we
implement
by
disposable
there's
no
value
in
adding
an
is-8
disposable,
because
the
work
is
closing,
handles
and
other
things
where
there's
no
async
work
being
done.
There
were
basically
five
places
that
I
found
some
which
were
abstract
classes,
so
there's
more
building
on
top
of
that,
but
basically
five
types
that
I
found
where
this
is
relevant.
You
can
scroll
down.
B
So
it's
these
five
I'll
start
at
the
bottom
and
work
out
because
that's
easier,
so
cancellation,
token
registration,
but
there's
no
problems
here.
Basically,
cancellation,
token
registration,
that's
given
back
to
when
you
call
cancellation,
token
dot
register
and
the
idea
is
you
have
a
callback
that'll
be
invoked
when
cancellation
occurs
and
we
are
done
with
your
operation.
B
B
B
B
So
if
you
don't
override
dispose
async,
if
you
have
you
know,
if
you,
you
start
running
on
a
new
version
of
the
runtime
that
has
this
and
new
compiler,
but
you
haven't
gotten
around
yet
to
adding
expose
async
override
when
someone
uses
dispose,
they
saying
it'll
quote
quote:
do
the
right
thing
and
only
both
the
dispose
method.
It
may
just
be
slightly
more
expensive
than
you
would
otherwise
like,
because
we're
queuing
a
work
item
to
call
your
existing
dispose.
B
There's
the
alternative,
which
is
we
just
had
it.
Synchronously
call
dispose,
but
that
could
be
very
confusing
for
the
caller
and
then
we
go
and
override
this
on
all
of
our
streams
throughout
core
effects
and
asp
net,
where
it's
relevant
so,
for
example,
memories
stream,
where
it
is
fine
to
call
the
supposed
synchronously
just
does
so
file
stream,
where
it's
disposed
currently
does
synchronous
flushes.
Even
if
it's
under
open
the
underlying
file
for
overlap
diode,
we
now
use
flush
async
instead
of
flush,
and
so
a
wrapping
stream
like
deflate
stream
or
gzipstream.
B
They
end
up
call
dispose
they
sink
on
their
underlying
stream,
rather
than
calling
me
dispose
on
the
underlying
stream,
and
so
the
main
difficulty
here
has
to
do
with
how
you
deal
with
a
base
class.
Let's
say,
you've
got
your
driving
from
stream
and
you
don't
know
what
the
base
streams
implementation
does
well
with
dispose.
Today,
the
assumption
is
every
level
of
the
class
hierarchy
may
have
some
resources
that
need
to
be
disposed
than
need
to
post.
B
So
if
you're,
a
and
you're
driving
from
be
in
your
dispose
method,
you
release
your
resources
and
then
you
call
B
not
disposed
to
release
its
resources,
but
you
do
that
here,
you're,
a
deriving
from
stream.
You
do
your
releases
and
your
dispose
a
sink.
You
will
wait.
Stream
done,
dispose
they
sink,
which
in
turn
use
a
work
item
to
call
dispose.
So
now,
you're
disposing
yourself
twice,
which
in
theory
should
be
fine.
B
It
should
be
either
potent
what
you're
doing
it's
weird
you're,
calling
yourself
twice
when
you
meant
to
apply
yourself
only
once
so,
you
could
say
all
right.
Well,
if
I'm
driving
from
stream
I
know
that
I
know
it's
based.
Behavior,
so
I'm
not
gonna,
call
based
off
this
books,
but
then
what
if
I'm
Class
D
deriving
from
a
driver
from
stream
now
Class
D
needs
to
know
whether
or
not
it
should
call
its
base,
and
presumably
it
does,
but
maybe
not
so.
B
M
B
At
which
point,
if
memory
streams
dispose
a
sink,
was
implemented
as
a
Noah,
it
wouldn't
be
calling
the
Levi's
important
dispose.
So
memory
streams
dispose
a
sink
needs
to
do.
He
needs
to
say
if
I,
if
this
get
type
equals
type
of
memory
stream,
no
one
else,
delegate
to
the
base
of
that
task
of
running
books
disposed
on
Levi's
only
by
his
memory
stream
done
dispose.
But
now,
if
you
derive
from
memory
stream,
you
have
to
do
the
same
thing.
You.
B
K
D
C
D
B
B
B
O
B
G
B
So
they
won't
be
able
to
put
their
stream
in
an
using
block
yeah.
Nor
are
we
using
block.
So
that's
one
of
the
options
is
number
two:
don't
implement
the
interface
on
the
stream
but
implemented
on,
derive
types,
and
let
people
do
opportunistic
casting
where
they
have
a
strong
type
reference
yeah
is.
D
B
D
Misunderstood
no,
no,
so
so,
essentially,
a
direct
derived
class
from
stream.
That's
called
basic
stream,
and
that
adds
support
for
that
adds
the
I
using
disposables
idle
abstract
as
an
abstract,
and
then
we
implement
it
on
we.
You
know
we
take
everything
where
it
makes
sense
and
shove
it
under
there
right,
implement
it
and
everything
else
stays
the
same.
It
stays
in
the
synchronous
world.
It
doesn't
try
to
pretend.
F
D
R
H
A
A
Sorry,
so
imagine
you
have
like
the
same.
If
can
can
read
where
it
can
rain
can
seek
you
just
sick
in
this,
pose
they
sink
and
then
returns
false
by
default,
so
it
blows
up
if
you
call
it,
and
so
when
you're
wrapping
a
stream,
you
ask
whether
it
supports
it.
If
it,
then
you
call
otherwise
you
don't
the.
B
B
O
B
Theory,
yes,
unfortunately,
there
are
cases
where
I
believe
deflate
stream
is
one
of
these,
where
flush
doesn't
fully
flush
because
it
doesn't
I,
forget
the
details,
but
something
like
flush.
A
sink
doesn't
really
flush
because
there's
state
leftover
as
part
of
the
compression
and
a
doesn't
like
you
need
a
trailer
yeah.
C
P
R
O
B
B
B
B
H
B
Say
you
know
a
wait,
flush
final
yeah
that
the
turning
task
completed,
because
presumably
once
you've
done
a
flush
final
like
this
hose,
should
just
be
closing
a
handle
or
without
a
decent,
Chris
right.
It
is
weird
of
if
we're
introducing
a
middle
state,
we're
flush,
finals,
public
API
and
can
be
I
guess
it
could
be
protected
and
then
that
solves
a
problem
if
flush
final
got
called.
If
we
say
that's
invalid
now,
like
are
we
introducing
an
object,
disposed
exception
with
no
one
culprit,
sensors.
B
B
C
B
C
H
B
N
B
B
B
I
create
a
new
Steve
school
stream.
Yeah
drive
some
streams
and
I
want
to
implement
everything
correctly.
So
I
override
everything
yeah
when
I
override
dispose
I,
don't
use
flush
final
async
I
just
do
whatever
I
want
in
my
dispose,
maybe
I
call
flush,
but
I
don't
call
flush
final,
you
think
am
I
disposed.
They
think
I,
don't
over
I
just
was
I.
Think
this
it's
non-virtual
I
over
I'd
flush,
finally
sink
to
either
just
do
a
flush,
a
sink
or
do
whatever
else.
You
need
to
do
such
that
when
dispose
is
called.
Yes,.
B
Final
sink
back
of
them
to
distinguish
them
would
be
based
on
dispose,
but
you've
already
freed
your
resources
before
you
called
it.
So
you're
you're
now
dead.
Well,
no
I
mean
we
would
say
that
flush
final,
a
sink
would
need
to
row
is
a
flush
final.
A
sink
we'd
have
a
clear
pattern
on,
but
if
we're
trying
to
also
make
flush
final
for
synchronous
code,
I
know
we
wouldn't
have
a
flush
final.
Okay,
yes
yeah.
Okay,
talking
about
adding
sorry.
B
O
O
G
It
comes
to
whether
we
allow
extension
methods
to
we
don't
allow
extension
methods
anywhere
for
pattern,
lookup
for
the
innumerable
or
dispose
powder
folks,
we
do
for
a
little
way,
so
we
do
for
tasks
and
won't
we
do
for
task
alights.
Oh,
we
don't
do
or
don't
do
that
for
4h
or
iterator
I.
Think
the
only
conclusion
that
we
got
to
before
in
ldm
was,
if
we
do
this
we'd
like
to
do
it
all
at
once.
Yeah.
D
R
D
Don't
you
get
started
afterwards
right,
so
we
would
have
to
like
put
it
at
the
at
the
way
end
yeah,
which
is,
which
means
it's
not
just
a
method.
Lookup.
We
do
an
instance
method
lookup,
then
we
do
other
things
and
then
we
do
the
extension
method,
okay,
which
we
can
totally
do
and
I
think
that's
probably
what
we're
going
to
end,
but
it
it's
just
a
little
more
complicated
and
then
just
finding
the
method
and
saying
I'll
think
over
that
yeah.
G
And
we
have
to
decide
like
for
using
current
using
disposed,
it's
just
its
interface
first,
so
are
we
gonna
do
but
forget
a
new
murder,
its
pattern
first.
Well,
it's
like
this
is
a
new
type.
Do
we
do
pattern
first
and
say
to
hell
with
the
previous
position,
or
do
we
do
interface
first
for
consistency,
I
think?
Actually,
if
you're
using
its
interface,
only
its
interface
only,
which
means
that
if
we
changed
it,
it
would
still
it
wouldn't
necessarily
be
interface
first
and
wait.
There's
no
there's!
No
time
ago,
there's
no
pattern
see
pretty
easy.
A
G
D
And
practice,
that's
just
gonna,
be
one
or
two
things
that
work
out
and
the
two
things
do
the
same
thing
anyway
under
the
bush
so
yeah,
but
I
think
that
that
the
extension
methods
is
where
that
falls
apart.
Because
if
you
put
an
async
or
if
you
put
a
dispose
on
an
as
an
extension
method,
then
it
will.
G
D
D
G
D
B
R
Reed
I
say:
if
you
call
Reed
I,
think
and
you
don't
put
away
the
keyword,
the
compiler
spins
at
you
here.
If
I
remember
correctly,
you
Ron,
you
write
a
for
each
loop
and
you
don't
have
a
way
to
select
correct
which
one
you
do
you
put
a
weight
before
the
forage
so
that
it
sticks
it's
like
a
weight
for
each
versus
for
each
yes,
so
you
say
you
have
a
way
to
select
by.
R
Be
an
opportunity
for
the
compiler
to
tell
me
basically,
if
I,
already
implement
for
each
and
I
have
now
a
thing
for
each
method:
I
write
for
loop
and
it
just
works
except
it's
not
efficient
in
the
compiler.
Doesn't
let
me
know
you
mean
if
you
have
I,
don't
see
if
you
have
something
that
implements
both
ienumerable
and
if
you
use
for
each
it
will
use
the
synchronous
I.
Don't.
Q
B
M
G
A
G
R
Ranking
award
that
using
what
you
could
look
at
impossible
to
for
the
compiler
to
detect
if
we
are
inside
an
async
method,
either
automatically
select
the
async
dispose
or
anything
for
each
I
can
imagine
it
being
a
warning
if
the
compiler
could,
if
the
compiler
using
requires.
If
the
compiler
statically
sees
what
it
is
supported.
So
you
could
imagine
if
you're
inside
an
async
method,
and
you
had
a
using.
G
S
D
D
R
B
F
D
Be
using
it
yeah,
so
so
it's
not
so
much
that
it's
a
breaking
change
in
the
language
we
can
could
we're
now
adding
warning
waves.
We
could
just
added
asset
and
warning
that
only
comes
on
when
you
ask
for
it,
but
it's
that
you
can
break
your
consumers
by
adding
a
better
option
and
compiler
would
offer
would
twist
around
trying
to
use
that
trigger
what
I
mean.
D
L
B
A
I
A
B
A
To
begin
with,
so
why
would
they
ever
call
it
synchronous
disposed
so
I
think
if
your
type
is
realistically
only
be
usable
in
an
async
context,
I
think
it's
fine
to
only
implemented.
We
don't
use
I
a
single
syllable
in
Sigma
R,
but
we
have
the
connection.
Object,
has
a
dispose
a
single
today
you're
supposed
to
try.
Finally,
oh
go
away,
the
idea
being
will
ramp
up
when
we
don't.
Yes,
we.
R
I
R
I
R
B
D
B
To
not
implement
I
dispose
of
look
you're.
Also,
blending
icing
just
a
crimp
under
grants
and
disposable.
Are
there
any
other
things
that
people
have
seen
thus
far,
that
make
them
say?
Oh
and
I'm,
assuming
we'd,
have
a
flush
final
async,
not
only
on
screen
but
also
on,
for
example,
text
writer
never
be
the
same
again.
So
I've
got
a
question
yeah.
How
do
you
think
it
relates
to
the
pipelines,
so
pipelines
have
kind
of
modeled?
That
is
a
bit
similar
to
this
one.
R
R
R
M
R
B
B
R
C
M
G
M
B
M
G
B
U
B
S
B
Make
that
a
really
good
implementation
and
that's
sort
of
the
reference
the
interfaces
are
in
dotnet
and
they
provide
that
library
provides
indentation.
We
don't
need
to
also
provide
the
implementation
and
dotnet
itself,
wife
Camille.
It
doesn't
matter
where
the
library
comes
from.
It
comes
from
IX.
That's
great
part
of
the
reason,
for
that
is
a
there's
already
an
implementation.
B
There
be
the
explosion
that
you
get
in
the
number
of
methods,
100,
link
methods,
200
overloads,
and
that's
only
when
you
have
ienumerable
to
ienumerable,
nevermind
I
think
innumerable
that
is
I
can
immobilize
I
can
agree
with
innumerable
line
in
mobilizing
there.
We
go
methods
that
take
multiple
the
new
more
goals
as
input
in
the
combination.
The
explosion
is
ghastly.
B
B
B
Don't
didn't
completely
understand
the
first
part
of
the
question,
but
the
second
part
of
your
question
Julian
raised
the
idea
of
how
an
extension
method
on
ienumerable
as
a
sink
enumerable
I,
don't
know
if
the
open
Edition
for
it
or
not,
but
because
then
you
wouldn't
be
a
sink
to
sink
and
they
sink
to
a
sink
and
explosion.
You
think
everything's
a
sink
and
then
things
would
just
fall
in
so
that
guests
have
extra
question
I
actually
had
to
go
back
to.
We
can
revisit
that
to
go
back
to
the
woman's
config.
Nearly.
K
U
Q
B
B
B
B
Y
D
R
R
S
Q
P
M
M
B
Q
B
B
B
D
Language,
syntax
for
query.
Expressions
translates
into
calling
link
methods
with
lambdas
synchronous
language,
so
an
async
lambda
has
a
different
syntax
in
t-shirt
and
well
either.
The
compiler
needs
to
be
smarter
than
probably
wanted
to,
or
they
need
to
be
some
using
some
syntax
indication
that
you
wanted
to
have
not
just
a
stream
but
also
the
carburetor
applied
to
a
be
asynchronous.
H
H
P
D
B
Was
on
the
head
a
massive
performance
bug
because
it
generated
they
go
download
the
entire
database
and
then
run
a
lot
of
lambda
against
the
return
results
that
have
send
the
Select
into
sequel
and
then,
when
they
fix
the
bug
they
still
stuck
with
query
syntax
and
I
just
hold
my
eyes
they're.
Just
like.
Oh,
if
we
put
these
two
things
now,
it
completely
changes
the
performance
of
this.
It's
like
yeah.
D
B
B
Think
about
it,
if
you
don't
have
a
bunch
of
methods
in
dotnet
that,
except
an
eye,
a
symphony
horrible
in
the
core
libraries,
if
you
don't
have
a
bunch
of
things
that
except
I,
think
innumerable
then,
and
in
particular
things
that
accept
combinations
of
multiple
eyes
that
you
know
those,
then
maybe
it's
not
as
relevant,
you're
arguing
people.
You
know
if
you're,
using
either
library
that
would
benefit
it.
That
library
also
provides
the
maybe
many
of
the
how
many
of
the
link
methods
actually
take
more
than
one
I
normal.
B
B
Life
sink
innumerable
and
is
the
lambda
that
you
give
it
synchronous
or
asynchronous
for
the
processing
of
each
element.
That's
for
the
main
explosion,
so
looking
at
IX,
it
doesn't
look
like
they
have
to
take
both
I,
have
it
to
a
sink
in
your
mobile
extension
so
that
that's
acing
yeah.
So
that's
the
one
we're
just
talking
so
there's
no.
A
B
Our
net
core
app
does
that
now
become
an
implicit
dependency
for
anybody
else.
Who
would
want
to
do
a
similar
type
of
problem,
or
are
we
recommending
than
everybody
copy
and
paste
the
same
explore
that
conversion
is
trivial?
That's
a
four
in
a
wait
for
each
loop.
That's
sorry!
That's
a
for
each
loop
inside
async
I,
a
new
async
icing
canoe
verbal
of
T
as
a.
B
B
In
the
interface
is
actually
trivial
move
next
async
would
do
return
new
value
tasks,
move
next
and
currently
call
card.
So
that's
that
it
really
is
commercial,
I'm,
gonna
get
just
and
then
there's
the
this
library
provides.
That
extension
in
this
library
provides
that
extension.
Now
you
have
the
go
resolve
your
extension
methods
problem.
So
it's!
This
is
a.
Is
this
core
enough
that
we
would
put
the
extension
in
the
VCL,
even
if
we
make
no
use
of
it
just
because
it's
just
setting
things
up
for
extension,
collision
feels
like
maybe
but.
B
I
A
Question
generally
is
like
for
the
extension
of
the,
for
example.
Do
we
need
to
ship
this
guy?
Can
we
just
stay?
Configured?
Wait
also
goes
to
IX,
because
then
we
can
just
say
we
should
believe
the
abstractions
and
then
the
implementation
is
this
one's
different,
so
that
extension
method
other
one
we're
talking
about
it's
beneficial.
When
you
have
methods
that
accept
and
I
think
innumerable.
C
B
This
is
about
assuming
arbitrary,
a
signals
from
anywhere
and
doing
it
in
a
library
safe
way.
So
any
library,
that's
for
teaching
over
an
async
enumerable,
should
be
using
this
yeah
that
one
needs
to
you
know
the
sneak.
This
needs
to
live
in
court
I
believe
so,
where
does
the
current
wonder
figure
the
way?
That's
a
instance.
B
H
F
D
D
G
G
B
H
B
Your
async
enumerable,
you
were
imagine
you're
doing
like
a
where
async
and
in
there
you
were
awaiting
each
item
and
only
1%
of
them.
You
end
up
yielding
right.
How
did
your
where,
if
you
were
doing
that
on
the
UI
thread,
every
a
weight
is
gonna,
go
back
to
the
UI
thread
yeah?
But
then,
if
you
expect
beyond
you,
if
you
then
update
the
UI
after
the
last
one,
you
need
to
be
on
the
you
or
the
1%
yeah
come
back.
B
99%
of
them
up
in
that,
where
example
aren't
don't
worry
to
me,
those
are
99%
your
posts
back
the
UI
or
happening
unnecessarily.
That
said
link
is
an
interesting
question
in
general,
anytime,
you
have
your
a
library
the
week,
so
the
guidance
is
your
library.
You
use
a
configure,
wait,
you're,
not
you
don't,
but
there's
a
weird
part
of
the
library,
one,
your
library
and
you
accepted
elegant.
B
What
do
you
do?
Because
where
does
that
delegate
expect
to
be
called
so
one
thing:
we
have
a
signal
art
because
you
can
register
callbacks.
We
don't
run
the
money
the
same
context
today
we
run
them
on
thread,
pool
where
we
are,
and
we've
always
done.
That
and
most
users
are
familiar
with
the
idea
that
they
need
to.
M
We
could
have
some
run
right
away,
just
jump
into
the
thread
right
away,
because
it's
a
likelihood
to
hear
plumbing
UI
thread.
We
don't
want
to
be
doing
our
stuff
on
you
right
away,
probably
as
an
analyzer
that
requires
you
to
set
it
for
everything,
yeah,
something
like
detach
I,
don't
know
you
the
detached
from
one
and
that's
probably,
research.
M
E
B
Something
different:
if
people
come
up
with
a
good
suggestion:
I
just
don't
have
one
I,
wouldn't
do
it
any
differently.
I
would
when,
if
we
do
this
I
would
I
would
do
the
new
overload
is
in
the
ocean
of
for
both
of
them,
and
then
you
can
do
you
see
the
Moreland
in
the
l1?
It's
just
gone.
Why
would
we.
A
B
B
B
B
B
You
just
like
today,
you
call
a
method
and
accepts
the
cancellation
token.
You
write
an
async
iterator
when
your
argument
is
a
cancellation.
Towe
could
use
that
cancellation
to
okay,
their
body,
and
so
on
that,
for
the
most
part
that
works
really
well
and
one
of
the
reasons
that
drove
us
there
is
well
there's
sort
of
two
main
reasons
that
drove
us
to
that
point.
B
One
is
in
general,
why
would
you
pass
a
different
cancellation
token
to
every
call
to
move
next,
async
you're
doing
logically,
a
single
large
operation
with
many
sub
components,
it's
difficult
to
think
of
a
scenarios
where
you
would
want
different
cancellation
per
call
to
move
next,
they
say
I'm
sure
you
can
come
up
with
some.
It
would
be
very
rare.
The
second
issue
is
you
write
an
async
iterator
and
you're
consuming
it
generally
with
for
each
async.
B
How
do
you
get
a
cancellation
token
from
the
four
eaching
into
the
body
of
the
async
iterator?
You
could
solve
the
the
form
the
for
each
problem
in
two
ways
you
could
either
just
not
use
for
each
and
just
manually
use
the
next
a
sink,
or
you
could
have
an
extension
method
similar
to
configure
wait
on
the
source
enumerable
whose
and
that
configure
wait
or
that
whatever
next
with
cancellation
method
accepts
the
cancellation,
token
and
sort
of
funnels
it
through
to
the
move.
B
B
Think
at
this
model,
I
see
you're
doing
yield
while
applied,
yield,
blah
blah
blah.
Oh
wait,
blah
blah
blah
whatever
await,
and
that
means
that,
after
after
each
of
these
meals
there's
a
move,
next
async
call
that's
reentering
the
state
machine,
potentially
with
a
different
cancellation
token.
What
does
that
mean
for
the
person
writing
this
code?
And
how
does
the
code
in
here
even
get
access
to
that
cancellation?
Okay,
so
we
talked
through
various
things
we
could
do
in
the
language
like
having
some
sort
of
ambient.
B
Seemed
wonderful,
and
so
the
combination
of
all
of
that
led
us
to
say
well,
the
least
evil
thing
would
be
just
to
pass
it
here
and
that
matches
really
nicely
with
existing
methods.
Use
this
here
place
it
potentially
breaks
down
is
if
you
did
have
something
like
if
you
do
have
something
like
a
link
and
you
didn't
want
to
have
to
pass
the
cancellation
token
into
the
source
of
music.
B
When
you,
like,
you
know,
database
called
dot,
select,
dot,
we're
done
food,
you
past
the
cancellation
token
into
database
call
and
it
sort
of
logically
false
floats
through
it.
But
if
you
didn't
do
that,
database
called
that's
left
out.
Where
does
food,
and
then
you
wanted
to
44
the
cancellation
token
you're
planning
out
a
lot
right,
so
I
mean
this
dude
I
mean
the
other
question
know
what
happens
like
what?
What
kind
of
times
would
we
expect
to
implement
I
I?
Think
in
the
mobile
right,
because
logically,
icing.
A
Enumeration
kind
of
implies,
there's
communication
to
some
extrinsic,
so
otherwise,
why
would
you
make
it
a
singer
to
begin
with,
so
I
can
like
the
typical
thing
where
you
have
a
collection
doesn't
make
much
sense
in
my
opinion,
so
usually
I
would
expect
something
like
I
don't
know
like
the
github
client,
they
would
have
a
pull
request.
Collection,
that
is,
is
a
new
mobile,
but
you
could
also
just
immediately
expect
those
to
be
not
just
collections.
Just
you
just
make
the
methods
and
they're
just
churn
is
you
know,
I
think
that
was
the
point
earlier.
A
A
R
B
R
R
R
It's
already
created
for
you,
I
was
thinking
that
this
creates
an
icy
collection,
but
in
the
you,
when
you
in
the
implementation
is
them
the
biggest
argument,
I've
seen
against
this
and
I,
don't
necessarily
buy
it,
but
I
understand
it.
My
argument
for
this
is
99.9%
of
the
case
when
you
get
into
numeral
today,
you.
B
Enumerate
it
once
right
right,
it's
it's
one,
expressions
I'm
for
reaching
over
get
me
an
enumerable
there,
and
in
that
model
this
is
totally
fine.
Well,
the
the
iterator
the
yield
return
state
machine
is
not
restartable
right.
It's
only
able
to
be
trained
once
ever
well
what
you
can
do
it
for
the
enumerate
tour
yeah
for
me,
but
the
thing
is:
that
is
what
I'm
saying
the
innumerable
you
can
get
as
many
enumerators
from
it
as
you
want.
B
H
B
A
D
Materialized,
so
for
those
it's
fine
to
like
go
over
again
and
again,
except
if
you
mutate
them,
then
it
isn't,
and
then
you
blow
up
in
weird
ways
for
asynchronous
iteration
that
doesn't
really
seem
I
mean
the
is
they
sing
for
reason?
It's
a
thing
because
you're
waiting
for
it
to
materialize,
they're
not
already
materialized
things,
then
why
do
we
even
have
this
is
think
in
the
movie?
Why
not
have
just
a
numerator,
yes
and
reaching
over
the
numerator?
R
D
F
I
I
I
Z
I
G
I
I
B
They
come
back
to
it
later
and
they
grab
that
object
and
for
this
operation
they
then
do
dot
where
dot
select
whatever
and
they
in
iterate
that
one
and
then
they
come
back
to
that
same
cache
thing
later
and
they
do
not
select
the
kind
of
application.
If
you
are
talking
about
the
web
application,
that
probably
won't
happen
because,
in
a
request
to
probably
just
construct
the
query
and
execute
it
right,
but
in
a.
I
Long-Living
context,
you
can
probably
store
the
query,
keep
it
somewhere
and
then
execute
again.
I
mean
it's
not
I,
don't
think
that
is
super
common
right.
That
is
probably
with
more
than
one
or
two
per
side.
Well,
the
question
I
mean
naked
yeah
I
mean
I'm,
proposing
to
removing
it
right.
The
question
is
to
shoot
me
also
exposed
from
my
could.
A
I
A
This
in
with
this
API
will
be
actually
killed
scenarios
with
that
because
it's
like
it
seems
like
what
you
could
store
it,
but
you
could
also
just
ask
for
it
again.
Well,
I
was
doing
things
that
I
did.
The
reason
that
we
bring
this
up
is
because
it
impacts
the
cancellation
story,
so
yeah
you
could
imagine
so
EF
has.
B
I
I
B
Into
this,
because
it's
building
up
this
huge,
basically
database
processor,
at
which
point
it
could
have
an
implemented
cancellation
that
took
an
interval
and
returned
enumerable
and
that
added
the
cancellation
token
into
whatever
that
stateful
knowledge.
We
that's
a
language
flow,
the
cancellation,
token
into
objects,
at
which
point
that
allows
you
to
you.
L
B
Let's
ignore
the
cancellation
if
I
were
to
call
a
new
Murry,
something
async
and
I'm
holding
on
this
object
that
enumerate
it
twice
gives
different
results
because
well
it
did
a
second
network
query
and
it
got
different
answers.
This
I
mean
it's
a
thank
you
I
mean
I,
know,
I,
know
it's
possible
with
everything
right
now,
and
this
just
goes
back
to
the
normal
leg.
The
first
thing
that
you
do
when
you
do
this,
if
you
need
consistent
state,
is
you
drain
it
into
a
list?
Yeah
the
expectation
no
marbles
today.
H
B
Again,
and
and
yes,
the
answer
is
you
drain
into
a
list,
but
it's
it's
still
very
yeah
you're
a
bad
person,
that's
not
the
worth.
No
I
mean
it's
the
same.
It's
the
same
concept
and
it
shows
up
even
in
court.
Libraries
file,
dot,
Li,
blinds
async
gives
you
back
in
the
normal.
You
can
enumerate
that
enumerable
at
any
number
of
times,
and
every
time
you
do
and
it's
based
on
the
current
state
of
the
system,
does
it
reopen
the
file
every
sooner
than
me.
There
yeah
I
mean
the
only
case
where
I
wanted.
A
Is
basically
producing
a
bunch
of
my
quota
me
iterators,
which
is
very
similar
to
enumerators
and
so
I
have
to
create
this
career
plan
like
the
debate
starts
with
reading
the
table
applying
a
predicate
joining,
and
so
the
the
construction
of
this
plan
is
moderately
expensive
right
because
they,
after
they
do
some
optimizations,
and
so
once
you
have
to
plan,
you
would
really
like
to
cash
the
plan
and
then
just
next
time.
Somebody
wants
to
get
the
rolls.
A
You
just
be
rerun
this
right,
but
because
my
dividers
are
holding
on
to
the
state
they
effectively
dead
after
you
did
this,
you
have
to
redo
the
translation.
So
if
the
construction
of
the
query,
like
the
construction
of
the
I
new
hook
themselves,
is
expensive,
I
could
see
an
argument
for
you
know
you
really
wanted
as
the
unit
of
composition,
because
then
you
can
just
yep.
The
translation
from
the
item
will
go
to
the
I.
A
Knew
more
tour
is
pretty
straightforward,
so
this
is,
you
know
you
just
allocate
any
resources
for
the
new
query,
but
you
don't
have
to
come
up
with
the
new
but
the
Nutri
of
like
what
you
put
equal
to
agree.
But
that
means
that
the
is
ink
and
wearable
that
get
async
enumerators
for
the
cancellation
token
should
go
well,
not
necessarily
it
means
you
have.
You
can
also
have
it
quite
a
job
and.
Q
R
D
B
Could
add
a
keyword
for
the
if
we
wanted
to
pass
a
cancellation
token
in
to
get
a
synchro
numerator
there
could
be
the
this
is
the
cancellation
token.
They
can
always
think
that
was
the
idea
about.
You
have
a
keyword
here
that
represents
sort
of
a
state
that
was
passing
together,
but
even
that
was
weird,
because
the
idea
that
the
cancellation
told
me
to
change.
Let's
say
in
here
you
you
enumerated
something
else.
Let's
say
you
did
for
each
something.
B
B
So
when
get
a
sickening
writer
started,
you
got
past
your
cancellation
token
you're
using
it
for
your
entire
run.
It
doesn't
change
like
so
it's
not
and
move
next.
That's
in
get
a
numerator.
It's
my
that's
your!
So
so
you
work.
You
have
a
consistent
token
for
your
home
run!
Yeah!
You
pass
that
token
into
something
else.
It
has
it
for
its
whole
run
you're
all
of
one
token,
but
a
second
call
to
get
a
numerator
might.
B
H
D
B
D
P
B
That,
and
that
seems
like
well
there's
a
there's,
a
pattern
here,
we're
helping
you
with
the
pattern
we're
doing
the
right
thing
this
is
you
probably
want
to
support
cancellation
tokens?
We
don't
know
which
way
you
wanted
to
do
them,
and
life
is
hard,
so
go
write,
a
million
lines
of
code
and
you're,
probably
gonna,
get
it
wrong.
That's
really
what
this
feels
like
to
me
now
that
we're
saying
the
word
cancellation
token
now.
B
A
A
X
D
If
we
were
to
do
something
in
the
in
the
language,
it
wouldn't
be
cancellation,
token
specific
that
will
be
along
the
lines
of
what
Steve
said.
There'll
be
some
way
that
there
could
be
some
context
that
was
ambiently
available
and
it
would
just
happen.
You
just
happened
to
define
things
so
that
I
can
sleep
token
would
be
there.
So
I
guess
the
other
thing
that
would
do
it
would
be
Christophe
suggestion
of
async
for
each.
B
R
D
B
B
B
D
R
F
M
B
B
But,
but
it
feels
like
this
is
solvable
with
the
one
like
making
a
numerate
or
be
more
of
a
pattern
of
this
is
a
one-shot
call,
calling
it
a
second
time
will
is
different
right
is
this
is
a
this?
Is
this
problem
of
not
being
able
to?
You
are
probably
aware
not
being
able
to
and
no
matter
it
enumerators,
it's
kind
of
like
it
comes
up.
R
From
time
to
time,
because
you
want
to
have
one
collection
and
then
you
know
two
different
ways
to
in
a
very
good,
you
want,
you
know
forward
and
backwards.
But
let's
say
it
would
be
nice,
it
getenumerator
took
a
boolean,
parameter
it
backwards,
and
then
I
can
just
for
each
today.
I
can
add
for
each
other,
it
risk
if
you
like
that,
if
you
tweeze,
for,
if
you
take
the,
if
you
take
the
enumerator
store
in
variable
for
each
it,
and
then
I
call
things.
M
R
M
I
R
G
G
G
G
A
We
had
there
there's
a
thing.
Some
work
I
mean
the
the
other
thing
we
talked
about
was
to
configure
white
stuff,
which
we
basically
said.
We
will
have
an
extension
method
that
does
that
to
be
consistent
with
what
we
have
and
I
think.
The
major
program
that
seems
to
be
left
is
like
figuring
out
where
they'll
be
happy
with
the
cancellation
or
less
is
proposed
here,
whether
we
need
something
different
which
no
made
actually
or
might
actually
change
the
shape
of
the
interfaces.
B
R
A
B
Right
and
then
you
can
easily
work
around
that
by
producing
a
new
anymore
bolt
that
has
the
cancellation
token
stored
inside.
But
in
order
to
do
that,
you
have
to
have
white
box
knowledge
of
the
source.
New
rollback,
let's
see
essentially
I,
mean
one
way
to
kind
of
close.
This
would
be
to
say
that,
okay,
we
will.
We
say
that
single
user,
no
more
rules
at.
D
D
D
It
and,
and
how
do
you
maintain
that
contract
across
method
boundary
and
it
makes
it
out
halfway
through
a
new
rating
it
like
do
you
break
in
the
middle
here
for
each?
Does
it
dispose
it
or
not,
don't
want
to
created
it,
then?
Yes,
but
if
it
didn't
create
it
yeah,
maybe
you're
handing.
Maybe
somebody
else
is
going
to
do
the
rest
of
the
preaching.
D
F
R
I
D
R
I
D
Y
D
D
C
B
B
Guy
for
a
second,
but
if
every
time
I
want
to
enumerate
stuff
from
the
channel
I,
just
called
your
for
teach
or
a
week
for
each
plot
channel
dot
as
a
sinking
in
with
one
I
give
it
the
champ
can
switch
it
open
and
I
want
to
use
for
that
enumeration,
I'm
effectively
tearing
off
whatever
you
want
to
call
it
an
enumerable
or
a
numerate
or
the
channel
readers.
You
know,
multi
use.
Any
number
of
people
can
be
numerating
it
by
the
PI.
B
If
I
want
to
supply
cancellation,
I
get
the
numerable
that
has
my
cancellation.
Token
and
I
do
write
that
and
then
what
I'm
done
this?
No,
no,
it
hasn't
affected
to
change
yeah.
It's
just
commute.
So
this
is
the
case
that
I
was
kind
of
saying.
Well,
it
could
as
well
return.
I
know
my
right
or
it
would
be
exactly
the
same,
and
then
you
bring
up
the
issue
of
disposing
and
I'm.
R
T
D
A
A
A
D
R
On
we
would
basically
say
the
reset
thing
was
a
comm
feature.
We
now
implement
reset
as
trows
not
support
it
exception,
meaning
a
numerator,
something
we'll
use
a
numeral
bulls,
multi-use
I.
Think
I
I
get
what
you're
saying.
If
you
use
language
syntax,
we
will
dispose
it
for
you.
If
you
don't
use
language
syntax
to
dispossess.
You
know,
I
am
my.
A
Iteration
right,
it's
completely
fine
to
say
within
your
async
iterators
and
say
I
enumerate.
This
thing
once
do
something,
and
do
it
again,
because
I'm
now
I'm
part
of
the
same
cancellation
of
the
overall
operation
in
both
cases.
Well,
except
venue
with
the
only
thing
you
have
is
an
enumerate
or
you
can
only
do
it
once
for
sure.
No,
no,
but
the
translation
to
obtain
that
applies
to
each
iteration.
A
A
sync
iterator
and
all
I
want
to
do
is
I
want
to
iterate
this
thing
once
compute,
something
iterate
it
again
and
do
something
with
that
knowledge
right,
given
that
this
whole
thing
runs
with
the
same
cancellation
token,
that's
fine!
If
everything
is
I,
a
Seng
removal,
because
I
can
iterate
them
as
many
times
as
I
want
and
so
long
they
have
the
same
cancellation
token,
which
I
know
about
construction
was
the
case
in
my
case.
A
A
I
would
argue
harder,
because
the
Hindi
cancellation,
token
and
practice
will
have
a
lifetime
or
anything
I
sing,
Jones,
twice
no
I'm,
saying
no
I'm,
saying
that
the
common
thing
you
have
today
is
that
people
thinking
I
remove
all
they
can
generally
iterate
it
multiple
times
and
with
the
cancer.
Even
if
the
cancellation
token.
A
D
What
it
is
that
we
have
this
concept
in
the
middle
of
an
immovable
enumerable
is
only
supposed
to
be
iterated
once,
but
you
haven't
started
doing
it
yet
right,
then
you
Peck,
it
can
be
a
you
want
something
that
can
be
a
currency
type
and
you
can't
have
a
currency
type
that
is
mutable
and
in
the
middle
of
a
like
a
transformation
right.
So
so
that's
why
enumerators
I'm
good
as
a
currency
type,
but
you
couldn't
have
something
less
than
innumerable.
D
C
D
Call
getting
them
read
again:
you
get
an
exception
that
that
would
essentially
be
the
engine
was
about
to
say,
like
you
can
literally
just
implement
it
like
that,
or
you
can
just
say
so.
I
nee
move
over
the
additional
contract
that
you
can
only
do
one
and
then
that's
one
exception.
It's
exactly
the
same
as
move
next.
Also.
A
D
R
C
R
A
B
R
For
each
and
I
that
the
dispersed
thing
I
have
to
tell
you
I
kind
of
don't
buy
the
I
understand
that
there
is
an
you
know,
disposed
issue
and
you
can
screw
it
screw
it
up,
I'm,
not
sure
if,
like
in
practice
it
matters
so
I
think
that
the
core
of
where
I
am
remake.
You
is
basically
it
feels
natural
that
they
think
that
you
are
trying
to
cancel
is
the
enumeration
which
is.
C
R
Implemented,
like
you
know,
for
each
they're,
basically
with
one
call
its
I
get
next,
we
considered
about
so
much
faster
in
a
lot
of
cases
where
it's
like
you
know
it's
just
another
list
of
T
yeah.
We
have
usually
so
much
fun
considered
about
9
or
10
different
variations.
This
we
actually
implemented
up
until
a
few
weeks
ago,
a
completely
different
approach
in
the
compiler.
B
Various
constraints
around
what
you
can
do,
a
synchronously
with
regards
to
repin
out
what
you
can
do
with
regards
to
Co
and
contravariance,
and
we
had
an
API
that
allows
you
to.
Basically,
the
alternative
sort
of
the
winning
alternative
was
basically
a
two
method:
interface,
wait
for
next
async
and
try
next
dragon.
Next
and
basically,
you
would
effectively
start
state
machine
moving
forward
and
then
once
there
was
something
available,
you
would
sit
in
a
tight
inner
loop
calling
try
again
because.