►
From YouTube: 2021-04-21 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).
B
Can
you
guys
hear
me:
okay,
okay,
yeah,
so
chris,
I
guess
status
updates.
President
diagnostics,
I
think
there
are
only
some
comments
left,
which
reminds
me
I
need
to
say
close
another
open
rust
ticket
to
improve
what
your
diagnostics
good
stuff
done.
There.
We
have
a
bunch
of
questions
about
regarding
the
auditory
stuff
because
I
think
roxanna.
C
B
Okay,
so
basically
we
don't
have
things
for
our
send
right
now,
because
of
that
and
thing
that's
left
is
drop
and
yeah
those
exams.
The
only
thing
that's
left
is
like
small
comments.
It
won't
be
long
after
today
or
tomorrow.
I
think
he's
done
today
or
tomorrow.
Other
stuff.
D
C
C
A
C
Do
I
have
it?
Can
you
all
see
my
screen
yeah
so,
like
I've
been
looking
through
the
language
item
table
because
that's,
it
seems
like
for
everything
else,
like
the
sync
trait
and
the
clone
trade
we
can
find
with
this
id
just
by
calling
like
yeah.
C
No,
I
can't
I
can
find
the.
A
C
A
Know
what
it
might
not
be
in
there
actually,
because
there's
really
been
no
reason
for
the
compiler
to
know
about
the
send
trait
it's
just
an
auto
trait
and
there's
logic
that
works
for
all
auto
traits.
A
C
A
C
Tried
to
add
a
new
row,
but
I'm
not
sure
what
I
have
to
do
like
do
like
do
I,
if
there's
some
other
things,
I
need
to
add,
apart
from
adding
a
new
row
in
that
table,.
C
C
A
Okay,
so
if
you
pull
open
hold
on
I'll,
send
a
link
in
two
seconds
so.
C
C
A
C
Okay,
yeah-
and
I
guess,
like
the
the
other
thing
that
I
kind
of
realized
is
like
I
I
guess
like,
as
I
mentioned
like
a
few
days
ago
like
it
seems
to
me
like
the
clone,
or
I
think
it
could
also
be
applicable,
maybe
for
other
traits
that
we're
checking
but
like
since
we're
only
checking
if
the
root
variable
is
applies
to
trade
and.
A
C
A
C
C
Was
a
really
like
false
migration?
It's
more
like,
I
guess,
I'm
more
concerned
that,
like
in
the
case
where,
like
a
lot
of
things,
do
implement
the
clone
trait.
We
just
end
up
like
providing
a
lot
of
warnings
for
like
things
that
may
not
need
like
that.
The
user
may
not
care
about,
and
it
would
just.
A
A
A
A
C
B
B
A
A
A
So
what
I
was
saying
was:
if
anyone
is
going
to
care
that
the
closure
is
cloned,
it
will
be
the
closure.
Creator
must
care
and
there
would
be
a
couple
ways
that
that
could
happen.
One
would
be
like.
A
Like
this,
but
another
might
be,
let's
make
this
self-contained.
Another
might
be
like
this.
A
And
here
it's
like
you
know
we're
telling
our
caller
that
the
closure
we
return
is
cloned.
But
the
point
is
that
either
way
at
the
point
where
we
return
c,
it's
our
job
as
this
function
to
prove
that
c
is
cloned
for
our,
so
that
our
caller
can
rely
on
it
and
what
that
means
is
actually
during
the
type
check.
We
have
a
kind
of
record
of
all
the
things
we
had
to
prove
along
the
way
for
this
particular
function,
and
so
we
could
conceivably
remember
things
like
anytime.
A
Let's
remember
that,
because
then
we
might
want
to
lint
about
it,
and
if
we
don't
see
a
record
in
there
that
we
ever
had
to
prove
that
the
closure
was
cloned,
then
we
can
leave
off
the
lint.
So.
B
I
have
a
thought
about
one
educate,
so
let's
say
the
user
did
have
a
call
to
let
the
c
dot
clone
somewhere,
but
before
they
run
the
migrations
before
they
were
doing
something
they
did
comment
it
out,
for
whatever
reason
they
were
trying.
Something
out
like
could
be
anything.
B
A
A
Yeah,
it's
a
question
of
how
often
does
it
happen
that,
like?
How
often
does
this
scenario
happen?
In
the
first
place,
I
think
my
assumption
was
most
clone.
Things
have
non-cloned
things
or
don't
have
not
cloned
things
in
them,
or
at
least
if
they
do
we're
either
capturing
them
by
reference,
in
which
case
it
doesn't
matter
because
the
reference
is
cloned
or
we
are
capturing
the
outer
thing
so
like.
If
you
imagine
as
an
example,
if
I
said
let
x
equals
rc
new,
not
clone.
A
A
Just
yeah
you're,
probably
right
that
in
fact,
we'll
always
just
capture
the
rc,
because
it's
it's
got
a
draft
or
whatever
else.
That's.
B
A
C
A
A
We
have
something
we
call
autotrade
leakage
and
in
particular
it's
allowed
for
me
to
write
code
like
this
for
better
or
worse,
better
a
lot
of
the
time,
but
not
always.
A
And
even
though
I
didn't
write
impul
fn
once
plus
send
this
will
compile,
assuming
this
is
sent,
of
course,
let's
just
make
it
send
by
it's
trivially
send
now.
So
the
reason
is
when
we're
testing
whether
an
auto
trade
holds,
we
actually
don't
use
the
like
opaque
type,
where
all
we
know
is
that
it
implements
fn
once
we
actually
test
it
against
the
other.
Excuse
me,
the
underlying
type,
the
hidden
type
and
that's
basically
because
well
that's
kind
of
what
autotrades
do
is
they
leak?
A
That's
their
whole
reason
to
exist
is
to
be
convenient,
so
they
leak
out
through
privacy
and
other
kinds
of
boundaries,
and
the
point
the
point
being
that
when
we're
type
checking
variant
two,
we
actually
can't
know
whether
one
of
our
callers
cares
or
not.
A
If
the
closure
gets
returned
or
otherwise
passed
outside
of
the
function,
because
there's
another
variant
like
this
well,
okay,
this
variant
is
not
so
important.
I
take
it
back.
I
was
going
to
say
something
like
this,
but
actually
we
would.
A
We
would
have
to
write,
send
here
for
for
us
to
to
do
this
error.
So
actually
it's
not
true.
It's
really
only
the
returning
case,
so
if
we
want
it
to
be
super
precise,
we
could
detect
the
case
where
the
closure
gets
returned
somehow,
and
so,
if
we
wanted
to
be
super
precise
maximally
precise,
we
would
say,
consider
and
autotrade
x.
If
we
see
a
test
for
closure
x
or,
let's
say
a
t
or
closure
type
c
is
returned.
However,.
A
However,
you
know
migrations,
don't
have
to
be
perfect.
Our
aim
is
to
get
90
percent
of
the
code
out
there
automatically
migrated
or
something-
and
my
hunch
is.
B
C
A
A
B
D
C
C
B
A
B
A
B
The
compiler,
no,
I
only
did
that
for
the
testing
part,
I
think
I
do
not.
I
might
have,
I
might
have
not.
There
was
only
one
spot
and
no
that
needed
an
actual
migration.
Oh,
I
did
not
because
the
my
commit
had
a
lot
of
other
unimplemented
features
being
bugs
being
worked
around.
A
B
A
Right,
so
if
we,
if
we
just
implement
the
maximal,
we
get
a
total
number
of
migrations
and
I
think
there's
a
there's.
Also.
My
hypothesis,
which
I
started
with,
was
that
that
number
would
actually
be
small,
like
that,
most
of
the
time,
if
the
outer
thing
is
send
the
inner
thing
will
be
send
and
vice
versa,
it's
rare
to
transition
that
way,
and
if
that's
true,
then
none
of
this
matters
at
all,
because
it's
like
fractions
of
a
small
number
are
still
a
small
number.
A
A
D
B
Oh
everything,
that's
in
in
progress
are
in
review
except
the
blog
post,
because
I
forgot
to
put
my
changes
and
I'm
sorry
yeah,
but
other
than
that
everything
that's
in
those
two
columns
are
near
done
because
all
the
diagnostic
stuff,
you
review
it
from
what
I
understand
so
we're
basically
feature
complete,
except
for
maybe
adding
some
more
test
cases
to
the
compiler,
but
nothing,
nothing
major
is
left
from
an
implementation
point
of
view,
yeah
great.
It's
amazing,
yeah,
so
yeah.
A
A
I'm
using
problem
is
the
code
I'm
using
is
mostly
unstable
only
so
I
have
to
wait
a
little
while
still,
but.
B
We'll
get
there
yeah.
Is
there
anything
for
us
from
edition
team
or
lang
team
that
we
should
need
to
worry
about,
given
deadlines
are
coming
up
soon
or
there?
No.
A
C
A
A
A
Right,
I
guess
I
think
we
could
recategorize
that
as
polish,
given
that
they're
not
stable,
fair
enough,
in
other
words,
so
therefore.
D
A
B
A
My
experience
is
that
every
every
deadline
gets
met
this
way
in
practice.
Oh
those
bugs
look
hard.
Let's
push
that
to
the
next
milestone.
A
I'll
see
you
monday,
yes,
we'll
see
you
monday,
we'll.