►
From YouTube: 2021-01-08 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).
A
B
Oh,
oh,
oh,
oh
sorry,
let
me
figure
out
why,
okay,
it
should
be
available
now.
C
A
Yep
all
right,
so
we
have
a
bunch
of
pr's
that
were
created
over
the
last
week,
so
well
yeah
three.
Actually
there
should
be
one
for
migration.
That
is
so.
This
one
is
roxanne
created
it,
which
is
I'll
quickly
go
over
discuss
this.
This
is
the
really
so
we
have
one
thing
and
that's
in
review
is
to
improve
diagnostics,
for
when
we
report
errors
around,
if
f
and
once
f
and
mute
and
f
enclosure
like
the
traits
are
not
being
met.
A
So
now
we
can
provide
better
diagnostics
in
terms
of
just
like
the
place
that
we
report
is
now
the
precise
spot.
That's
made
us
select,
fnf
and
once,
and
whichever
thing
similar
for
when
trades
like
copy
trade
is
not
met,
we
now
require
precise
diagnostics,
so
pr
is
open
for
that.
A
What
else
I
have
a
pro?
First,
we
are
open
for
migrations.
A
So
this
is
the
basic
what
we
had
discussed
with,
where
we
just
use
news
drop
to
select
places
that
might
require
so
just
hold
on
quickly
scroll
down.
So
this
is
just
like
a
basic
set
of
test
cases
based
on
knees,
drop
that
might
need
migration,
so
this
is
done,
and
now
we
have
this
length
which
you
can
just
enable,
which
is
disjoint,
deny
disjoint
capture
drop
reorder,
but
again
if
a
name
can
be
discussed
and
we
can
come
with
a
new
one,
but
I
have
there's
this:
that's
open.
A
A
Yes,
I
would
need
some.
I
would
like
some
help
on
this.
I
wasn't
able
to
figure
that
out
where
that
was
coming
from.
Basically,
when
I
started
looking
at
the
debug
logs,
a
lot
of
what
I
saw
is
bar
checker
states
yeah.
A
Chris
has,
I
don't
know
if
he
created
a
pr
and
wrestling,
but
I
I
at
least
approved
it
on
my
our
end
that
initial
work
on
splitting
password
bar
checkers,
like
we
can
now
store
more
detailed
information
on
basically
separate
the
span
for
the
path
that
we
selected
versus
the
span
for
the
capture
kind
that
we
have
so
that
we
can
do
better
diagnostics,
so
that
is
also
there.
A
So
one
thing,
I
think
that's
important
that
I
kind
of
want
to
discuss
right
now
what
tyson
brought
up
recently
about
our
destruction,
the
significant
destructors
that
we
were
discussing
for
migrations
before
the
before
the
holidays.
A
B
A
Okay,
okay,
that
makes
more
sense,
then
all
right
so
that
that
I'll
start
implementing
so
knees
drop
today
is
implemented.
As
a
query,
I'm
wondering
if
you
want
to
add
another
query
for
something
like
this
or
how
do
you,
because
then
that
means
it
will
get
into
like
if
someone
runs
the
linda
at
some
point,
the
results
from
that
query
will
get
stored
and
some,
I
guess,
I'm
assuming
incremental
cash.
B
I
think
a
query:
I'm
a
little
bit,
I'm
trying
to
think
what
kind
of
context
it
needs.
A
B
A
The
type
that
might
be
dropped
yes,
but
you
need
some
way
of
looking
at
the
attributes
on
that
type
because
that's
how
we
landed
it
so.
A
B
Yeah,
a
query
is
probably
good.
The
thing
is.
B
B
Careful
about
query
cycles
and
I'm
not
sure
how
needs
drop
handles
that
I
think
it
creates
an
internal
vector
to
track
it
or
something.
Okay,
and
you
have
to
look
but
like
the
danger
would
be
if
you
just
naively,
because
needs
drop.
A
B
Oh
valid
code
for
sure,
okay,
so
an
example
would
be
like
you
might
have
a
struct
foo.
Let's
say
you
have
a
link
list.
Okay,
you
have
a
struct
link
list
and
one
of
its
fields
is
next
option
box
of
linked.
C
A
I
didn't
look
too
much
into
the
query
itself,
but
yeah
it
ends
up
being
called
ends
up.
Calling
a
query
will
implement
it
in
an
interesting
way.
What
else
yeah
one
thing?
Another
thing
we
probably
want
to
be
careful
about
is
generic
arguments.
So
let's
say
we
have
a
vector
of
whatever
types.
Now
the
vector
will
have
a
sigma
vector
will
be
a
significant
drop
type.
A
If
the
elements
are
then
at
her
significant
drop
so
like,
if
you
have
a
vector
of
a
type
that
the
user
implements
that
type
and
has
a
custom
drop,
then
that
vector
now
becomes
significant
to
us,
because
that
drop
water
could
have
actual
effects.
They
could
have
side
effects
other
than
this
training
of
memory.
B
Okay,
so
right,
so
the
fact
that,
let's
see
what
you're
saying
here
is
yeah,
you
can't
stop
the
search
when
you
find
a
type
that
that
I
think
that
seems
right.
You
keep
going.
But
if
we,
if
we
go
to
what
needs,
I
mean,
in
other
words
vec
of
t,
if
you,
if
you
look,
can
you
pull
up
the
needs
of
drop
code?
I
think
that
would
be
helpful.
A
B
A
A
A
B
A
A
B
B
Okay,
well,
it's
not
that
important,
I'm
sure
what
that
code
looks
like
if
we
could
find
it
is.
It
basically
has
like
a
loop
where
it.
A
B
A
Yeah,
my
point
was
around
asking
about
the
vector
stuff.
B
Right
all
right,
oh
all,
right
so
vectors
what
they
yeah.
I
forgot.
What
vectors
will
do
I
mean
the
way
that
would
work
is
that
your
the
component
of
the
vector
will
be
t
right.
A
B
That
doesn't
work
as
well,
because
it
may
or
may
not
drop
all
of
those
arguments
for
one
thing
so
like
you
could
have
a
struct
that
has
inside
of
it
an
ampersand
t,
in
which
case
the
t
won't
get
dropped.
C
B
Also
yeah,
so
the
needs
drop
code,
like
the
neat,
strap
components.
Kind
of
already
solves
that
problem.
Essentially,
the
advantage
of
the
scheme
you're
proposing
would
be
that
you
wouldn't
have
to
worry
about
cycles,
but
unfortunately,
it's
not
sufficiently
precise,
but
I
think
what,
if
you
look
at,
how
needs
drop
works,
which
I
don't
have
in
front
of
me,
because
I.
B
Okay,
okay,
yeah
and
you
can
see
the
stack
and
the
hash
set
there
yeah
seeing
ties.
So
if
you
go
down
now,
I
don't
know
what
that
use
size
is
for,
but
whatever
keep
going
down,
keep
going
down
a
little
bit
more
a
little
bit
more
here!
Stop
okay!
So
the
adt!
B
B
No
what's
going
on
here,
this
doesn't
look
right,
no
sorry,
scroll
up!
It's
not
what
I
wanted.
C
B
B
So
yeah
that
looks
right:
that,
where
does
that
get
cold.
A
B
Okay,
so
adt
fields
is
like
a
that's
wacky.
Okay,
fine!
I
see
yeah.
So
if
you
go
back
to
that,
adt
drop
ties.
I
don't
know
where
exactly
that's
getting
called.
But
the
point
is
here
where
it
says:
if
there's
a
destructor
return,
error
always
requires
drop.
B
B
B
Easy
because
you
have
the
def
idea
of
the
struct
right
there
in
your
hand,
but
yes,
so
and
then
the
idea
would
be
that
we
basically
run
this
lint,
see
how
many
and
we'll
see
what
false
I
mean.
Either
we
go
through
all
the
structs
in
the
standard
library
and
decide
where
to
put
the
attribute,
or
we
run
the
lint
on
a
bunch
of
code
and
every
time
we
get
a
false
warning.
That
seems
silly.
We
put
we
add
more
attributes
until
we
stop
getting
silly
warnings
yeah,
they
both
will
work.
A
Yeah,
I
also
have
the
precision
pass
implemented
that
we
talked
about
the
step.
That
would
be
after
this.
So
let
me
I
don't
know
if
I
committed
any
test
cases
to
that,
but
I
think
the
idea
for
using
a
slice
actually
worked
pretty
well.
I
can
show
you
that
as
well.
A
A
Yeah
so
act,
let's
see
yeah.
So
basically
the
slicer
that
you
were
talking
about
actually
worked
very
nicely
yeah.
One
thing
that
was
another
interesting
thing
that
I
don't
know
if
you
discuss
it
or
not
right
was
that
it
is
possible
that
let's
say
we
have
a
structure
and
we
capture
all
of
its
fields
like
completely.
It
is
still
possible
that
the
structure
implements
the
drop,
in
which
case
we
would
have
to
run.
A
A
A
So
we
have
so
we
have
this
wrapper,
which
has
a
point
ignore
the
ampersand.
I
realized.
I
didn't
need
that
there
and
it's
wrong
to
actually
have
it
here
so
yeah.
So
we
have
this
wrapper.
We
have
a
point
and
a
color
inside
it.
Color
doesn't
implement
drop
point,
has
fancy
integers,
which
influence
drop
and
basically,
what
we
do
is
we
capture
w
dot,
p,
dot
x
and
w
dot
c,
which
means
w
dot,
p
dot
y,
then
capture
and
we
would
have
to
migrate
for
it.
A
Now,
the
way
we
start
is
we
start
with
the
type
of
w
and
the
slices
of
projections
that
represent
our
captures.
I.
B
A
What
starts
at
p?
We
start
at
c
now
we
see
that
we
have
an
empty
slice
in
this
vector,
which
means
this
thing
was
completely
captured.
Yep,
we
don't
need
to
deal
with
it
and
we
return
false
and
similarly
over
here
we
see
we
have
a
slice
which
contains
only
one
of
them,
but
now
that
we
are,
we
were
split
into
multiple
parts.
This
one
was
completely
captured,
so
we
didn't
do
nothing.
B
All
right,
this
is
great
yeah,
it's
perfect
when
you,
when
you
expand
in
the
any
given
node
into
its
children.
Are
you
that's
for
every
field
in
the
struct
or
whatever
right?
That's.
A
I
tried
couple
examples.
This
seems
to
work.
We
would
need
some
of
the
previous
pr's
to
go
in
just
so
that
I
can
assert
on
a
couple
things
like:
let's
try,
the
raw
pointer
and
stuff,
but
yeah.
B
Yeah
are
those
all
assigned
to
me.
B
B
There's
no
point:
okay,.
A
A
Yeah,
so
the
problem
is
or
like
the
thing
we're
trying
to
fix
over
here.
Oh
god,
is
it
a
little
bit
so
we
have.
We
are
modifying
something
use
via
an
emitter
so
like
that
itself
is
immutable,
but
it
contains
a
mutable
borrow
that
allows
us
to
actually
modify
the
original
place,
which
I
yeah,
which
itself
is
immutable,
but
that's
kind
of
the
testing
point,
but
the
idea
is
we
don't
need
that
to
be
mutable
to
fix
our
issue
over
here.
A
A
No,
we
don't
so
basically
like
where
we
do
see
this.
Like
the
like.
Once
I
start
back
racing,
it
basically
comes
down
to
a
function
which
is
called
from
basically
everywhere
and
at
some
point
I
could
not
like
none
of
the
places
I
saw
it
being
called
from
was
near
directly
near
somewhere.
We
referenced
upwards
or
like
captures
or
anything,
so
it's
kind
of
hard
to
figure
out
and
if
I
enable
some
more
logging
on
it,
I
think
I
end
up
seeing
a
lot
of
bottle.
Checker
states
which
to
me
did
not
make
much
sense.
B
A
A
And
I
can
just
I
should
really
add
another
work
trick
on.
A
A
A
While
that
it
is
the
branch
and
stuff
we
can
still
sort
of
look
into
where
this
gets
called
from,
I
have
access
sorry
reportability.
I
think.
A
C
A
B
Thinking
yeah,
I'm
thinking
it
will
work
better,
it's
not
to.
Maybe
we
can
are
you
available
later
today?
I
am,
I
don't
know
about
you
roxanne,
but
what
I
was
thinking
is
what,
if
I
got
this
building,
I
think
it'll.
B
A
Yeah
bring
me
give
me,
can
you
give
me
just
an
idea?
I
just
yeah.
B
Probably,
looking
at
my
calendar,
real
fast,
probably
2
p.m,
would
work.
B
Yeah
2pm
should.
C
B
B
Oh,
you
know
what
oh
bother
annoying.
Okay,
I
have
too
many
calendars
now
so
many
calendars,
not
that
one!
That's
not
even.
C
C
A
A
A
So,
like
the
first
time
we
see
the
most
ancestor
part
that
ended
up
getting
captured
per
se
will
be
the
one
we
say
was
the
reason
why
we
captured
that
path.
So,
for
example,
in
this
piece
of
code
we
have
like,
let's
say
within
a
closure-
we
have
print
p,
dot
x
and
then
print
p.