►
From YouTube: 2020-11-05 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).
A
Yeah
so
say
again,
the
main
things
are,
I
guess,
kind
of
announcements
or
section
would
be
I'll
me
or
roxanne
will
try
to
get
the
effects
for
the
upper
ties
and
yeah.
I
think
you're
right
about
just
using
double
up
for
as
much
as
we
can
like,
and
I
think
last
time
we
were
trying
to
do
that,
but
we
forgot
to
remove
our
call,
which
ended
up
in
the
regression
so
yeah.
We
should
be
fixing
that
soon.
A
B
Yeah
never
mind
nothing.
No,
that
sounds
good.
I
was
reviewing
one
of
the
pr's
that
landed
tonight.
I
saw
a
funny
funny
pattern
that
I
was
thinking
about
raising
with
you,
though,
I'm
not
actually
sure
if
it's.
B
A
All
right,
let's
do
that
then
I,
what
I
did
was
I
added
another,
commit
to
the
min
capture
so
that
it
basically
enabled
well
it
does
two
things.
A
It
enables
the
feature
by
default
or
more
like
it
just
removes
the
part
of
the
code
that
handles
if
the
feature
gate
is
not
set,
it's
just
like
a
very
small
snippet
and
updated
the
test
cases
so
that
the
light
underscore
pattern
becomes
less
unused
sort
of
so
like,
instead
of
underscore
becomes
underscore
x
in
the
three
test
cases
that
fail
and
bohr's
try
post
on,
basically
all
architectures
and
stuff.
B
A
B
There
an
open
pr
for
this.
Yes,
I
can
send
a
link.
A
Yeah
this
is
this
is
mostly
from
okay.
I
send
it
on
zoom,
oh
well,
that
was
a
bad
way
of
sending
it
never
mind.
I
forgot
messenger
like
that,
all
right,
that's
the
beer!
A
So
essentially,
there's
this
thing
at
the
end
like
the
burst
test,
which
does
that
update
some
ui
tests,
because
expert
user
runs
in
a
different
order,
a
little
bit
then
upwards,
not
in
in
instead
of
like
the
intro
visitor
that
we
have
so
when
we
use
the
new
analysis
book.
A
B
B
Yes,
it's
cool,
so
the
tests
look
good
yeah,
I'm
just
skimming
most
of
this
pr
success.
A
lot
of
it
is.
A
Well,
90
yeah,
it's
like
two
or
three:
it's
like
a
firms.
Mention
sorry
affords
our
artists
and
expertise
are
the
ones
that
have
like
major
changes.
Everything
else
is
just
and
a
little
bit
on
lightness,
because
that
required
a
bit
more
of
okay.
B
I
have
one
one
question:
I
see
that
you
modified
issue,
two,
nine
nine
four,
eight.
A
The
reason
I
did
I
did
that
one
was
so
that
I
can
run
all
the
test
suite
instead
of
removing
tests,
because
I
didn't
want
it
to
fail
at
the
very
start.
If
you
look
at
it,
it's
like
in
this
pr.
It's
only
part
of
the
last
comment,
which
is
only
to
run
boost
on.
B
A
Yeah
because,
like
we
locally
only
run
like
kind
of
stage
one,
and
it
just
allows
us
to
run
everything.
B
B
I
am
the
idea
of.
A
Yeah,
I
think
so
I
I
feel
like
I
think
you
should
drive
this
one,
because
I
I
have
some
ideas,
but
I
think
you
probably.
B
Taking
notes-
and
I
guess
I
can
should
I
share
it-
I'll
share
this
window,
so
it's
in
the
recording
and
everything
you
see
this.
I
guess
so,
let's
see
the
let
underscore
equals
x
problem.
A
B
B
A
B
It's
just
as
simple
as
this
right
to
start.
Yes
and.
B
The
challenge
here
is:
if
we
don't
capture,
we
don't
see
a
read
or
other
use
of
x,
which
we
don't
in
this
example,
then
it
will
not
be
added
to
the
capture
list
in
any
form.
A
I
have
one
question
around
this:
what,
if
like
in
this
case,
we
need
x
to
actual
x
would
have
technically
been
moved.
Okay,
actually
never
mind.
I
was
going
to
say
that
this
might
like.
If
there
might
be
problems
when
x
is
referred
as
a
mutable
or
immutable
references
are
being
moved,
but
that
doesn't
matter
we
can.
We
just
need
to
read.
We
don't
actually
need
to
move
it
here.
B
Right
this
is
not
a
move,
closure
and
so
on,
and
so
now
the
problem,
as
I
understand
it,
the
problem
is
that,
like
that,
in
and
of
itself
is
okay,
there
is
a
backwards
compatibility
question,
but
that's
a
separate
thing.
B
Right,
yes,
so
the
challenge
is
in
t
here:
construction
when
we
build
or
when
we
build
the
t
here,
we
need
to
translate,
let
underscore
equals
x
into
something,
but
we
can't
represent,
or-
and
normally
we
translate
up
bars
like
x,
into
expressions
that
reference
closure
fields.
B
Self.X
right
or
yeah,
but
there
is
no
field
and
there
is
no
expression
we
can
generate
that
represents
x.
In
this
example.
Oh
sorry,
let
me
see
who's
calling
me
here.
Oh
you
hold
on
one.
B
B
B
Okay,
so
I
lost
track
of
where
it
was
all
right
yeah.
This
is
the
fundamental
problem
we
can't
generate
here
expression
at
the
moment.
B
B
Actually,
there's
a
there's
a
another
thing
worth
talking
about,
but
go
on.
Yeah.
A
So
the
failure
that
happens
happens
in
the
build
it
doesn't
happen
in
the
marble
dhir
folder.
I
just
want
to
make
sure
that
that
is.
I
don't
know
if
it's
invoked
when
the
tour
is
built
or
it's
invoked
when
we
convert
a
third
into
mark.
So.
A
A
A
A
Sorry
one,
second,
sorry,
can
you
go
back,
I
I
was
trying
to
find
the
no.
It
does
not
ice
around
here
at
ice
around
and
merville.
B
B
B
B
No,
it's
going
to
get
none
and
then
it's
going
to
treat
it
like
a
local
variable,
that's
actually
local
to
the
closure,
and
then
it's
going
to
ice
in
mirror
construction
later
on,
because
there
is
no
such
variable.
Okay,
that's
fine,
but
I
think
the
problem
is
really
here,
even
though
it
doesn't.
Okay.
B
B
You
know
we
can't
build
this
kind
of
expression
when
there's
no
field
to
reference,
necessarily
that's
one
challenge
yeah
so
like
hold
on.
Let
me
put
a
link
here.
A
I
think
we
will
have
a
similar
problem
in
liveness
analysis
as
well,
because
the
thing
that
you
were
suggesting
yesterday
to
see-
if
let
me
just
give
me
one
second
I'll
point
it
to
that-
it
might
be
there
to
explain
that
way.
A
But
basically,
what
I
did
was
in
lightness
there's
a
part
of
it
again.
It
checks
for
upwards
basically
for
to
check
if
things
are
being
used
correctly
or
not
and
respect
so.
A
Where's
the
zoom
chat
there.
It
is
so
yeah
send
it
and
zoom,
but
basically
that
as
well,
we
kind
of
have
this
thing
where
and
basically
we
skip
accessing
the
variable.
A
But
this
would
require
some
interesting,
more
complicated
way
of
checking
if
the
place
is
being
used
or
not
in
the
future.
B
B
There's
one
other
looking
a
little
bit
forward.
We've
talked
about
this
before,
but
before
we
get
into
like
how
we
might
solve
this,
I
just
want
to
say
that
if
we
had
a
case
like.
A
B
We're
gonna
have
a
similar
problem
in
that
or
a
related
problem.
In
that
we
can't
translate.
B
We
expect
to
have
a
field
corresponding
to
x.0
here
right,
so
we
can't
translate
the
here
expression
x
into
a
t
here:
expression
on
its
own.
We
can
only
translate
x,
dot
zero
into
a
t
here,
expression
right.
A
A
B
A
B
B
B
B
And
then
and
then
you
could
add
like
98
or
something
like
upvar,
not
yeah,
like
non-existent
up
bar
or
something,
and
we
could.
A
B
Local
partial
path
alone,
or
on
this
later
so
the
idea
of
non-existent
upvar
would
be
that's
what
we
would
return
in
this
case.
So
when
we
translate
x,
we're
not
actually
going
to
build
an
expression,
we're
going
to
return
non-existent
up
bar,
which
would
then
whoever
calls
convert
var
like
this
function.
B
B
I
don't
know
like
it
might
get
tricky,
but
let's
assume
it
works,
we
propagate
it
up
and
the
idea
is
now
what's
gonna
happen
is
some
of
these
some
of
these
other
places.
Let
me
find
a
simple
example
like
okay,
here's,
a
binary
operator
right
and
first
it
converts
the
left-hand
side
to
an
expression,
and
then
it
converts
the
right-hand
side
to
an
expression.
B
These
actually
want
real
expressions.
So
at
this
point
you
would
have
to
have
some
kind
of
assertion
that
says
I
should
have
gotten
this
variant
at
this
point:
yeah
yeah
and
if
not
that's
some
kind
of
bug
and
you
can
ice
so
so
the
two
ref
function,
let's
see
so
convert
var
and
friends,.
B
A
Right,
no,
I
think,
there's
a
statement
kind
like
or
no
okay,
this
converts
to
yeah,
never
mind.
I
think
statement
kind
of
local
conversation.
B
B
A
A
A
Like
we,
okay
does
her
actually
provide
a
no-op
statement
that
can
be
just
put
in.
A
B
Right
that
would
work,
I
think,
that's
the
right
strategy,
the
night,
the
thing
that
we're
assuming
here
is
yeah,
so
we're
assuming
that
if
we
find
a
non-existent
up
far.
A
B
That's
what
this
assertion
is
kind
of
double
checking
like.
Hopefully,
that
assertion
is
correct
if
we
can
come
up
with
an
example
where
there's
a
binding
in
the
pattern
and
there's
no
up
and
the
non-existent
up
bar
would
be
interesting,
but
I
don't
I.
B
Yeah
or
there's
I'm
sure,
there's
some
other
ways
we
can
do
it,
but
the
I
think
that
would
work
and
then
the
reason
I
brought
up
this
looking
forward
example.
Is
that
then,
because
right
now
we're
not
handling
that
yet
right,
but
later
we
may,
we,
I
think,
we're
going
to
want
a
similar
enum
so
and
that
would
be
like
partial
paths.
So
that
would
be
a
case
where
you
know
we
converted
x,
but
we
only
have
a
field
for
x
dot
zero.
B
A
Need
so
since
we
are
capturing
x,
dot,
zero,
we
would
need
a
way
to
capture
x
in
some
capacity
right,
and
I
think
this
is
where
that's
getting
at.
A
B
Actually,
there's
an
interesting
question,
no,
never
mind,
I
don't
think
we
would
like
at
least
the
naive
version
of
the
t
here
code
would
actually
generate
a
field.
We
would
have
no
field
that
corresponds
to
x
right.
It
would
only
have
a
field
that
corresponds
to
the
path,
but
we
still
need
to
return
something
that
starts.
B
That
just
propagates
up
all
the
way.
This
is
a
different
case.
This
is
like
partially
exactly
captured
up
far,
so
that
would
be
a
new,
a
new
entry
in
the
enum
and
it
is
gonna
propagate.
I
think,
in
the
same
way,
like
most
the
same
logic,
most
most
uses
just
assert
that
that
they
got
a
fully
formed
expression.
That's
still
true,.
A
I
guess
my
question
was
less
around
the
pipelining,
this
information
on
the
court
mode
around
building
that
actual
expression.
So
I
just
want
to
make
sure
that
it
is
since
we're
not
capturing
x
in
its
entirety.
B
B
A
Yeah,
I
think
this
is
another
one.
It's
expert
yeah,
so
convert
bar.
We
have
a
convert
up
bar
function,
yeah.
Basically,
my
question
around
here
is
like,
since
over
here
we
start
building
expressions
which
are
which
basically
returns
some
reference
to
x
or
like
whatever
the
upper
we're
capturing.
What
we
discussed
last
time
was
that,
instead
of
doing
that,
we
will
now
also
apply
projections
on
top
of
it.
A
That,
basically,
are
the
projections
of
the
place
that
we're
trying
to
capture
my
question
is:
is
it
like
just
want
to
make
sure
that
it's
fine
to
start
that,
since
x
is
not
captured
completely?
It's
fine
to
capture
start
that
of
expression
of
x
directly
in
here.
B
B
And
so,
when
we
type
when
we,
when
we
type
expression
kind
field
or
when
we
convert
it,
that's
this
code
right,
okay,
okay,
let
me
just
throw
a
link
in
there
for
posterity.
B
B
Yeah
yeah
and
that
invokes
convertvar,
which
today
returns
an
expression.
So
what
I
imagine
would
happen
is
tomorrow.
This
will
return
a
special
particle
which
has
some
information.
I
don't
know
exactly
what
we'll
have
to
figure
that
out
about
the
fact
that
it's
x
and
then
here
today,
this
like
wraps
in
a
expression,
kind
field
tomorrow,
it
would
say
if
we
got
back
a
partial
path
and
adding
x
dot
zero
makes
a
complete
upbar
match.
B
A
Yeah
yeah,
can
you
go
back
quickly
to
the
code
that
we
have
so
again
we
are
creating
this
field
new
with
that
feel
the
next
again
we
at
some.
Oh,
we
don't
yeah,
we,
so
we
still
need
the
lhs
right,
which
is
what.
B
B
And
I
think
it
would
be
something
like
what
this
equal
sign
is
yeah,
it's
probably
not
too
ref,
but
you
know
whatever
it
is
going
to
be
two
exper
blah
blah
blah
and
then
what
did
we
call?
This
enum
know.
B
B
Partial
path,
all
right,
this
is
the
more
interesting
case
where
we'll
kind
of
say:
let's
I
don't
know
exactly,
what's
going
to
go.
B
A
B
B
A
I
am
still
confused,
I'm
sorry!
So,
okay,
let
me
let
me
just
go
through
and
see
what
my
understanding
of
this
code
is.
Okay,
we
start
30
minutes
good.
So
what
are
we?
What
we're
doing
is
we
say:
hey
take
this
place.
This
is
a
field
place.
Give
me
a
partial
convert.
A
Try
converting
this
we'll
try
to
find
the
any
ancestor
of
that
place
in
our
list
of
captured
places,
and
so
yes
we'd
put
that
there
and
if
it's
a
complete
apart,
which
basically
means
the
place
that
we
got
back
did
not
have
any
projections.
Then
we
do
the
return
self
dot
and
we
did
references.
Otherwise
we
basically
escalate
it
up
and
say
some
let
something
else
handle
it.
B
B
B
Let's
do
this,
I
don't
know,
so
let
me
think
is
that
capturing
all
the
things
I
want
yeah.
This
will
be
okay
for
now,
so
there's
two
expressions
here
right
or
we
will
have
two
fields
in
our
closure,
x0
and
x1
and
our
sort
of
capture
table.
I
forget
exactly
how
your
data
structure
looks,
but
I
think
it's
something
like
this.
A
B
Yeah
yeah,
so
so
what
I'm
imagining
now
is
when
we
are
converting
x.0.0.
That
is
here
like
field
zero
field,
zero,
yep,
and
so
the
idea
would
be
we'll
start
here.
It'll
recurse,
it'll
recurse
at
this.
A
B
B
And
now
we
say
x.0.0
we
have
a
field
for
that,
so
we
construct
starself.x00
and
return
that
and.
A
B
A
B
B
Yeah,
because
now
our
captures
x
dot,
one
isn't
really
very
interesting,
but
that's
okay!
Now
our
captures
look
like
this
x0,
just
that,
yes
right
and
so
now
what
will
happen
by
value?
B
B
I
don't
know
why
this
is
jumping
around,
but
there
you
go
yeah.
So
I
think
this
should
work.
What
I
realize
now
is,
as
we
talk
this
through,
is
you
may
not
want
where's
the
enum
blah
blah
blah
blah
blah
blah
blah
blah.
B
B
A
B
Yeah,
maybe
the
only
I'm
thinking
about
there's
one
case
I
wanted
to
think
about,
and
maybe
we
should
just
talk
it
out
right
now,
so
something
I'm
a
little
bit.
Oh,
what
is
going
on
here.
This
must
be
some
wacky
wacky
corner
of
markdown.
I
don't
know
anyway
one
one
example.
I
was
a
little
bit
nervous
about
that.
We
can
talk
about.
Let's
do
it
now,
because
it's
relevant
is
something
like
this.
B
Okay
right
this
should
just
here
we
should
capture,
I
think,
we're
going
to
capture
x.0
and
x.1
yes,
but
we
can't
generate
the
t
here.
B
We
actually
are
kind
of
stuck
here,
because
we
can't
generate
the
t
here
that
we
want
right
because.
B
We're
going
to
have
translating
x
yields
a
partial
path,
but
we
need
to
generate
a
let
like
y
z
equals
translation
of
x
like
we
don't
have
that's
really
annoying,
and
I
don't
know
what
I
think
the
answer
is
to
that.
A
A
I
was
asking
more
okay,
I
guess
question
was
that
the
can
we
not
generate
two?
Let's
convert
this
one,
let's
statement
into
two
in
some
sense.
B
Okay,
sorry
getting
a
lot
of
calls
today,
so
the
problem
here
is,
I
mean
it's
just
a
matter
of
how
we
like
currently
it's
mere
construction
that
does
that
has
the
job
of
taking
a
pattern
and
turning
it
into
statement
like
individual
assignments,
and
you
can
see
that
here
right.
We
have
a
statement,
kind,
let
and
it
takes
a
pattern
and
an
initializer
expression.
B
So
so
this
this
really
gets
turned
into
t
here.
That
looks
pretty
much
exactly
like
it
looks
here
and
once
we
get
the
mirror,
it's
going
to
get
translated
into
y
is
x,
dot,
zero,
but
unfortunately
the
t
here
doesn't
do
that.
So
so
that's
kind
of
a
drag.
I
don't
know,
I
don't
know
what
the
right
answer
is
here
because
so
like
the
wrong
answer
is
to
you
know
solve
this
all
by
the
hacky
solution.
We
talked
about
way
in
the
beginning
of
making
a
false,
read.
B
Yeah,
I
don't
think
that's
making
it
much
harder,
but
it's
true.
Okay,
so
there's
two,
I
see
really
two
yeah
okay.
I
guess
I
see
let's
look
at
the
possible
solutions,
so
you
know
one
of
them
is
mess
up
the
language.
B
By
calling
this
a
read
of
x,
you
know
pro
easy
con.
B
You
don't
want
to
do
that
if
we
can
avoid
so.
The
other
solution
is
that
we
can
kind
of
change
who's
responsible
for
de-sugaring
up
our
fields
and
push
that
a
little
more
to
so
basically
extend
t
here
with
partial
path
and
push
the
upvar
conversion
apart
to
field
conversion
into
mirror
construction
in
a
way,
nothing
changes
or
like
it's
very
similar
to
what
I
wrote
above,
except
that,
instead
of
this
not
being
a
real
expression,
it
would
be
a
real
expression.
A
A
B
B
A
B
Yeah
but
hold
on
a
second,
let
me
let's
first
okay,
so
it's
definitely
an
error.
If
there
are
two
patterns.
B
And
it's
definitely
an
error.
If
you
have
a
binding,
it
doesn't
appear
to
be
an
error
with,
however,
without
a
binding,
so
yeah.
So
what
that
suggests
to
me
is
we
have
to
be
able
to
express
x
also
in
this
position,
so
it's
really
not
just
d
sugar,
but
also
match
and
that's
tricky
for
another
reason,
which
is
that
I
believe
exhaustiveness
checking
operates
on
t
here.
B
If
I'm
not
mistaken,
so
we
don't,
we
really
don't
want
to
be
doing
de-sugaring
like
exhaustivist
checking
has
to
come
before
we
do
sugar,
not
after
and
yes,
yes,
I
think
this
is
not
really
feasible.
Okay,
okay,
that
logic
is
pretty
complicated
and
I
don't
really
want
to
move
it
nah.
That's
that's
fair!
I
don't.
B
So
I
think
that
suggests
we're
gonna
need
to
move
this
stuff
into
mirror,
which
is
unfortunate,
but
but
okay,
it
probably
doesn't
affect
us
in
the
short
term,
like
we
probably
still
want
to
do
this
non-existent
up
bar
thing.
B
B
Yeah,
maybe
we
make
an
expression
kind,
it's
not
partial
path,
but
it's
like
up
far
path
and-
and
we
do
some
logic
to
grow
it
or
either
we
handle
that
in
the
mirror,
but
I
think
it
might
be
nicer
to
handle
it
in
t
here
such
that
we
we
wind
up
with
the
full
path
once
we
get
to
mirror,
so
that,
like
all
mirror
has
to
do
is
oh
no,
I
guess
it
has
sorry.
No.
I
guess
it.
It
has
to
kind
of
be
in
the
mirror,
normally
right.
B
So
what
we
would
we'd
have
some
upvar
node
and
mirror
would
do
the
same
logic.
I'm
talking
about
here.
Probably
of
that
when
you
convert
into
mirror
it'll
we'll
have
to
look
at
the
code,
but
it'll
do
something
similar
of
like
oh,
I
don't
have
enough
things
to
build
a
place
yet
so
I
have
to.
I
don't
have
enough
context
to
build
a
place.
B
A
Okay,
I
am
I'll
be
honest,
I'm
starting
to
kind
of
lose
you
a
little
bit,
but
I'm
hoping
once
I
get
into
it.
I'll,
probably
figure
out
a
bit
more.
B
I'm
not
surprised.
Luckily,
we
don't
have
to
write
this
code
today.
So
I
just
remembered,
though,
there's
one
good
thing,
which
is
the
mirror,
distinguishes
a
place
that
is
under
construction.
B
A
B
No
sorry,
okay,
so
there's
two
parts.
I
think
that
the
first
thing
we
talked
about
today
of
having
t
here
construction
understand.
The
idea
of
there
is
no
upward.
There
is
no
entry
for
this
up
far
that
we
just
have
to
do
yes,
or
at
least
it's
the
easiest
thing
to
do,
and
it's
probably
how
I
would
handle
this
in
the
short
term
in
order
to
make
the
lat
underscore
equals
x,
not
ice.
Sorry,
I'm
having
one
further
thought,
which
is
I'm
wondering,
given
that
this
is
a
fix
me.
B
B
A
Maybe
the
weekend
a
little
bit,
I
don't
know
yet
I
at
least
yeah
I'll
discuss
with
the
team.
I
think
there
are
a
couple
people
with
time,
so
we
can
start
looking
into
it.
I
was
thinking
more
around
sort
of
creating
some
well
creating
a
couple
base
comments
and
then
like
splitting
into
groups
instead
of
doing
yeah,
both
things.
B
But
I
don't
quite
know
what
I
think
it
should
look
like
either
so,
okay.
A
A
B
I
don't
think
we'll
modify
mirror.
We
just
have
to
we'll
make
the
mirror
construction
a
little
more
complicated,
but
the
mirror
okay.