►
From YouTube: 2021-01-27 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
how
are
things.
B
These
are
all
right,
let's
see,
how
are
you
doing.
B
There's
the
one
on
adding
the
length
that
is
left
yes
and
then
my
what
I
was
going
to
ask
was:
should
I
just
completely
separate
out
handling
moves
from
the
pr
that
I
created
for
moves
and
mutability?
There
was
some
little
bit
of
overlap,
so
that's
why
I've
done
them
together,
but
should
I
separate
them
out
or.
B
B
Is
a
reference
you
want
to
do
things
a
little
different,
so
I
feel
like
maybe
separating
it
out
and
just
doing
it
as
a
separate
like
doing
all
these
additions
in
a
single
pr
might
be
more
cleaner
for
someone
to
track
down
later.
A
B
Work
right
now
is
kind
of
small
something
needs
to
be
reworked
to
handle.
B
What
is
it
called
changes
to
fnf
and
once
because,
once
we
start
supporting
re-borrowing
and
all
all
these,
what
we
like
the
f
and
f
and
ones
will
change,
because
we
do
not
do
the
restriction
and
like
we
do
not
handle
like
we
do
not
trim
off
whatever
we
dremel
from
our
projections
or
anything
like
that
until
we
are
doing
a
min
capture
analysis.
A
B
A
Wait
so
long
because.
A
Yeah,
it's
not
so
bad.
I
could
try
to
review
it
tonight.
Okay,
to
the
extent
that
I
haven't
already,
which
I
forget
what
about
and
then
the
other
one
is
80629.
B
Sorry
I
want
to
talk
about
how
we
plan
on
implementing
the
rebar
like
do
we
just,
I
think,
I'm
just
gonna
r,
plus
this.
This.
A
Lint
one
it
looks
like
I
already
gave
it
a
review
and
was
pretty
happy
so
yeah,
okay,
I'm
just
gonna-
do
that
right
now
so
now
what
was
your
question.
A
That's
not
quite
right,
it's
not
important
if
the
root
variable
is
a
reference.
Okay,
what
we
want,
let's
make
a
do.
We
have
a
document.
B
I
have
we
can
start
a
new
one
and
I'll
just
dump
it
and
like
the
way
we
have
been
doing
it.
B
There
is
an
issue
for
this.
Yes,
so
yeah.
B
A
Well,
let's
do
it
I'm
using
my:
what
do
you
call
it
this
new
theory?
Oh
that
looks
right.
The
crazy
keyboard
strip
on
my
mac
for
changing
buttons
changes,
yeah.
A
Don't
think
it
provides
me
with
excessive
value,
but
neither
does
it
get
in
my
way
in
particular,
so
at
least
there's
a
physical
escape
key.
I
understand
that
was
a
problem
early
on
so
okay,
let's
look
at
the
example
yeah.
This
is
a
good
one,
a
good
enough
one,
or
this
is
an
initial
one.
Let's
start
with
it,
so.
A
A
B
Of
of
a
captured
place,
if
we
have,
let's
just
in
a
situation
like
this,
where
we
dereference
a
immutable
reference
on
top
of
a
mutable
reference.
B
We
need
to
do
that
for
handling
the
mutability
side
of
using
mutable
bottles
outside
of
the
case
of
moves.
Okay,.
A
B
Like
if
you
have
a
like,
if
you
have
a
tuple
that
contains
a
mutable
reference,
if
we
meet
we,
if
we
mutate
the
structures
via
this,
if
you,
if
we
mutate
sorry,
if
you
mutate
the,
if
we
mutate
some
data
while
going
through
this
tuple,
then
even
if
it's
a
mutable
border,
we
would
need
to
keep
a
track
of
mutability,
because
if
the
temple
is
immutable-
and
I
probably
should
be
writing
otherwise-
this
doesn't
make
sense.
Yeah.
B
So
like,
if
we
have
this,
we
have
let
us
legislate
string.
A
B
We
need
to
compute
the
mutability
of
if
this
place
started
our
zeros
mutable
or
not.
So
we
need
to
do
that
today.
Why?
B
Because
the
because
the
body
checker
a
lot
kind
of
special
cases,
the
immutability
of
uppers
and
until
today,
would
only
check
if
the
root
variable
is
mutable.
So
this
is
the
other
pr.
This
is
the
other
part
of
the
fear.
That's
open
as
part
of
the
move
here
that
we
were
talking.
A
About
but
what's
confusing
me
is,
maybe
I
don't
understand
the
word
we
or
we're
being
a
little
sloppy
when
we
say
we
need
to
compute
immutability,
which
piece
of
code
at
what
time
needs
to
compute
it.
A
B
We
also
would,
in
this
case
we'll
say
this
place
is
not
mutable,
because
it
will
just
look
at
the
root
variable
today
and
say:
oh
since
t
is
immutable,
the
start
of
this
place
will
be
immutable
because,
okay,
so
the
the
error
happens
because
of
the
same
issue
that
we
were
kind
of
discussing
last
week.
Is
we
see
that
a
capture
is
being
modified?
A
capture
in
its
entirety
is
being
modified.
B
A
A
Yeah,
so
that's
fine,
let's,
let's
pop
back
the
stack
a
little
bit
so
I
mean
just
to
summarize,
if
I
understood
basically,
we
are
storing
as
part
of
the
capture
information.
A
B
A
A
B
A
B
I
I
guess
yeah
another
similar
question
here
would
be
word
if
we,
I
was
actually
just
moving
the
path
as
dot
x.
Afterwards,
right
like
I,
just
called
move.
A
A
Right,
I
think,
ignoring
the
fact
that
it's
an
error.
What
I
expect
is
that
this
closure
will
mute,
ref,
s.x
and
well
it
would.
I
guess
I
take
that
back.
I
don't
think
it
would
move
s
dot
y,
because
we
never
move
d.
Refs
it'll
move
s,
so
I
think
it
would
just
move
s
yes,
and
in
that
case,
if
you're
going
to
move
s,
you
don't
mute.
Ref
s,
dot,
x,
right,
yeah,
also.
B
S
is
a
vertical
dropping,
so
it
will
like
that
chord
will
fail,
but
yeah.
Yes,
this
will
do
that.
A
B
A
Works
today,
but
this
is
not
really
it's
not
acid,
star
aesthetics,
yes,
but
this
probably
just
works.
B
Playground,
because
the
fix
is
not
in
it's
the
same
issue
that
I
was
talking
about
earlier
with
having
to
compute
immutability.
A
B
B
A
A
But
even
there,
I
think
it
just
kind
of
can't
happen,
because
the
only
time
you
would
reborrow
is
when
there's
a
draft
in
the
path,
and
if
you
have
a
move
of
some
suffix
of
that
path,
it
will
stop
at
the
draft.
And
so
therefore.
A
It's
going
to
wind
up
moving
the
whole
thing
and
your
your
reboro
is
not
needed.
The
only
case
where
I
think
this
analysis
applies
is
in
a
move
closure.
So
my
argument
is.
A
A
A
B
Yeah
yeah,
it
will
do
that
so
that
that,
like
the
main
caption
also
will
happen,
it
will
figure
out
the
shortest
path
we
should
capture.
Why
are
we
not
considering
shared
bottles
here
like
just
get
my
life
simpler?
Okay,.
B
A
I
haven't,
I
have
a
theory.
I
have
a
mental
model
that
I
want
to
try
on
you,
and
I
want
you
to
tell
me
if
it
fits.
A
This
is
my
model.
First
of
all,
the
analysis
has
two
two
phases.
A
Use
some
weird
pseudo
notation
here
where
mode
is.
A
The
place
and
and
then
you
have
minimus,
what
do
you
call
it?
Minimization
yeah
men,
analysis.
It
takes
quality
analysis
that
takes
s
and
produces
s
prime
of
captures.
Right,
yes,
and
so
that's
the
first
step.
I
think,
looking
just
at
this
first
step,
including
a
set
of
accesses,
I
think,
if
we
do
not,
let's
say
we
ignore.
We
borrow
second,
let's
do
it
before
we
have
reborrow.
B
That's
going
to
say
so:
some
truncation
to
some
degree
happens
as
part
of
the
min
analysis,
because
truncation
can
happen
on
not
just
remove.
We
could,
we
might
be
truncating
for
unsafe.
A
B
Yes,
they
all
accesses
are
actually
initialized
in
that
case,
so
yeah,
oh,
what
all
accesses
and
are
already
initialized
with
mobile
phone
number
correctly
by
value
capture.
B
B
No,
I'm
saying
we
don't
and
we
don't
change
it
later.
It's
just
initialized
that
way,
but
I
think.
A
A
Yeah,
I'm
just
kind
of
giving
a
like
mathematical
model
for
how
it
works,
so
something
not
necessarily
how
the
code
literally
works,
but
now
here's
the
big
change,
basically
is
with
reboros.
I
think
all
we
have
to
do
is
change
this
part.
To
say
if
m
is
mute,
ref
and
p
contains
the
draft
of
an
n
mute.
A
B
A
A
Well,
okay,
so
I
was
going
with
your
your
assertion
that
what
is
this
called
min
capture
analysis?
Yes,.
B
Okay,
I
see
okay,
so
this
is
this
is
where
I
was
a
little
confused,
and
this
is
why
they
I
had
made
a
comment
about.
If
you
look
at
the
first
very
say:
first
part
computing
a
set
of
axes
before
he
borrows,
so
we
initialize
things
to
be
a
move.
The
moment
we
see
them
and
we
don't
actually
maintain
a
state
of
what's
the
way
to
put
it,
we
don't
store
if
they
need
to
be
immutable,
bottle
or
something.
So
I
think
that
can
be
changed
so
like
line
143.
A
B
So
yeah
in
line
143,
basically
that
move
is
like
line.
142
is
always
a
move,
regardless
of
any
part
of
the
process.
We
are
in
as
long
as
it's
a
move
lawyer,
so
I
I
see
how
to
fix
it,
I'm
just
pointing
it
out
like
right
now.
It's
not
that
yeah,
so
just
just
so
that
if
I
ever
refer
to
this
video
again,
I
remember
things.
B
Yes,
and
also
the
reason
we
would
do
that
is
so
that
we
can
handle
immutable,
sorry
copy.
B
A
Can
we
actually?
No,
I
don't
know,
I
didn't
think
about
that.
That
analysis
is
done
based
on
the
it's
done
in
the.
A
A
Yes
s
yeah,
but
if
we
do
this
algorithm
like
we
can
go
apply
it
to
one
of
these
examples.
Right
like
like
this
one.
A
A
Yeah
where's
a
good.
What's
a
good
example,
we'll
do
this
one,
but
as
a
move
closure.
I
think
it's
a
good
example.
A
Which,
I
think
is
what
we
expect
yes
and
our
original
example
is
trivial,
because
there's
only
one
access
not
very
interesting,
I
guess
the
only
other
interesting
example
would
be
like
would
be
like
this
one.
A
B
B
Stars.Xml
and
then
we'll
convert
s
we'll
convert
this
to
a
reboro
of
well
to
introduce
a
rebar.
Do
we
just
drop
the
last
d
reference,
and
that
is
it.
A
B
A
B
Yes,
my
my
oh,
my
point
was:
how
do
I
describe
like
once
we
convert
that
new
draft
to
a
move
at
the
end,
or
do
we
never
just
or
we
don't
always.
If
we
don't
just
don't
do
that,
then
that
works
is
that
is
that
what
you're
suggesting.
A
A
B
A
Here
you
have
s
dot,
x
and
s
dot
y,
but
I
put
the
the
mute
ref
here.
So
you'll
get
star
s,
dot
x
and
move
star
s;
dot
y
we're
going
to
truncate
the
move
to
s.
So
we
wind
up
capturing
just
this.
B
Okay,
yeah,
this
makes
sense
I'll
try
to
get
the
vr
I'll
just
push
the
changes
that
I
have
I'll
keep
the
move
there
I'll
leave
some
degree
of
fix
me
if
it's
needed
for
the
fn
once
change
and
we
bought
it.
Sorry
f
and
once
are
likely
computing.
The
closure
trade
change
that
might
be
required
and
yeah
the
rebar
could
be
a
separate
vr.
A
Okay,
yeah
yeah,
I
would
like
the
reboro
seems
complex
enough
that
I'd
like
to
review
it.
Yeah
myself.
A
All
right,
as
far
as
your
other
pr
goes,
we
already
are.
I
just
request
the
the
migration
lint.
I
will
try
to
revive
you.
The
other
one
is
ready
for
review
right.
I
mean.
B
Yeah,
I
think
it's
ready
for
review.
I
just
like
the
only
change
I
was
making
was
around
dealing
with
fn
once
and
all
that
stuff,
because
some
truncating
might
have
like
if
we
truncate
a
draft.
Essentially
what
we'll
end
up
with
is
like.
B
If
we
are
ending
at
a
reference,
then
it's
possible
like
if
we
truncate
to
just
an
ampersand
string,
then
you
don't
need
to
have
an
if
you're
just
moving
an
ampersand
string
instead
of
a
string,
then
basically
you
can
have
an
f
enclosure
or
something
exposure,
so
just
need
to
handle
that
correctly
working
on
cleaning
up
there,
but
yeah
could
probably
turn
that
into
a
pair
of
it's
also,
that's
like
concise.
A
B
I
think
projects.
B
Okay,
that
so,
okay,
so
number
22
got
merged
and
number
32
is
I'll
check
in
with
you,
which
made
the
added
the
test.
That
you'd
ask
him.
A
B
So
number
22
should
probably
let
me
check
one
second,
I
thought
number
22
got
merged
or
I
know
you
delegated
to
chris
and
he
has
pushed
the
change.
B
So
it
should
be
good,
like
it's
waiting
on
boars
okay
yeah.
So
that's
about
done
so
chris
will
start
working
on
number
eight.
After
that
number
18
is
waiting
on
the
immutability
change
a
bit
because
we
get
those
extra
warnings.
When
we
add
some
test
cases.
B
Roxanne
started
working
on
24
based
on
discussion
from
last
week.
This
one,
I
think,
needs
a
test
case,
so
that's
being
done,
number
35,
the
first
part
once
it
gets
merged
I'll
open,
a
pr
for
precise
capture
as
well,
because
that's
already
unimplemented
and
I'm
just
gonna
start
working
on
the
what's.
It
called
the
insignificant
destructor
stuff
as
well.
B
We,
let's
take
a
look
so
number
eight
chris
will
start
working
soon.
Number
29,
we
discussed
number
29
and
number
28
are
sort
of.
We
need
to
look
into
this.
B
With
when
roxanne
version,
24
33,
I
think,
is
just
sort
of
an
extension
of
work-
that's
being
done
right
now,
but
can
it's
just
unsafe
code
that
shouldn't
be
too
hard
to
extend
the
current
strategy
to
all
right?
Can
you
go
back
to
this?
What
did
you
say
about
this
one
roxanne,
I'm
working
on
one
24.
This
will
go
with
24,
which
is
like
handling
patterns.
Okay,
so
24.
B
24
and
then
yeah
27
is
just
like
removing
one
line
once
that's
done,
got
it.
Okay,
if
you
scroll
down
on
the
to-do
side.
B
Oh,
what's
left,
this
is
calling
a
function.
This
is
minor
change
and
this
is
debug
diagnostics.
So
this
is
a
minor
change
that
I
will
that
we
can
do
of
what's
it
called
that
I
think
I'm
going
to
design
to
throw
after
he's
he's
going
to
add
some
tests
for
as
includers
so
john
triplett.
They
pointed
out
that
we
they.
B
We
don't
have
that
many
tests
for
them
or
any
tests
for
ace
enclosures
using
our
features.
So
I
was
to
add
some
tests
and
just
make
sure
I
tested
a
single
case
and
it
works,
but
just
add
some
of
those
37
and
23
are
just
extensions,
of
course,
enclosures.
To
be
sorry,
no
not
37.
20
37
can
be
closed
actually,
because
that
we
handle
with
the
new
drop
strategy.
A
A
And
I
remember
I
I
I
sort
of
yeah
we
were.
There
was
kind
of
this
question
of
like.
A
A
A
B
Yeah
so
like
the
changes
that
are
left
are
kind
of
the
main
big
changes
that
are
left
is
this
reborrow
implementing
insignificant,
destructors
and
patterns.
Everything
else
is
kind
of
sort
of
in
motion
or
just
like
waiting
on
other
a
bit
of
other
things.
It's
pretty.
B
B
A
Yeah,
that's
gonna,
be
I
think
it's
gonna
be
one
of
those
changes
that
that
we,
we
can't
believe
we
didn't
have
once
we've
had
it
for
a
while.
B
Yeah
I
I
can,
I
can
understand
I
I
think
it
will
also
make
like
people
who
are
just
starting
to
write
trust
a
little
less
confused
about
some
of
these
things.
At
least
that's
what
I
think
I
add
some
like
at
least
when
I
was
reading
the
irc.
It
felt
like
that
good.
This
could
be
a
big,
narrow
block
as
well
like
some
very
simple
patterns,
especially
in
case
of
like
lambdas,
within
a
self
block.
B
A
A
B
So
when
I
did
the
initial
testing,
this
feature
was
doing
better
like
if
you
go
into
my
220,
you
mean
your
perf
results.
Yes,
the
first
runs
we
did
it.
B
A
Okay,
well,
that's
good!
I
wonder
if
we'll
just
have
to
see
I'm
not
too
worried.
You
can
certainly
imagine
that
some
closures
get
really
big.
I
think.
B
Yeah
or
just
call
the
capture
or
migration
mac
or
whatever
end
up
interesting.