►
From YouTube: 2021-06-30 RFC 2229
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).
B
All
right,
so
we
have
the
size
pr
merged
in
all
right,
so
we
have
the
size
beer
right,
so
we
have
the
size
pr
merged
in
and
I
added
that
part
to
our
blog,
which
let
me
just
share
my
screen
and
yes,
I
need
sharing
permissions.
B
All
right,
okay,
so
how
do
I
yeah
that
one?
B
B
A
A
Should
probably
put
yeah,
I
was
thinking,
maybe
edit
the
I
might
move
these
two
caveats
into
the
questions
themselves
so
like
link
to
project
repository
and
you
could
put
optional
and
then
just
delete
it
from
the
top
or
put
like.
B
A
D
Those
three
ellipses
on
the
right
bottom
right
just
add
description.
Smart
all,
right.
A
That's
excellent
and
then
I
would
I
would
take
also
please
note
that
google
collects
the
data
or
is
that
added
by
google.
B
Yeah
like
yeah
and
that's
about
it.
So
if
we
refresh
this
page
now,
all
right,
yeah,
so
you're
not
expected
to
share
your
source
code,
but
don't.
A
Change
it
to
change
it
to
required
just
total
nitpick,
but
I
I
alright
fair.
E
A
G
B
All
right,
just
let
me
make
sure
that
is
yeah.
It's
not
limited
to
one
response.
It's
usually
gonna
submit
multiple
and
yeah.
That's
enabled
all
right,
so
this
is
done.
Second
question
I
had
was
which,
where
do
these
go
in
their
last
reference.
A
E
A
I
think,
first
and
foremost
should
go
in
the
edition
migration
guide,
which
is
in
wrestling.org
edition
guide.
B
B
B
B
A
D
A
H
A
H
F
A
B
Yes,
so
how
do
I
or
where
do
I
like?
Do
I
just
add
another
section
in
this
which
says
2021.
A
Yeah,
that's
a
good
question
scroll
up
a
little
bit.
C
A
F
A
Directs
people
to
the
edition
migration
guide,
for
you,
know,
questions
or
something,
and
so
I
think
I
would
say
like.
I
would
change
it
here
where
it
says
a
closure
expression
with
a
unique
anonymous
type,
a
closure
which
contains,
let's
say
the
captured
values
instead
of
variables,
and
it
would
say,
like
these
values
correspond
to
you
know,.
B
A
After
this
like
capture,
precision
you
know,
and
then
it
goes
into
detail,
that's
how
I
would
do
it
and
then
I
would
have
a
rush
2018,
either
a
subsection
or
just
a
second
just
another
section.
That
says
like
rush.
H
A
B
All
right
that
makes
sense.
Okay!
What's
next,
we
have
our
optimization
pr.
That's
up.
I
think
that
needs
approval,
so
I'll
leave
that
so
that's
still
in
review.
Okay,
we
have
a.
D
B
So
we
have
a
bug
in
our
migration
and
I'll
explain
where
it
comes
from.
So
this
is
something
you
pointed
out
early
on
as
well,
where
one
second,
so
we
so
there's
a
check
in
the
drop
migration
part
which
says,
if
essentially,
if
drop,
is
defined
on
a
type.
So
it
uses
this
type
like
part
of
like
the
what's
it
called
the
traits.
B
I
think
rate
system
to
figure
out
if
drop
is
implemented
for
a
particular
type,
and
if
so,
then
we
should
not
be
seeing
this,
because
anything
that
has
drop
implemented
on
it
will
be
should
be
completely
captured
because
you
cannot
move
out
of
it.
B
But
I
what
we
are
seeing
is
that
this
call
fails
and
it
either
causes,
and
the
interesting
thing
is
we
I
am
seeing
or
like
amongst
us.
We
have
seen
two
different
sorts
of
errors,
so
drove
and
roxanne
get
an
error
which
says
some
something
about
infor
regions
or
it
it's
similar
to
what
we
get.
If
things
are
not
resolved,
when
it
says,
cannot.
G
B
A
H
A
I
do
think
that
asking
if
a
type
implements
the
drop
trait
is
like
a
wacky
thing
to
do,
not
because
it's
not
wrong.
I
guess
just
the
drop
is
very
like
special,
and
maybe
you
know
I
mean
what
I
mean
by
that
is
like
we'll
synthesize,
whether
or
not
you
implement
the
trait.
A
You
know
we
synthesize
drop,
it
doesn't
mean
nothing
happens
when
you
get
dropped
because
we'll
synthesize
drops
of
all
your
sub
constituent
fields
and
so
forth,
but
that
none
of
that,
like
that's
just
true
that
that
is
a
weird
thing.
However,
I
don't
know
why
that
would
make
these
ices
happen.
B
B
So
initially
it
was
added,
because
I
did
not
realize
that
you
cannot
move
out
of
drop
types,
so
it
was
sort
of
there,
and
then
we
realized
that
this
is
just.
We
left
it
there
because
saying
it,
it's
a
possible
bug
in
the
user
code
and
the
fact
that
we
can
detect
it.
We
just
do
not
migrate
in
that
scenario
in
case
it
does
end
up
running
on
that
rustrix
ends
up
running
on
that
I
am
completely.
B
A
So
this
this
not
tuple
go
up
next
one.
I
want
to
see
the
adt
case.
That's
what
I'm
trying
to
get
yeah
so
another
way
to
do
that
same
check.
If
you
wanted
to
would
be
to.
H
A
A
A
A
B
A
B
A
What
I
mean
is,
if
you
take
the
check
out
and
they
have
like
foo
dot
bar
where
foo
has
a
destructor.
They
might
capture
food.bar
right
instead
of
capturing
foo.
A
B
A
E
A
B
So
yeah,
I
think
that
is
that
is
basically
make
this
checker.
Okay,
all
right.
So
that
is
basically
what
was
sort
of
stopping
us
from
also
doing
insignificant
destructor
checks.
Another
thing
that
we
kind
of
so
we
started
doing
in
singapore
and
destructors,
and
one
thing
we
realized
was
if
we
enable
the
lint,
as
is
it,
fires
a
lot
around
one
pin
for
a
race.
A
A
B
A
A
Yeah,
okay,
I
would
guess
those
are
like
type
parameters
of
type.
You
know
t
implements,
fn
mute
or
something,
but
there's
some
kind
of
bug
about
the
I
mean
you're
already
actually
whole
path.
F
A
B
A
F
A
C
C
A
C
H
H
A
B
B
B
B
B
B
B
B
B
A
Yeah,
that's
fine,
then
take
out
the
arguments
and
just
have
it
all
predicate
by
itself.
Just
all
it
does.
It
calls
predicate.
H
C
A
B
A
B
B
At
least
from
we
definitely
wanted
to
capture,
we
probably
should
drop
the
data
and
yeah.
A
B
We
did
want
precise
capture,
so
I
think
we
really
just
want
to
drop
drilling
details.
A
B
Not
okay,
so
there
was
this
example,
which
was
x,
dot
y
dot
truncate.
I
think,
in
which
case
we
were
fine
with
capturing,
if
even
if
x
was
an
ampersand
reference,
you're
fine,
with
capturing
star.x,
dot
y
and
a
reference
to
this,
or
something
like
that,
so
that
we
can
just
so
that
we
can
offer
precision,
especially
around
prints
and
stuff.
B
G
A
A
reference
we
borrowed
yes-
and
there
was
a
good
reason
for
that
you're
right.
I
forgot
about
that
rule
okay,
so
this
is
falling
out
from
that.
That's
interesting
and
I
see
that
we're
doing
a
unique
immutable
borrow.
A
That
seems
wrong
to
me.
Change
it
to.
A
A
F
A
Yeah
it
actually
is.
It
might
be
a
bit
of
a
bug
here,
because
if
you
were
capturing
the
local
variable
predicate.
A
A
unique
immutable
borrow
is
reasonable,
because
what
you
get
back
is
like
this
doesn't
actually
exist
in
rust,
but
if
it
did,
you
get
back
an
ampersand,
unique
that
says,
like
I
have
a
reference
which
nobody
else
can
use
this
reference,
but
I
can't
write
it,
which
is
different
than
ammu,
we're
saying
nobody
else
can
use
it
and
I
can
write
it
so
that
makes
sense
for
the
local
variable
predicate,
but
for
star
predicate
we
actually
need
a
real
mutable
borrow
right
like
so
I'm
not
sure
where
the
unique
immutable
borrow
code
comes
from
like.
H
A
I
think
we
still
get
an
ampersand
mute
out
of
it
like
if
there's
no
type
that
corresponds
to
that.
So
when
we
make
our
types,
we
still
make
it
in
amps
mute,
which
is
a
little
weird,
but
anyway
we
just
sort
of
know
that
it's
like
an
amp
sam
mute.
You
promised
not
to
write
to,
and
we
know
that's
true
because.
B
A
Well,
I
don't
know
how
we
know
that's
true,
but,
and
so
anyway
the
point
is,
I
was
wondering,
I'm
a
little
bit,
I'm
there
seems
to
be
some
bug.
Okay,
what
am.
B
B
So
this
is
oh
yeah.
This
is
like
we
want
to
set
that
yeah
yeah,
I'm
assuming
something
calls
you
from
expert.
A
Music,
I
vaguely
remember
this
code,
but
yeah.
I
think
it's
not
quite
right.
I
think
there's
a
subtle
bug
here
and
I
don't
I
have
to
look
at
it
to
know,
but
but
I
don't
know
that
that
go
back
to
the
to
the
example
for
a
second
I
might
be
getting.
This
might
be
a
bit
of
a
red
herring
like
there
might
be
a
bug
here,
but
there's
something
else.
That's
a
little
funny
to
me,
which
is
the
type
of
value
that's
being
captured.
A
It
should
be
still,
even
though
we're
capturing
star,
predicate
we're
capturing
it
by
reference,
so
the
type
that
we
check
to
see
whether
it
implements
unpin
or
not,
it
should
be
a
reference
to
star
dref
which
in
other
words
it
should
be
an
ampersand
predicate
which
is
actually
what
we
wanted.
So
there
might
be
a
bug
in
the
code.
Can
we
pull
up
the
auto
trade
testing
code,
yeah.
B
No,
I
I
know
where
the
problem
is
so
here
the
problem
is
so
this
is
so.
This
function,
final
advertise.
B
A
Well,
that's
yeah!
Okay,
that's
what
I
was
imagining
the
bug
might
be.
So
I
think
that's
that's
the
bug.
It's
not
that
we're
capturing
the
wrong
thing.
It's
actually,
okay
to
capture
the
I
mean,
there's,
maybe
two
bugs
we
shouldn't
have
this
unique
immutable
borrow,
but
I
don't
actually
think
that
bug
is
harmful.
A
C
B
C
Sorry,
yes,
my
screen's,
pretty
big
so.
B
B
I
see
so
we
look
at
the
okay,
so
there's
two
things
you
missed.
We
do
not
consider
the
type
of
the
capture
kind
of
the
root
variable.
We
just
look
at
whatever
what
the
type
of
the
root
variable
is.
We
do
not
account
if
it
would
have
been
a
bottom.
E
B
So
this
one
would
be
a
little
tricky
as
well,
because
we
don't
just
need
to
look
for
so
we
would
have
to
go
and
take
the
maximum
of
all
the
capture
current.
We
have
starting
at
that
path.
B
B
A
A
I
don't
think
so,
but
go
on
well.
So
here's
what
I
think
is
going
to
happen.
Your
2021
you've
captured
by
reference
star,
whatever.
A
B
H
B
F
B
B
I
I
have
gone
through
exams
with
philadelphia
type
was
not
not
using
a
single
one.
I
have
rock
handy
one.
Oh
sorry,.
H
A
Throw
it
on
the
yes,
we
should
throw
it
on
the
some
project.
A
A
A
I
kind
of
forgot
about
these
reboros
at
the
time
so
like,
for
example,
if
you
have
a
box
of
ampersand
mute
of
t
and
you
use
and
you
call
dot
truncate
or
whatever
in
a
move
closure,
we
probably
want
to
reborrow.
A
B
Okay-
let's,
let's
just
do
that
here,
just
to
figure
out
what's
actually
happening
I'll
just
I
know
all
right,
so
we
have
fm
box
mute
and
that
the
what
we
want
is,
let's
say
we
have
let
s
equals.
A
F
B
B
A
C
A
A
Yeah,
I
don't
think
that's
the
right
thing.
I
mean
it's
not
so
we're
gonna
move
bx,
so
we're
taking
ownership
of
the
string,
but
it's
still
limited
to
like
it's
still
not
going
to
be
able
to
outlive
px
or
s
rather,
so
we
don't
really
get
anything.
By
doing
that,
I
think
if
we
captured
and
mute
star
star
bx,
we
would
it's
like
strictly
better.
It's
it's
more
flexible
and.
F
B
A
B
A
G
A
G
F
Mute
as
I
wonder
how
that
worked,
I
don't
oh
well
that
that
probably
won't
that'll.
A
B
B
So
we
have
this
who
so,
instead
of
a
string,
we
have
like
something
that
actually
contains
data
inside
and
the
same
box
of
a
mute.
Now,
if
I
were
to
do
something
like
this,
which
is
just
move
this
or.
A
Well,
it
matters
here
that
it's
a
copy
value.
A
B
I
think
we
do
in
the
case
am
I
doing
particular
we
might
do
that
in
the
case
of
moves.
Let
me
just
confirm
it:
it's
been
a
little
while,
since
I
even
wrote
that
so
one
sec
and.
B
No,
we
definitely
do
yeah,
so
this
gets
called
in
a
capture.
Coin
for
place
gets
called
from
and
it
captures
yeah.
It
gets
called
from
internet
capture
info
for
place,
which
is
called
from
both
consume
and
wait.
I'm
copying
the
wrong
phone,
so
yeah
internet
capture
info
for
place
gets
called
from.
Basically,
our
first
functions
that
hit
us
from
infrabotto
kind
and
stuff
which
calls
in
in
it
capture
kind
which
accounts
for
the
closure
is
by
val.
B
B
Yes,
then
we
in
that
case
you
will
do
a
biovalue
capture.
If
the
data
gets
moved
out,
then
we
will
truncate
the
capture.
Yes,.
A
A
F
H
A
A
move,
so
it
seems
better,
I
think,
that's
a
bug.
B
All
right,
so
that
is
this
part,
yes
yeah,
so.
A
A
B
B
Yeah
because
we
will
end
up
yeah
if
it's
data,
we
don't
wait.
Sorry
if
the
capture
count
is
by
value,
we
don't
want
yeah.
Sorry,
I
got
a
call
yeah.
If
the
capture
kind
is
by
value,
then
we
don't
want
sorry
just
give
me
one.
Second.
B
A
B
A
A
A
You
can't
move
out
of
any
other
kind
of
deref
than
a
box,
and
it
only
matters
if
you're
moving
out
of
the
draft
so
like
if
you're
capturing
a
thing
which
is
a
copy
like
if
it's
a
copy
type,
you
could
move
out,
but
then
you're
actually
copying
out
not
moving
out.
So
we
actually
capture
a
reference
and
if
you're.
A
B
Because
this
is
called
when
the
data
so
there's
a
this
one
gets
run
when
we
are
moving
data
out
of
a
reference.
Sorry,
when
we're
moving
data
into
a
closure,
not
if
it's
a
move
player.
B
A
A
A
A
Yeah,
let
me
yes,
why
don't
you
if
you
have
time,
I
would
love
it
if
you
wanted
to
take
a
stab
at
producing
a
version
of
this
that
can
go
in
the
reference.
That's
like
more
mathematical,
but
if
that's
tell
me,
if
you
feel
like
that's
outside
of
your
like,
you
don't
quite
know
how
to
approach
that
and
I'll
take
a
step
at
it.
Instead,.
B
I
I
would
I'll
I'll
take
a
stab
at
it,
which
is
mathematical.
I
don't
know
how
good
my
output
would
be,
but
I
think
I
can
take
a.
B
A
I
think
I
think
I
would
like
to.
I
would
like
to
think
of
it
like
some
algorithm
that
takes
in
yes,
the
tricky
part
is
that
we're
doing
things
at
various
places,
so
my
ideal
world
is,
we
would
take
as
input
the
something
that's
not
dependent
on
modes
at
all,
like
the
precise
captures
would
just
be
independent
of
the
capture
clause
and
all
the
other
stuff,
and
we
would
like
then
process
that
set
and
do
all
the
logic
in
some
later
step.
I.
A
A
And
then
like
there
will
be
some
algorithm
that
like
churns
those
and
produces
the
end
result,
and
so
the
fact
that
we
like
when
the
in
the
code,
at
least
as
we
assemble
that
first
step,
we
look
at
the
capture
clause,
makes
that
a
little
more
complicated.
Because
then
the
code
is
not
producing
just
a
transcription
of
what
the
closure
does.
It's
producing
it's
already
doing
a
little
bit
of
logic,
but
maybe
we
can.
B
B
G
A
H
A
Stabilize
yeah
an
ideal
world,
we
can
implement
it
and
you
know
yeah.
E
B
B
All
right,
I
will
all
right.
Okay,
thank
you.