►
From YouTube: 2021-06-02 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
Yeah,
so
I
think
we
can
go
over
sort
of
the
quick
step
first
and
then
get
into
the
closure
side
stuff.
I
think
it
might
require
quite
a
bit
of
refactor
and
I
just
don't
want
to
know,
don't
know
too
much
about
it.
So
yeah,
let
me
share
my
screen
or
just
send
you
the
link
to
the
blog
post,
roxanna
and
that
were
working
on
circumstances
in
the
status
think
channel
on
zulu
I'll,
hear
my
stream.
A
How
do
I?
How
do
I
get
rid
of
these
zoom
thing
that
shows?
Okay,
that's
where
this
works,
so
what
we
had
talked
about
was
we
wanted
to
take
the
blog
post
and
split
that
into
post,
like
pages
that
will
go
in
the
last
reference.
So
that's
what
we
did.
So
we
have
two
phases
now
which
are
now
actually
probably,
this
is
easier.
So
there
are
two
pages
now
that
will
go
in
the
rough
reference
and
then
their
blog
post
that
will
end
up
linking
to
them.
A
So
the
overall
blog
post
now
is
just
sort
of
a
brief
description
that
we
talked
about
that
we
want
to
give
about
the
feature
and
the
fact
that
just
give
an
idea
that
this
this
is
going
to
be
a
breaking
feature,
so
they're
going
to
migration
helps
goes
a
little
bit
into
water
closures
and
really
just
ends
up
linking
the
rust
book
crossed
by
example
and
the
rust
reference,
depending
on
the
level
of
the
experience
the
person
has
was
reading.
This
gives.
A
Into
what
this
giant
capture
is
and
kind
of
links
the
rc,
so
that
whoever
cares
about
like
knowing
what
the
motivation
is
and
all
that
stuff
and
the
plan
is
over
here,
we'll
end
up
linking
the
posts,
our
pages
and
rush
reference,
which,
as
one
is
there,
are
cases
where
what
you
like.
The
path
is
not
captured
to
full
precision
and
that
there
are
minor
breaking
changes,
and
this
is
they're
again
documented
in
the
rush
reference
details
on
using
the
lint
and
the
that
and
and
then.
C
D
B
I'm
wondering
okay,
can
you
scroll
back
up
to
the
two
reference
pages?
What's
the
difference
in
them,
I
see.
B
B
So
if
we
put
that
in
the
migration
guide,
that'll
be
available
immediately
in
the
nightly
links,
the
rust
reference
only
contains
stable
things,
which
is
kind
of
annoying.
I
wish
there.
I
don't
actually
like
that.
I
think
that's
well,
it
makes
sense,
but
it's
annoying
when
you're
trying
to
do
what
you're
trying
to
do,
because
it
means
you
can't
link
to
to
it.
But
we
could
land
this
in
the
migration
guide
and
link
to
it
the
next
day
via
via
a
nightly
link
and
then
for
the
reference.
B
Yeah,
that's
probably
why
I
said
that
I
do
think
it's
a
good
idea.
So
scroll
up
one
thing:
that's
not
in
here
under
capture
precision!
Sorry,
nothing
far
up.
A
B
A
Okay,
I
can
put
a
box
example
if
you
want
that.
B
B
A
Okay,
I
will,
let's
see
how
you
add
a
comment
here:
okay,.
A
Yes,
it
is
if
a
move
closure
will
not
move
out
of
the
reference
is
really
what
that
rule
is.
So
that
is
yes,
we
talk
about
it
that
well.
B
I
think
the
rest
does
fall
out
from
capturing
references
because
rc
it
might
be
worth
adding
a
note
about
adding
an
example
of
rc.
I
would
probably
put
it
as
like
a
it's,
not
a
rule.
It
like
is
an
example
to
work
through,
because,
basically
because
what
happens
is
the
rc
gets,
the
draft
of
the
rc
gets
de-sugared
into
you
know
into
this
ampersand
into
this
call
to
the
draft
method.
So,
from
the
compiler's
point
of
view,
it's
a
borrow
of
the
variable.
B
Happening
is
we,
like
you,
can
kind
of
show
the
capturing
you
can
show
a
few
things
here
right,
like
first,
it
de-sugars
to
a
borrow
of
a
dot
b
which
maybe,
if
it's
a
move,
closure
that
passes
through
a
reference.
I
don't
know.
Maybe
you
can
show
that
then
the
capturing
reference
and
move
context
might
apply
in
that.
B
A
Second
thing
we
wanted:
our
discussion
is
related
also
related
to
the
edition
guide
creator
and
that
we
were
we're
those
discussions
about
so
one
thing
that
we
have
talked
about
was
annotating
the
raw
standard
library
with
insignificant
destructors.
So
how
do
we
want
to
go
about
that?
A
Is
there
like
what
kind
of
formal
process
or
a?
How
do
we
plan
on
documenting
all
of
that
b?.
B
I
think
this
would
also
be
good
material
to
include
in
the
guide
and
possibly
the
reference.
I
think.
A
Is
that
something
is
that
just
okay,
sorry.
B
B
C
B
You
know
systematically,
which
may
not
be
that
bad.
There
may
not
be
that
many
or
else
we
another
approach
is
we
turn
on
the
lint
on
the
compiler.
C
B
C
B
I
think
what
I
would
do
is
start
with
the
easy
ones
the
collections
run,
the
lint
on
the
compiler
and
see
what
you
get
and
see
if
anything
sort
of
jumps
out
at
you
as
like.
This
is
not
just
freeing
memory,
but
it's
still
seems
insignificant.
B
Sort
of
my
goal
here
is
like
before
we
we
probably
do
want
to
go
through
the
drop
pimples
one
by
one
eventually,
but
before
we
do
that,
it's
probably
a
good
idea
to
have
an
idea
what
the
rules
are
that
we're
looking
for.
So
we'll
have
to
do
it
more
than
once.
B
B
No
yeah,
I
was
thinking.
I
know
that
some
of
the
iterators
like
drain
or
into.
D
C
B
A
It
might
be
a
good
idea
to
get
first,
just
we
are
planning
on
doing
going
with
the
strategy.
A
A
A
A
A
So
that
was
yes,
this
function,
what
gets
captured
by
this
function,
at
least
from
in
terms,
is
so
we're.
Looking
at
this
lawyer,
which
is
over
here,
which
is
like
which
includes
this
nasty
enclosure
within
it
package
id
coin,
filter
unit
for
and
self
get
captured
by
this
lawyer
what's
interesting
is
before
the
feature.
A
A
Yes,
so
I
do
not
know
too
much
details
about
that,
but
what
what's
the
difference
is
this
just
the
size
of
the
pointer?
That's
different
now
because
function
versus.
B
B
A
A
A
B
Yeah-
and
you
could
just
kind
of
strip
them
all
and
you
would
get
back
to.
However
many
there
are,
you
could
strip
them
and
you
would
kind
of
get
to
the
older
semantics.
B
A
So
like
this
is
the
new
one
right,
so
we
had
so
we
had
a
reference
to
our
rough.
Amber
st,
like
we
have
t,
is
where
the
den
function
pointer
is
right.
B
A
A
B
A
B
A
B
B
B
B
A
A
D
B
Was
trying
to
think
if
there
was
some
way
to
get
the
closure
bigger
by
dropping
stars?
But
I
don't
think
so
because
you
can't
start
through
like
basically,
you
can
have
a
thin
pointer
to
a
fat
pointer
like
we
have
now,
and
you
can
start
through
the
thin
pointer.
But
you
can't
have
a
fat
pointer
to
a
thin
pointer
like
it's
not
a
thing.
B
Or
at
least
you
could
but
or
if
you
did,
it
would
have
to
be
like
an
overloaded
draft
or
something,
and
we
wouldn't
do
it
anyway.
So
all
right,
so
it's
strictly
going
to
make
your
closures
smaller.
It
might
make
them
marginally
slower
at
run
time.
There's
an
extra
load.
D
A
So
there
isn't
too
much.
At
least
this
was
what
I
did
back
in
november
december,
so
this
was
whatever
our
closure
restriction
was
and
we
remove
our
trailing
drops.
B
A
B
A
It's
it's
an
optimization!
Yes,
so
we
have
this
okay,
so.
A
Okay,
yes,
now
I
want
to
talk
about
profiling,
generics.
A
How
worth
it
it
is,
so
I
wanted
to
do
that
first
and
I
once
I
did
send
a
message
about,
though
I
probably
should
have
learned
something.
Also,
I'm
sharing
wait.
What
am
I
saying
right
now
I'll
share
this,
so
where
was
I
think,
david
replied
to
this
a
little
bit.
Give
me
one.
Second,
I'm
trying
to
look
through
it.
Okay,
yes!
A
So,
okay!
I
don't
see
this
here.
A
B
A
B
A
Okay,
so
that,
if
that's
the
case
and
this
might
be
doable
because
what
happens
is
so
I
have
two
different
types
right.
I
have
the
type
after
the
closure,
and
I
have
the
type
before
the
employer.
So
before
is
fine,
because
it's
sort
of
what's
currently
in
how
the
data
is
pipeline,
but
the
the
way
the
polymorphism
code
ends
up
working
as
and
I
do
not,
it
depends
on
the
def
id
and
everything
is
it?
Does
all
the
calculations
based
on
def
id,
so
uh-huh.
A
B
Okay,
I
think
I
understand,
I
don't
think
this
is
at
all
relevant.
I
think
you
could
just
comment
that
code
out
for
now.
A
B
D
D
B
A
A
B
You
could
ask
david
t.w
co
if
there's
an
easy
way
to
disable
polymorphism,
there
might
be
a
zed
flag
or
something.
B
A
B
I
see
your
point
yeah
yeah.
We
don't
want
that.
We
want
it
to
be
the
standard
one.
Let
me
look
real
fast
at
that
polymorphous
code.
B
B
Uh-Huh,
so
you
can
actually
disable
polymorphization
with
a
command
line
flag.
If
you,
if
you
go
to
instance.rs.
A
B
C
A
A
That
makes
sense,
and
is
there
an
easy
way
to
do?
Well,
I
can
probably
look
into
this.
I
forgot
and
I
might
have
of
where's
that
function
of
creating
an
instance
within
the
sorry.
Where
does
that
go
sorry?
I
will.
A
It
was
the
name
of
yes,
this
one
create
fm
item.
Is
there
a
way
to
create
an
instance
over
here
of,
like
a
type
that
I
want,
like
instance,
on
the
fly
like
right
now?
Instance
is
positive,
but
I
would
have
to
create
an
instance
myself
before
so
I
need
an
instance
of
the
type
that
is
before
and
an
instance
of
the
type
of
the
closure
that.
A
A
So
wait
doesn't
polymorphis
remove
and,
like
put
so
at
least
when
I
did
this
a
couple
days
ago
again,
I
would
probably
change
what
I'm
sharing
again
is.
I
was
getting
the
same
issues
if
I
did
not
call
polymorphis
on
like
as
I'm
not
okay
I'll
share
my
screen.
A
Sorry,
I
like
this
in
two
different
places,
but
so
what
I
had
in
earlier
was
I
would
polymorphize
the
instance
and
I'll
read
the
type
of
the
instance
and
do
the
size.
I
would
not
do
this
for
new
the
new
instance,
because
I
did
not
have
the
right.
It's.
B
A
So
I
will
end
up
getting
the
same
error
as
before,
which
is
failed.
I
do
not
know
these
types
and
therefore
I
can't
give
you
these,
like
the
size
of
the
player.
B
A
New
tie
is
the
so
I
create
two
okay,
so
in
write
back
or
like
in
type
check,
I
create
the
closure
type,
which
is
would
be
after
the
feature
I
just
stored
that
I
just
create
that
as
a
like,
I
create
a
new
closure
type
and
store
that
information.
What
would
the
type
have
been
if
the
feature
was
enabled
and
I'm
accessing
that
type
here.
A
B
I
see,
I
wonder
if
that's
causing
a
problem
because.
B
A
A
My
question
is
even
if
we
do
that,
nowhere
in
the
pipeline
am
I
saying
okay,
these
are
the
concrete
types
that
are
associated
with
that
closure,
because
if
I
have
a
function,
which
is,
if
I
have
a
generic
function,
that
contains
a
claudia
there's
only
at
least
oh.
A
B
D
B
A
A
A
All
right,
yeah.
A
B
A
A
No,
I
if
that
one
does
not
work
at
least
so
over
here.
In
my
implementation
I
had
vertical.
I
did
remove
it,
one
second
yeah.
So
in
my
implementation,
I
do
this
review
all.
A
I
get
this
normalizing
erasing
errors
thing
when
I
do
that.
Well,
it's
probably.
A
B
Yeah,
I
don't
know,
but.
A
B
B
B
Might
get
confused
fair.
A
Enough
makes
my
life
makes
a
little
bit
of
the
type
check
code
a
lot
more
well,
not
a
little.
It
makes
it
a
lot
cleaner
to
see
what's
happening.
A
I
I
can
just
get
it
out
of
the
instance
that
is
over
here,
because
the
parent
stuffs
for
the
both
new
and
also
here
are
still
the
same.
So
it
doesn't
matter.
B
D
B
A
Duple
is
the
percentage
increase,
might
look
different
because
right
now
the
closure
size
probably
also
includes
the
size
of
the
chlorine
coin
and
the
other
thing
or
does
it.
B
B
If
you
look
at
the
layout
code,
I
I
bet
you
it's
pretty
much.
A
It's
and
okay
suppose.
Maybe
this
one
is
this
one
or
yeah.
A
A
B
Great
yeah
or
next
week
I
might
not
be
able
to
make
our
meeting,
but
we
can
discuss.
B
B
Do
make
the
flag,
I
think
that's
the
first
thing
I
would
do
both
because
you
probably
want
this
code
to
be
behind
a
flag,
but
also.