►
From YouTube: 2021-01-15 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
All
right
so
recording
started.
I
will
paste
the
recordings
here.
I'm
now
committed
by
youtube
evidence
yeah.
So
an
answer
to
your
three
questions.
Is
there
something
that
needs
to
be
prepared
for
the
laying
team
meeting?
Yes,
I
think
you've
actually
already
done
the
work,
but.
A
Discuss
the
agenda
and
narrow
it
down.
Yes,
I
made
a
document
already.
Let
me
find
it
and
I
I
think
you
also
made
a
document.
B
B
A
Yeah,
I
think
we
should
definitely
talk
about
this.
I'm
trying
to
decide
the
way
to
frame
this
meeting.
B
Put
some
bullets,
do
you
want
to
put
the
stranger
on
your
end
or
so
that.
A
I
probably
didn't
give
you
permission
to
share
so
I'll.
Just
do
it
on
my
side.
Let
me
move
it
to
its
own
window.
A
B
A
See
yeah,
I
was
sharing
the.
I
think
that
was
the
wrong
sorry.
Zoom.
There
we
go
now.
You
should
see
it
all
right,
so
what
I
thought
would
be
useful.
Maybe
this
won't
be
the
format
of
the
doc
in
the
end,
but
it'd
be
nice.
If
you
and
me
could
put
some
bullets
that
summarize
the
rules
as
implemented
today,.
B
Do
you
just
want
to
copy
the
topic?
Sentences
from
my
document
might
just
be
quicker
sure
so,
like
I
have.
A
A
B
All
right
so
feature
sorry
yeah.
I
can
drive
filler.
I
can
pull
in
the
details
from
I
guess,
or
something
but
yeah.
This
is
this.
We
can
do.
A
Right,
the
thing
I
wanted
to
add
is
there's
something
here
that
we,
what
was
it
around
if
you
capture.
B
B
B
The
document
here,
but
basically
scroll
up
a
little
there's
some
place
where
I
say
an
rfc
comment.
I
think
it's
in
one
like
set
like
point
one
so
over
here
in
the
first
example
that
I
have,
which
is
the
non-copy
type.
B
So
if
we
were
to
do
star
x
dot
a
in
the
first
example,
we
will
end
up
copying
the
whole
one.
Second
I'll
open
that
up.
B
B
Also
it's
on
the
match.
Now
it's
stacked
to
the
issue
that
it
was
related
to
so
one
second
I'll
try
it.
A
Out,
if
you
can
find
it
it'd
be
great.
Let's
put.
B
A
B
B
You
should
have
it
right.
Yes,
you
have
okay,.
A
B
My
document,
okay,
so
let's
see
I'm
going
to
share
this
on
zula
just
for
that,
it's
fine.
A
B
Yes,
this
just
search
for
initial
proposal
or
something
it's,
it's
called
possible
extension.
If
you
search
for
this
in
the
document
below
yeah
that
part.
B
A
A
Why
don't
we
move
this
content
yeah
roughly
here?
Actually,
let's
get
the
mark
down.
B
B
A
A
Reference
on
roughness
hold
on
a
second
I'm
just
thinking
in
my
head
here,
so
it
is
in
a
way
specific
to
move
closures,
because
otherwise,
if
it's
not
a
move,
closure.
A
Yeah,
so
it's
really
re-borrowing
give
me
one
second
here.
Oh
sorry,
okay,
here
you
go
no
problem.
Okay,
re-borrowing
captures
for
move
closures;
these
that
makes
them
so
basically,
this
is
an
extension
to
the
rules
that
makes
them
behave
a
bit
more
like
regular
closures.
A
And
now
I
don't.
B
Yeah,
just
one
quick
thing
is
roxanne
waiting
on
the
room.
A
Zoom
is
not
very
aggressive
about.
Oh
there,
it
is
roxanne
entered
the
waiting
room,
admit.
A
B
A
B
No
no
first
first
example
in
the
dock.
Yes,
so
you
basically
explained
the
whole
thing
there
as
the
option.
One
like
we
talked
about
the
referent.
B
B
B
Yeah,
but
the
point
of
using
something
like
this
was
we
can
emit
things
that
are
on
the
stack.
Sorry,
we,
the
closure,
can
move
things
that
are
on
the
stack
and
not
like
the
stack
frame.
Sorry
not
like
right
so.
A
This
would
mutably
reference
s
dot
x.
Yes,.
B
B
A
B
I
do
so.
If
you
go
again,
I
think
it's
in
the
section.
Migrations
might
be
easier.
If
you
look
at
the
yeah
our
scroll
down
movie,
it
is
somewhere
our
scroll
up.
Sorry,
I
don't
see
that
if
I
look
on
mine
one
second.
A
So
why
don't
we
just
pull
this
over.
A
B
B
B
A
B
So
this
is
something
as
well.
We
need
to
discuss.
B
So
yeah,
if
you
have
time
I
want
to
go
with
this,
I.
B
A
A
B
A
Yeah
exactly
I'm
more
interested
in
this
question,
which
is
like
a
policy
question.
A
So
this
is
the,
and
these
are
like
these
are
bugs
right,
and
this
is
migration.
This
is
migration.
These
are
notable
bugs
and
limitations.
B
So
this
one
was
like,
since
so
the
okay,
so
in
type
check
what
happens,
is
index
projections
always
show
up
as
a
trade
implementation,
and
until
we
hit
right
back
so
since
it's
a
trade
implementation,
we
like
oh,
the
base
like
needs
to
be
completely
captured,
even
though
the
index
trade
might
be
implemented
on
for
an
array,
in
which
case
we
can
just
have
an
index
project.
Yes,.
B
A
Know
what
I
think
myself,
I
probably
I
guess
we'll
just
leave
it
like
this
yeah,
okay,.
B
B
And
we
might
go
over
the,
I
think.
A
B
We
can
oh,
we
can
do
it
in
three
steps
right.
We
can
say
mostly
two
steps
for
structures
in
standard
lip
that
only
free
up
memory.
We
will
not
recommend
migrations
and
I
guess
the
step
one
would
be
if
there's
a
path
starting
of
a
capture
that
isn't
completely
captured
but
implements
drop,
will
not
be
captured
so
well,
we'll.
B
A
B
B
B
B
B
B
A
There
are
a
few
observations.
One
is
let
x
equals
x
is.
A
B
A
So
I
think
that
also
is
relevant
like
up
here
right.
In
other
words,.
A
B
They're
not
unprotected,
I
don't
so.
I
guess
I'll
bring
up.
One
thing
that
I
was
thinking
about
matches
and
I
don't
know
how
much
time
we
have
left
to
go
or
all
of
it
later.
But
if
we
do
the
fixing
the
match,
as
we
were
talking
about,
it
is
possible
that
the
size
was
pretty
dramatically
like
30
x.
B
A
It's
basically,
I
think
now
that
you're,
I'm
backfilling
what
you
said,
and
I
think
I
understand
what
you're
saying.
But
if
you
have
a
big
match,
it
could
create
a
ton
of
paths
from
the
different
arms
which
could
in
turn,
lead
to
a
giant
blow
up
in
the
overall
size
of
the
closure.
Yeah,
especially.
B
B
It
is
relevant
because
we
have
a
bug
file
saying
so,
if
we
okay,
so
the
problem
is,
if
we
have
let's
say,
match
x,
and
the
only
thing
we
match
on
is
an
underscore
outside
the
closure
that
never
creates
a
read
an
actual
read,
but
today
it
will
because
we'll
end
up
moving
it
when
we
create
the
flower-
and
I
have
another
concern
around
that
so
patterns
are
a
little
gimmicky.
Roxanna
started
working
on
the
marble
stuff
that
we
had
discussed
about
using
place
builder,
and
I
realized
that
that
implementation
might
not
work.
B
B
Have
a
box
example
there
as
well?
Yes,
we
don't
as
long
as
it's
linked,
I
you
might
have
linked
the
wrong
one.
So
again,
it's
which
one
are
you
looking
for.
A
A
B
A
B
A
A
Yep
right,
this
is
kind
of
the.
A
Yeah,
it's
fine
they'll,
be
able
to
figure
it
out.
A
I
think
what
you
were
just
mentioning
we'll
get
to
it,
but
right.
The
point
is
where
we
may
now
cap
capture
many
more
paths
than
we
used
to
inflating
the
size
of
closures,
also
performance.
B
A
B
Yes,
yeah,
that's
the
bug,
but
it
oh
actually.
Can
you
undo
the
sorry
last
two
things,
so
this
is
around,
so
no,
I
think
this
is
a
little
different,
so
that
one
is
a
bug
which
is
a
compiler
bug,
the
first
one.
The
second
one
is
that
it
is
possible
that,
especially
in
case
of
the
match
example
that
even
though
nothing
is
used
from
the
match,
the
we
still
borrow
it
so
it
it
represents
two
different
things.
I
think.
B
Oh,
oh,
I
don't
know
if
that
makes
sense,
so
one
is
so
the
one
one
is
like
in
in
the
match.
Example,
at
least
since
nothing
is
used
from
it.
We
still
capture
the
whole
variable.
B
The
first
problem
is
that,
even
though
x
is
mentioned,
so
I
guess
in
your
second
so
you're,
the
second
snippet
that
you're
highlighting
right
now,
the
first
and
the
last
one
represent
two
different
problems.
One
is
that
would
not
be
x
would
not
be
captured
on
that
line,
and
that
will
create
a
compiler
issue,
because
that
will
create
a
nice
and
the
last
line
the
problem
is
x
will
be
captured,
even
though
it's
not
used,
which
is
a
land
team
issue.
B
I
guess
in
some
sense,
or
at
least
that's
my
kind
of
understanding
where,
like
one
creates,
an
internal
compiler
rather
today.
This
is
true.
This
is
true,
because
we
don't
have
a
fix
in
here,
or
can
we
do
it
as
a
another
question
we'll
get
to
in
a
minute,
the
other
one
is
should
x,
be
captured
in
case
of
a
scrutiny
and
match.
B
Yes,
now,
okay,
so
I
guess
this
is
kind
of
a
good
point
for
me
to
segue
into
at
least
from
the
compiler
side
of
my
problems.
Okay,
sorry,
so
the
the
main
issue
that
we
see
here,
at
least
from
a
compiler
standpoint,
is
that
x
needs
to
be
captured,
because
we
need
a
fake
read
of
x
in
mer
to
be
able
to
handle
this.
A
This-
let's
just
keep
this
section
since
it
seems
like
this
examples,
are
useful
for
the
laying
team
and
then
we
can
move
on.
I
think
we're
done
with
this
is
our
agenda.
Now
we've
got
plenty
to
cover,
we
probably
won't
get
through
all
of
it.
Current
status
we
could
put
a
little.
The
only
thing
missing,
then,
is
this:
okay
can.
B
Okay,
so
I'll
share
this
doc.
I'll
put
this
in
an
issue,
so
this
is
the
merc
stuff
that
murph
built
so
roxanne
started
this
working
on
the
refactoring
that
we
talked
about.
We
use
place
builder
as
many
places
as
possible
in
the
match
code
for
sorry
as
many
places
as
possible
in
the
match
code,
so
that
essentially
we
can
support
some
of
the
error
cases
that
we
just
saw
that
we
were
talking
about
so
from
a
compiler
perspective.
B
This
is
actually
going
to
be
interesting,
slash,
I
am
going
to
say
hard
right
away.
So
let's
consider
this
very
basic
example
where
we
have
this
kind
of
two
tuples
and
we
don't
match
on
anything.
The
word
that's
generated
for
this
has
two
sort
of
fake
reads.
So
one
is
a
fair
fee
to
match
on
this
side
so
that
we
can
just
make
sure
the
pattern
matching
happens,
which
is
fine
for
now
in
this
the
second
one
happens
over
here.
B
B
We
are
not
able
to
create
a
place
for
t
if
we
do
if
we
do
not
capture
t,
because
it's
not
being
used
because
it's
not
being
captured
by
a
player.
I
don't
know
if
that
made
sense.
B
B
B
And
the
issue
will
also
exist,
for
I
think
if
we
had
a
light
underscore
equals
because
again
we
would
have
introduced
a
fake
read.
We
need
a
fake
read
of
the
match
place
in
this
example
that
doesn't
quite
work,
because
it's
just
an
r
value,
but
if
we
were
actually
matching
on
a
place
that
would
have
been
like
ice.
A
B
A
Like
to
fix
it
a
different
way
or
like
I
have
a
blog
post,
I
can
point
you
at
that
gives
the
background
here.
If
you
want
to
get,
you
know
deep
dive,
I'm
trying
to
figure
out
how
how
how
deep
we
have
to
go.
B
B
If
so,
if
we
can
do
something
like
that,
then
we
essentially
what
we
do
is
we
I
oh,
I
might
have
it,
but
basically
I
probably
wrote
it
somewhere,
but
yeah.
B
A
B
B
And
I
guess
one
more
thing
so
roxanne
did
a
partial
implementation
where
not
everything
has
been
changed
to
either
place
builder,
and
there
is.
We
already
have
started
seeing
some
degree
of
perfect
regression.
B
A
B
A
Shouldn't
be
able
to
get
here
basically,
but
you
could
because
the
only
reason
you
couldn't
be
able
to
get
here
is
that
you
were
accessing
this
uninitialized
value.
What
we,
what
we
kind
of,
but
but
the
way
that
we
represent,
that
is,
was
not
causing
a
problem.
So
we
added
this
fake,
read
to
say
like
the
thing
you're
matching
on
must
be:
initialized
is
basically
what
it's
asserting
and
what
we,
I
think,
the
right
fix
that
my
blog
post,
which
I
could
look
for
if.
A
To
read
the
background
goes
into:
where
is
it
okay,.
A
A
And,
let's
see
is
that
the
notation
I
used?
Yes,
it
is
okay
and
the
idea
would
be
this
is
kind
of
explicitly.
Where
was
I
here,
we
go
explicitly
asserting
the
effect
of
the
never
pattern
is
kind
of
to
say.
A
If
you
get
here
at
runtime,
it's
kind
of
hard
to
describe
but
yeah,
it's
asserting
that
there's
a
that
that
there's
an
uninitialized
value
here
and
therefore
you
shouldn't
get
there
at
runtime.
But
if
you
did,
you
could
think
of
it
like
a
panic
or
something
or
only
it
won't.
Actually
panic
and
the
point
would
be
now.
If
we
did
this,
we
wouldn't
have
no
arms.
A
We
have
one
arm,
which
is
this
never
arm
and
that
that
never
arm
would
probably
add
the
fake
read,
which
would
in
turn
be
considered
a
read
by
expression,
use,
visitor
and
so
forth,
so
like
it
would
all.
B
A
Of
work,
the
problem
here
is
that
the
read
is
we
don't
have
an
explicit
representation
of
this
has
to
be
initialized
at
this
point,
and
there
are
some
subtle
things
around
unsafe
code
to
talk
about
in
the
blog
post,
where,
like
it
conceivably,
if
you
you
know,
depending
how
you,
depending
without
without
some
way
to
say
this
explicitly,
there's
some
like
certain
things
could
be
ub
or
not
it's
kind
of
hard
to
say
so.
A
A
A
Yes
and
the
point
is
we
don't
want
this
to
compile
either
I
imagine,
and
if
so,
if
we
did
nothing
else,
the
problem
will
be
when
you
come
to
to
insert
that
fake,
read,
you're
going
to
have
a
place
builder
that
is
not
resolved.
B
A
A
A
That
this
is
not
that,
oh,
I
think.
B
A
A
B
A
B
A
Yeah
I've
seen
it
used.
I
just
don't
it's
not
like.
We
have
a
formal
definition,
so
I'm
not
sure
if
we're
using
it
with
the
same
okay
by
scrutiny,
you
mean
this
expression
here,
that's
in
the
match.
A
A
Okay,
so
so
yeah,
you
could
do
something
like
this.
If
the
match
would
introduce
a
fake,
read
and
then
separately,
when
a
closure
is
constructed,
insert
fake,
read
for
every
upvar
mentioned,
in
addition
to
its
captures.
B
A
A
B
A
Okay,
fine,
let
match
scrutinees
fake
reads:
this
part
is
all
the
same,
and
then
here
when
a
closure
is
constructed,
insert
fake,
read
for
every
for
every
let
match
scrutiny
in
place,
and
this
can
be
consolidated
a
little
bit
and
you
can
well.
You
could
do
this,
like
you
know,
or
at
least
let
match
scrutinies
that
are
not
otherwise
captured
right.
Yes,.
B
I
so
I
just
looked
at
the
document
and
realized.
One
thing
I
measured
on
this
is
so
there's
again
possibility.
So
if
we
scroll
up
a
little
where
I
have
some
concerns
right
above
the
performance
section,
so
we
have
a
broken
assumption
that
multivariants
are
captured
completely.
So
we
probably
would
want
to
match
on
the
type
of
the
scrutiny
to
see
if
it's
a
multi-variant
enum,
because
otherwise.
A
B
What
will
happen
is
each
of
these
places
will
be
captured
individually.
So
if
you
look
at
the
example
above
so
when
I
do
match
x
in
the
first
thing,
we
I
get
two
places
that
are
captured,
which
are
both
for
the
sum
enum
a
and
some
enum
b.
B
A
Yeah,
the
problem
seems
to
be
that
there's
an
implicit
read
of
the
discriminant
happening
and
I
think
in
mira
this
is
actually
made
explicit
or
I
forget,
but
this
was
something
else
that
motivated
us.
We
had
some
similar
reasoning
and
fake
reads,
although
it,
I
think
fake
reads,
were
part
of
how
he
fixed
this,
but
I
have
to
look
but
yeah
and
that's
not
reflected
in
the
up
far.
B
A
A
No,
no,
I'm
not
disputing
that.
It
doesn't.
I'm
just
saying
I
think,
that's
a
bug.
Oh
okay
and
that's
probably.
A
B
B
A
Pattern
that
has
to
that
has
a
discriminant,
so
that
would
mean
that
would
mostly
mean
multivariant
or
like
pattern
bindings
like
this
they're,
what
you
call
it
refutable,
but
yeah
also,
I
guess
constants
and
other
things
right.
B
A
Yeah,
I
think
that's
just
that
it
needs
more
reads,
so
we
should
add
that
to
must.
B
A
B
B
Have
a
match
or
two
much
arms,
and
then
we
want
to
read
and
if
you
have
a
single
match
arm
we
want
to.
If
you
have
a
single
match
arm
it
either
is
an
underscore
or
if
it's
a
refuted,
irrefutable
pattern
that
should
really
be
converted.
But
again
you
can
write
it
like
like
if
you
have
like
yeah
some
something
so
maybe.
A
B
The
fakery,
okay,
I
thought
it
okay,
I
thought
we
didn't
want
to.
I
can't
see
your
highlights.
It's
a
little
sorry
confusing.
What
do
you
mean
by
addressing
okay
yeah?
So
we
need
fakers
and
we
need
the
match
in
case
of
irrefutable
patterns.
B
A
What
I
meant
was
if
we
do
the
match
in
case
of
if
we
record
reads
for
patterns
with
discriminant
tests,
then
if
you
scroll
up
the
thing
that
you
highlighted
as
the
amount
of
information
we
store
for
captures
will
grow.
Oh
that
that.