►
From YouTube: 2020-12-10 RFC 2229 Sync
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
So
do
you
have
a
plan?
I.
A
C
So
there
are
a
couple
that
are
not
in
here
for
well.
There
are
a
couple
of
things
I
wanted
us,
but
I'll
slowly
add
those
tests
once
you
fix
them,
because
what
I'd
initially
done
was
I
added
them?
They
just
don't
work
because
patterns
are
immutability
issues,
okay,
okay,
so
those
will
be.
I
I
want
to
add
them
as
I
fix
them.
So
that's
like
if
someone
looks
at
a
pr
like
yeah.
A
A
C
Actually,
life
patterns
and
stuff
like
that,
but
I
guess
those
were
tested
by
the
earlier
pr
which
then
had
like
the
procedure.
So
we
did
that.
There's
one
test
that
does
this.
What
I'll
do
is
I'll
look
at
a
couple
particular
tests
here,
because
we
still
see
them
failing
because,
like
we
now
see
precise
volatile
errors,
regardless
of
us
fixing
things
which
is
nice.
A
A
The
one
I
guess
I
still
think
it'd
be
nice
to
have
some
run
past
tests
that
just
exercise
capture
exercise
not
necessarily
min
capture
but
places
that
are
more
complex
than
just
a
b
like,
for
example,
indexes
or
stars
of
box
stuff,
like
that.
C
Okay
I'll
add
some
of
those
yeah.
I
I
have
tests
for
them,
though
those
weren't
really
okay,
so
I
mean
they
should
work
right
like
the
same
thing,
they
should
write
if
you
have,
but
so
what
I
would
have
done
is
like
I
I
guess
we
should
add
test
case
exclusively
but
yeah
well
explicitly.
I
did
come,
make
the
whole
test,
the
whole
compiler
other
things,
so
you.
C
A
C
We
have
moves
that
and
the
third
one
would
be
unsafe
pointers.
B
C
Yes
drop
any
drafts
or
any
projections
after
and
then
well
of
course,
any
projections
after
that.
That's
what
that's
not
implemented,
though
that's
I
have
comments
for
them.
I
have
tested
them
because
I
needed
to
do
that
for
the
whole
compiler
when
I
was
doing
the
whole
compiler
test,
but
they're
not,
but
it's
they're
not
in
this
pr,
just
because
they're
small
patches,
no.
A
I
think
that's
good.
I
still
I'm
not
sure.
If
that's
the
right
rule,
I
think
we
might,
we
might
need
to
go
with
the
like
dumbest
rule
of
move
just
means
capture
all
the
local
variables,
but
that
was
something
I
wanted
to
bring
up.
I
was
I
was
thinking
we
should
schedule
a
laying
team
design
meeting
to
talk,
probably
not
till
the
new
year.
I
guess
I
don't
know
whether
you
all
are
available
at
our
usual
slot.
It's
on
wednesdays,
at
1
p.m.
Eastern
time
I.
C
C
A
Ping
you
all
in,
but
this
is
going
to
want
this-
is
going
to
be
a
bit
of
a
judgment,
call
yeah
either
way.
Let's
talk
about
migrations
because
it's
going
to
be
relevant,
I
was
going
to
discuss
something
yeah.
C
So
one
thing
that
was
brought
up
during
the
rfc
was
and
I'll
send
a
link
again
here,
it's
similar
to
what
we
were
discussing
last
time
and
I
think
it's
maybe
written
a
bit
more
formally.
It's
on
the
zoom.
C
C
E
B
C
At
least
the
way
I
understand
this
is
we
essentially
enforce
so,
let's
say
we
were
we
had.
We
had
a
mutable
reference
or
something,
let's
say
some
point
and
we
capture
star,
p,
dot
x
and
instead
of
since
p,
our
base
type
was
a
reference
itself.
We
essentially
add
a
border
on
top
of
this
and
then
move
the
borrow
instead
of
moving
star
p
dot
x,
which
is
a
value.
A
Yeah,
so
this
this,
what
sam
sartor
wrote
here
we
had
a
hackmd
last
time
right.
Yes,
we
did
it's,
I'm
gonna
get
a
ratio.
C
Which
one
was
move
out
of
references
and
okay?
I
think
I
should
probably
make
it
better.
A
A
I
don't
know
whatever
so
you
have
it
open.
I
have
it
open,
yes
right,
so
I
think
I
think
this
rule
that
sam
describes
is
the
same
one
that
I
arrived
at
yeah,
but
where
I
wrote
possible
extension
on.
C
I
thought
this
was
more
around
the
option.
One
we
were
looking.
D
At
maybe
but
yeah
possible.
Actually,
yes,
sometimes.
A
Capture
by
reference-
oh,
I
guess
I'll
share
this-
why
not
maybe
okay!
So
this
this
extension
here!
I
think
that
that's
exactly
what
what
he's
saying
is
exactly
what
I
proposed
there.
C
A
The
the
new
match,
the
the
match
modes-
change
that
we
recently
introduced
a
few
years
back.
It's
not
sure
if.
D
C
Some
okay
yeah.
A
So
we
wind
up
turning
this
into
a
reference,
because
you
kind
of
pass
through
this
reference.
Oh
I
see
that's
what
we
call
a
borrowing
mode
and
that's
kind
of
the
same
rule.
I
hadn't
actually
seen
that
until
I
read
what
sam
wrote
there,
that's
a
good!
A
A
It
is
not
this
truncate
on
d
referral,
yes,
I
think
so
it's
an
extension
of
it,
which
is
why
I
wrote
extension
like
it.
Sometimes.
Basically,
you
would
still
truncate
a
draft,
but
only
for
boxes
or
like,
but
not
for
reference
dress
your
truncate
drafts
that
are
of
other
things,
which
in
this
case.
C
A
I
don't
know,
I
think
I
think
we
should
defer
this
question.
This
seems
to
be
a
policy
question
and
we
should
take
it
to
the
lang
team
and
it
would
be
useful-
and
I
can
try
to
do
that-
who
write
up
the
like
options
and
interest
races.
I
think
I
have
a
pretty
good
handle
on
that
and
I
can
write
up
the
things,
but
in
the
end
of
the
day,
this
is
a
policy
question
of
like
what
policy
right.
It's
not
an
implementation
problem.
It's
a
problem,
who's,
the
right
thing
for
the
language.
C
C
C
A
A
I
don't
know
whether
they
should
behave
the
same
or
not,
but
like
I
have
opini,
that's
something
we
have
to
decide.
However,
non-move
closures,
in
my
opinion,
like
what
am
I
saying
so
they
I
think,
there's
prob
there
may
be
room
for
them
to
be
like
am
I
saying
whatever
they
do?
I
think
they
they'll
probably
want
to
be,
at
least
this
precise.
This
is
what
I'm
trying
to
say.
A
C
A
Yeah,
so
the
question
is
how
to
implement
it
right
or
what
or
did
you
have
other
questions
about
migration.
C
A
Yeah,
why
don't
we?
A
C
A
A
A
A
B
A
A
A
It
affects
the
runtime
semantics,
because
the
destructor
for
the
or
because
the
destructors
can
run
at
different
times
in
the
older
version,
the
destructor
for
the
base
variable
x
would
run
when
the
closure
was
dropped
because
the
closure
owned
x
in
the
newer
version,
if
the
closure
only
captures
x,
dot
y
and
the
destructor
for
y
will
run
when
the
closure
is
dropped
or
for
the
field
y.
A
Does
this
all
make
sense,
yep,
okay,
so
work
around
is
introduce
left
x,
equals
x
into
the
closure,
and
now
I
can
make
an
observation.
A
few
observations.
A
Matter
or
let's
put
it
this
way,
let
me
rephrase
it
a
few
destructors
actually
have
side
effects
in
practice,
most
just
free
memory.
A
When
the
destructor
runs
as
long
as
it
runs
and
or
they
would
probably
prefer
the
memory
to
be
freed
earlier-
which
I
don't
know-
which
it
may
be
or
may
not
be.
A
With
the
more
precise
capture,
the
reason
I
say
that
is,
if
you
make
a
move
closure
and
you
return
it
from
your
stack
frame,
yeah
you're,
going
to
get
straight
just
living
longer
than
your
stack
frame.
So,
but
on
the
other
hand,
if
the
closure
does
not
escape
the
stack
frame,
then
that's
not
true,
but
in
that
case
it's
probably
not
anyway.
The
point
is
my
hypothesis
is
so
long
as
the
destructors
are
only
freeing
memory.
A
We
don't
care
and
I
think
we
would
be
doing
users
a
disservice
if
we
migrate
their
code,
such
that
you
know,
if
we
introduce
let
x
equals
x,
just
because
some
string
might
get
free
to
slightly
different
time.
That's
my
consensus.
So.
D
A
A
Maybe
I
don't
know
we
don't
have
any
mechanism
for
that
right
now
and
that's
fine.
I
wouldn't
worry
about
it.
It's
just
really
easy
to
change.
What
I
basically
want
to
do
is
how
I
think
it
should
work
is
we
should
detect
if
the
no
longer
moved
content
has
a
type
that
may
have
a
sort
of
significant
destructor.
A
And
everything
else
is
significant,
so
we
essentially
have
an
accept
list
or
something
and
the
point
being
now.
A
A
And
see
whether
it
may
include
to
see
whether
it
may.
D
C
A
The
standard
limb
is
tied
to
the
version
of
the
compiler
that
is
building
it.
Basically,
so
you
can
have
like
nightly
unstable
things
in
there
that's
kind
of
a
standard,
lib
special.
It's
the
only
the
rust
code
that
can
ship
unstable
things
in
stable.
We
have
to
be
very
careful
too.
A
You
know
and
yeah
we'll
have
to
write
a
little
bit
of
logic
to
like
say
like
if
you
have
a
tuple,
you
know
whatever
it
has
to
know
there
kind
of
is
code
for
doing
this
already
have
to
be
slightly
adapted,
there's
code
for
figuring
out.
If
we
need
to
run
a
destructor
at
all,
we
would
have
to
like
tweak
it
with
a
boolean
or
some
kind
of
flag.
That
says,
like.
A
C
A
This
can
happen
like
whenever
right,
okay,
so
it
can
be
pretty
late
and
actually
it
wants
to
run
in
the
old
edition.
So
it's
gonna
want
to
run.
A
C
We
just
well
we
just
faked
like
well,
it's
not
fake.
Really,
we
just
initialize
reads
for
the
upwards
that
were
mentioned,
and
that
will
just
force
the
min
capture
to
do
things
did.
C
We
do
that
at
the
start
right
now,
because
we
realize
there's
no
reason
to
move
it
to
the
end,
but
yes,
well,
not
until
recently,
but
yeah
we'll
probably
move
it
to
the
end
yeah
now.
C
The
reason
we
want
to
move
it
to
the
end
is
because
that
allows
us
to
prioritize
the
things
we
see
inside
than
just
whatever
fake
things
we
created
earlier
and
in
the
sense
that
our
algorithm
prioritizes
what
we
see
earlier
over
things
we
see
later,
and
it
just
forces
any
kind
of
fake
information
that
we
are
adding
into
there
to
be
as
less
of
as
little
priority
as
possible.
B
C
I'm
assuming
there's
some
kind
of
like
context
right
that
we
are
doing
this
particular
analysis
like
we're
doing
this
migration
analysis
or
whatever
you
want
to
call
this.
C
Like
capture
analysis,
not
up
our
analysis,
actually,
no,
we
we
don't
really
need
that.
Yes,
you're
right,
I
can
just
think
that,
so
what
would
be
have
been
previously
captured
to
what
is
now
being
captured
is
essentially,
of
course,
mentioned,
was
being
what
is
was
being
really
captured
before,
and
this
is
what
has
been
captured
now.
The
only
question
comes
down
to
is:
do
we
need
I'm
forgetting
yeah?
The
moves
is
what
what
we
really
care
about,
so
we
might
need
to
figure
out
which
parts
get
would
have
been
moved
really.
C
And
yes,
but
what
I
was
thinking
he
was
using
upwards
mentioned
directly
to
figure
it
out,
but
yeah.
This
is
possible
to
do
something
of
this
sort.
C
In
in
check,
yes,
yes,
so
there's
two
analysis
right.
One
is
when,
when
you
software
analysis,
it
confuses
me
for,
like
the
very
first
pass
that
happens
for
things
that
are
just
mentioned
and
when
I
say
caption
analysis
like
the
second
one,
which
is
the
type
check
one.
A
A
Okay,
very
very
yeah
and
yeah.
So
then
the
point
is
it
will
be
like
zero
cost.
If
or
what's
nice
about,
this
is
you're
gonna.
Do
the
clone
sort
of
into
a
local
variable
during
the
upvar
analysis,
and
that
means
you'll
you'll
drop
that
local
variable
when
it's
done
so
we
won't
like
expand
the
memory
usage
and
so
forth.
In
particular,
it
never
has
to
get
stored
into
any
query
results.
A
A
Now
we
can
diff
the
results
and
I
think,
a
good
place
to
start.
I
guess
is
like
this
is
a
plenty
of
challenge
to
get
all
this
working,
but
once
we
do
have
it
working,
we
will
have
a
list
of
local
variables
that
you
know
may
contain
a
significant.
A
A
A
The
local
variable
may
have
a
significant
destructor
in
its
type
and
that
destructor
is
not
or
is
found
somewhere
outside
the
captured
place,
and
my
point
is
this
second
part
is
optional,
because
that's
like
more
precise,
but
if
I
had
to
take
a
guess,
I
would
guess
that
most
of
the
time,
it
won't
matter
so
quiet,
sorry,
guys
I'll
give
you
an
example
of
what
I
think.
It's
probably
worth.
Writing
writing
a
few
examples
to
show
what
I'm
talking
about
unless
you're
completely
following
and
don't
think
that's
necessary.
A
Okay,
well,
here's
an
example
anyway,
just
because
so
you
know
you
might
have
some
code
like
this,
and
this
is
an
example
of
changes
semantics.
But
who
cares
and
the
change
in
semantics
is
like
x,
is
dropped,
sorry,
x,
dot,
one
is
dropping
and
the
block
exits
not
when
c
is
dropped,
yeah
just
slightly
later
or
the
ordering
is
changing,
and
if
we
change
this
to
so
this
case.
A
A
A
This
is
the
optional
case,
so
I'm
saying
that
if
we
make
the
analysis
simpler,
all
we
would
do
is
say:
does
x
anywhere
have
a
significant
destructor,
yes
or
no
yeah.
If
the
answer
is
yes,
then
we'll
conservatively
transform
it.
Even
if,
because
we
happen
to
capture
the
significant
destructor,
it
doesn't
actually
matter
and
then
we
could
go
back
later.
C
That's
kind
of
where
my
question
was
coming
from
is
like
when
we
do
this
type
analysis
sort
of
thing,
how
do
we
figure
out?
How
do
we
plan
on
storing
the
path
itself
that,
where
the
like,
I
know
it's
optional,
but
if
we
were
to
do
that,
how
do
we
store
that?
Oh,
if
the
path
that
we
take
is,
let's
say
let's
say
this-
was
something
complicated
again:
a
dot
b,
dot
c
and
or-
and
we
had
again
an
a
dot
b,
r
d.
How
do
we
store
that.
A
C
Like
the
way
my
head
was
around,
this
was
like:
if
we
can
get
a
list
of
all
significant
drop
pods
and
we
can
represent
it
similar
to
places
we
can
again
do
the
similar
ancestor
analysis,
sort
of
thing
we
do
for
min
capture
and
that
will
give
us.
A
A
This
does
not
do
what
we
want,
but
what
this
does
is
this
figures
out,
so
needs
drop
figures
out
in
an
approximated
way
if
any
part
of
this
type
may
define
a
destructor
basically
and
but
it
only
considers
the
type.
A
What
you'll
see
is
it
basically
says?
Okay,
it
calls
needs
drop
component
wherever
that
is,
but
basically
it
matches
the
type.
And
let's
say
it's
just.
A
Okay,
this
is
annoying,
but
the
code
is
like
kind
of
generic
and
weird,
but
the
the
point
is
this
is
a
good
example
for
tuples.
You
know
it
goes
through
each
of
the
fields:
false
needs
to
drop
on
the
tuples
yeah,
and
so
what
I'm
imagining
is.
You
would
look
at
the
place
and
you
would
say
this
is
the
dot
one
field
I'll
go
through
all
the
fields
that
are
not
dot,
one
of
this
vector
and
dot
one
I'm
just
gonna,
ignore
it
because
well,
okay,
that
makes
sense.
That's
actually
not
quite
right.
A
You
have
you
have
to
get
to
the
end
of
the
place
before
you
can
actually
ignore
it,
but
what
you
would
do
is
you
would
have
this
optional
place,
that's
like
if
you
match
this
place,
or
maybe
it's
an
optional
slice
of
projections.
Actually,
if
this
slice
is
empty,
then
you
found
a
match.
So
you
can
just
stop
here
because
that's
the
place
that
got
captured,
so
I
can
ignore
it.
A
C
Mean
sort
of
like
I
get
the
general
idea,
I
think
when
I
start
writing
portugal
just
kind
of
makes
sense.
Also
like
we
really
just
care
about
adts
and
doubles
here,
because
that's
that's.
What
introduce
our
field
projections
right
and
I
don't
know,
what's
happening
with
ddos
and
the
situation,
but
again
it's
just
like
it
will
provide
us
access
to
another
field.
At
best
you.
A
C
A
D
A
Yet
I
would
start
just
by
using
needs,
drop,
okay
or
a
variant
of
needs
drop
which
we'll
have
to
define
that
I
mean
honestly,
we
could
actually
just
start
with
needs
drop.
Yes,
I
think
these
droppers
and
not
even
have
the
idea
of
significant
destructors,
because
yeah.
A
Code
with
local
copy
types
yeah
so
then
make
needs,
drop,
understand
significant
destructors,
and
then
these
are
like
the
refinements.
We
can
do
now.
The
hard
part
is
this
one.
We
come
to
some
list
of
local
variables
that
used
to
be
captured
and
we
want
to
have
backwards,
compatibility
around
them
or,
and
I'm
just
going
to
say,
and
they
may
have
significant
detours,
which
we
can
define
what
significant
means
in
more
and
more
refined
ways.
A
So
then,
this
is
where
we
have
to
make
a
suggestion
to
modify
the
text
of
the
closure
in
some
way,
and
one
thing
I
will
say
that
it's
relevant
here
is:
if
I
guess
it
depends
what
comes
out
of
that
linkedin
meeting,
because
if
the,
if
what
we
decide
is
that
move
closures
need
like,
we
need
some
more
complex
syntax
for
people,
so
they
can
more
conveniently
handle
some
of
these
annoying
cases
that
may
affect
what
we
do
here,
because
right
now,
the
only
workaround
we
have
is
let
x
equals
x
inserted
into
the
body
which
is
okay.
A
But
you
know
it's
kind
of
annoying
we
have
to
if
the
closure
doesn't
have
a
block.
Already,
we
have
to
add
x
kind
of
at
the
front
and
at
the
end
you
know
else,
and
the
nice
thing
is
we
can
just
we
can
make
these
edits
really
gross
like
the
formatting
doesn't
happen.
A
A
It's
not
the
end
of
the
world,
but
it
could
definitely
work.
However,
imagine
that
we
added
a
syntax
like
move.
No,
no,
no,
like
suppose
you
could
write
this.
I
don't
know
yeah,
which
kind
of
says
I
want
to
move
these.
B
A
A
D
A
A
B
C
B
A
C
A
A
Oh
and
cargo
fix
it.
That's
right!
That's
why
we
do
migrations.
We
we
issue.
Lints
and
people
run
cargo
fix
to
move
between.
We
have
like
edition
or
something
okay,.
A
C
A
A
But
really
like
there's
plenty
of
code
to
write
just
to
get
to
the
point
where
you're
ready
to
make
the
edit
in
the
first
place.
You
know,
like
you
a
good
first
pr,
I
think,
would
add
the
lint
just
using
knee
drop,
not
any
of
the
smarter
versions,
but
without
a
suggestion.
A
A
C
Yeah
that
makes
sense
yeah
okay,
so
I
have
some
somewhat
of
an
idea
here.
I
think
that's
good
enough
to
kick
things
off
yeah.
Another
issue
that
I
missed
was
like
our
issue
around
patterns
and
the
I
don't
know
if
you
like
that,
it's
extendable
to
like
the
functional
update
pattern
as
well.
So
if
you
scroll
up
a
little
or
if
you
go
on
the
view
thing
like
the
third
option,
hack
md
as
and
then
there's
the
open,
bugs
and
migrations
and
then
there's
the
first
one
yeah.
C
So
we
have
patterns,
we
don't
have
these
structured
patterns,
just
don't
work
at
all
right
now,
and
that
is
mostly
because
we
expect
like
we
have
work
around
for
this.
So
this
is
not
too
big
a
concern,
but
at
some
point
I
think
this
would
be
we
have.
How
much
time
do
we
have?
Oh,
we
have
terminals.
So
maybe
we
can
just
discuss
this
a
bit
more
detail
because
it's
patterns
and
then
there's
also
the
struct
update
syntax,
which
is
like
the
point
doing
this.
C
That
also
doesn't
work
for
the
exact
same
reason,
which
is
the
place,
is
completely
mentioned,
but
only
partially
captured
and
if
it
is
partially
sorry
I
actually
okay
yeah.
So
if
it's
partially
captured
also
wait,
I
I
feel
like
okay,
never
mind.
No,
I
had
fun
up
and
down.
While
I
listened
to
it.
No,
no
sorry,
my
I
got
a
call
and
then
give
me
one.
Second,
sorry.
C
Yeah
yeah,
so
essentially
the
issue
is
the
same
thing.
We
have
a
place,
that's
completely
mentioned,
but
that's
mentioned
in
the
in
our
code
within
our
closure,
but
it's
the
way
we
capture
it
does
not
express
it
as
as
completely
captured
yeah
so,
and
this
extends
outside
of
just
patterns.
A
C
We
haven't
tried
this
yet,
and
I'm
just
want
to
discuss
that.
We'll
probably
just
have
to
do
this
across
more
in,
I
think
like
across
the
whole,
build
at
this.
I
don't
know
if
it
needs
to
be
across
build
or
not
is
I
guess
my
concern
are
because
now
we
have
this
functional
syntax
one
as
well.
D
C
A
Issue,
I
think
this
is
probably
relatively
easy
for
us
to
fix.
Okay,
there's
an
analysis
that
takes
place
in
right
back
to
figure
out
and
I
don't
see
any
reason
we
can't
sort
of
move
that
code
earlier.
C
So,
for
the
mentioned
one,
we
just
basically
replace
most
things
and
place,
build
and
more
ability
to
use
voice
builder,
or
do
we
still
be
now
without
the
ones
above?
Do
we
still
be
a
little
bit
more
conservative
about
it?.
C
C
Okay,
and
would
you
want
me
to
submit
a
worker
on
pr
for
this
so
that
it
would
be
nice
if
people,
if
they're
they're,
weird
cases
that
people
can
there
are
other
people
that
can
think
of
when
they
use
this?
So
I'm
wondering
if
we
should
have
it
is
a
workaround
pr
like.
Should
I
create
a
workaround
pr?
C
Yes-
and
I
can
like
this-
is
the
general
solution,
I
can
just
add
functions
which
are
actually
just
named
fake
consume
for
two
to
nine.
The
first
one
isn't
really
relevant.
It's
just
the
second
file.
That's
right.
A
D
A
Yeah,
I
would
add
that
for
now
and
file
an
issue
to
to
resolve
it
some
future
all
right.
I
am
much
more
worried
about
this.
E
A
A
C
C
yeah,
and
there
was
like
another
example
that
I
put
up
there
like
scroll
to
the
bottom,
where
we
first
send
and
sync
yeah.
A
Right,
I
mean
I
think
we
can
probably
make
right.
We
can
potentially
make
some
of
these
examples
work,
but
the
general
case
worries
me
because
it's
easy
enough
for
someone
to
write
their
own
pattern
and
there's
no
way
we're
going
to
migrate
like
if
any
trait
is
implemented
by
you
know
like
we
can't
tell
that
question
yeah
exactly
no.
We
only
we
plausibly,
we
could
figure
out.
A
No,
I
don't
know
I
I
don't
I'm
not.
I
don't
really
want
to
get
if
the
migration
needs
us
to
be
like
super
smart,
smarter
than
it's
already
pretty
smart
if
it
has
to
get
smarter
than
what
I've
already
described.
I
don't
I'm
worried,
so
this
is
part
of
the
reason
that
I
I
feel
like
there's
a
case
for
move
capturing
local
variables
only.
A
I
I
still
feel
weird
about
it.
Also
I
haven't
figured
it
out,
and
maybe
what
we
want
is
just
a
shorthand
syntax
for
move
yeah
that
you
capture
only
local
variables
and
which
is
sort
of
what
you
suggested
already
but
yeah,
but
I
would
tie
it
into
a
more
general
closure
capture,
syntax
and
it
just
has
some
and
then
all
we
do
is
every
move
closure
like
no
matter
what
becomes
that
shorthand.
C
A
Okay,
I
mean
maybe
I
I.
C
I
okay.
Actually,
if
we
go
back
to
the
maybe
I
might
have
just
copied
this
so
yeah,
I
never
mind
yeah.
I
think
I
just
copied
this
over.
So
it's
probably
not
the
different
thing.
But
if
you
look
at
29
again,
we.
A
Bad
move
in
it,
but
I
think
it
would
compile
without
move
yeah
and
same
probably
test
this
right.
So
this
might
like
sort
of
validate
my
hypothesis
or
something
that
this
won't
come
up
without
move.
A
C
And
well,
I
was
going
for
every
move.
Well,
everything.
A
C
A
I
could
imagine
if,
if
you
have
a
closure
like
this
one,
that
captures
exactly
one
thing
or
everything
it
captures
is
by
move.
We
could
convert
it
to
this
syntax,
that's
probably
relatively
low
impact.
What
I'm
wondering
about
are
cases
where
some
things
are
by
move
and
some
things
are
not
like.
You
could
make
an
example.
A
A
A
A
A
C
That
makes
sense.
Okay,
I
think
we
are
about
time.
I
need
to
head
off
soon,
but
yeah.
This
makes
sense.
I
guess
first
fridays
will
still
be
to
get
the
migrations,
sorry,
mutation
and
all
the
fixes
and
sort
of
small
open
peers.
We
have
well
the
peers
that
we
are
working
for
diagnostics
and
stuff,
and
then
we
start
migrations.
I
don't
know
if
you'll
actually
get
the
migrations
before
next
week.
Are
you
available
next
week.
C
Okay,
I'll
I'll
I'll
try
to
kick
some
things
off
then
and
yeah
discuss
any
quick
follow-ups.
We
have
all
right.
Thank.