►
From YouTube: 2020-11-12 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
B
Yes,
that
is
okay,
I'll,
just
pull
up
the
video
right.
That
makes
it
easier
but
yeah.
So
this
thing
is
missing.
The
recent
changes
that
you
requested
during
review
yeah,
but.
B
Okay,
yeah,
but
mostly
it's
just
like
I
made
made
sure
that
I
can
run
boards
test
if
I
disable
this,
which
is
the
initialization
step.
A
B
A
B
It
is
not
exactly
that
yes,
so
we
might
want
to
run
one,
but
I
if
this
gives
an
idea,
then.
B
More
work,
I
would
think,
maybe
yes,
and
now
it
depends.
I
guess,
like
the
other
thing,
has
an
initialization
step.
This
has
an
extra
like
since
it's
not
initial,
I.
B
B
At
the
same
time,
overall,
in
the
future,
this
will
get
a
little
better
because
we'll
end
up
removing
the
bridge,
so
we
will
lose
one
extra
step
which
right
now
is
we
don't
want
to
modify
rest
of
the
compiler
to
handle
this
yet.
B
Yes,
but
I
don't
see
them
here
right
now,
which
is
the
concerning
part,
so
I
send
an
image
which
is
like
so
some
of
these
are
concerning,
but
these
are
really
small
numbers,
so
any
like
minor
changes
are
severely
exaggerated
yeah.
I
do
not
know
why
these
are
here.
Also,
this
might
be
wall
time.
This
was,
I
think,
of
all
time,
so.
B
A
B
B
B
Wait,
the
one
that
you
requested
was
like
what
something
about
log.
Oh
we're
using
spam,
never
mind,
never
mind.
Okay!
That's
fine!
Sorry!
I'm
sorry.
A
A
One
other
thought
I
had
on
that
note:
if
you
wanted
to
condense
the
output,
what
you
could
do,
which
might
be
useful,
is
to
create
one
error
and
add
span
notes
for
each
capture.
So,
like
one
error
for
the
closure,
this
is
what
I
originally
had
in
mind.
Actually
and
then
speed
notes
for
every
capture
with
the
span
and
then
the
capture
string,
sort
of
recaptured
x
because.
A
I
don't
think
that's
what
you
want
here.
Okay,
I
think
you
want
to
have
distinct
labels
on
each
span
where
you're,
saying
okay
after
this,
with
a
mute
borrow
because
of
this
span,
something
like
that.
Okay,
if
there
were
two
opinions
to
if
you
wanted
to
show
two
distinct
spans
for
the
same
label,
I
think
then
multi-span
is.
B
More
okay,
actually,
I
should
have
not
stopped
sharing
my
screen.
I
can
go.
I
added
a
couple
more
issues
to
the
project
board.
These
are
still
not
around
like
t
her
and
mer,
but
I
guess
we
didn't
resolve.
I'm
trying.
A
B
Remember
where
we
left
the
so
I
so
the
place
where
we
left
the
light
underscore
was
that
you
said
we
can
sort
of
move
some
of
this
work
into
more
around
using
place
builder,
because
you
can
have
some
under
constructed
places
or
places
that
are
under
construction.
A
B
Reviews
the
place
builder,
that's
in
mer
and
use
the
fact
that
some
places
might
be
under
construction,
so
use
that.
B
Had
so
I
think
he
left
a
double
x
or
something
somewhere
hold
on.
Let
me
pull
it
up.
I
left
it
here.
A
B
Or
maybe
in
the
other
one
oh
yeah
here.
A
B
B
So
basically,
we
don't,
and
we
don't
want
to
do
sugar
patterns
and
t
her
because
or
move
this
logic
there,
because
it's
critical,
we
might
make
mistakes,
and
so
the
idea
was
we
kind
of
moved
that
logic
into
at
least
that's
what
I
remember
being
the
last
bit
of
the
meeting.
A
That's
right-
and
I
think
I
think
the
outcome
of
this
is
that
t
here
depends
how
we
wanted
to
find
partial
path.
But
I
think
what
it
would
be
saying
is
that
t
here
right
now
t
here,
d,
sugars,
upward
references
into
a
field
access
itself,
and
I
think
what
the
thing
is
that
that
that
would
move
out
of
t
here
and
into
mirror
building.
B
Yes,
I
think
that's
what
I
understood.
I
still
think
we
need
to
do
some
parts
and
t
here
especially
handle
this
non-existing
upward.
So.
A
B
The
and
and
let
me
the
end
thing
we
had
was
like
we
first,
we
forget
about
the
letter,
underscore
issue
and
we
do
the
partial
path
and
see
if
we
can
handle
it.
The
problem
is,
we
need
to
handle
this
into
here,
at
least
to
some
extent,
because
otherwise,
t
here
will
mark
this
as
a
local.
A
A
Scope
and
that
it
would
just
if
we
did
it
this
way,
you
would
just
always
generate
an
upvar.
It
would
sort
of
be
like
today's
model,
no
matter
what
the
minimum
captures
are,
you
would
always
generate
an
up
bar
reference.
It
would
probably
not
be
de-sugared,
so
it
wouldn't
take
into
account,
buy
ref
or
buy
whatever
would
just
be
a
reference
network
kind
of
like
it
is
in
here
basically
and
the
reason
for
that,
and
then
it
would
become
mirror's
job
to.
A
Yeah
and
the
idea
would
be
then,
that
right
right,
so
when
you
get
into
mirror,
you
would
see
an
up
bar
reference
and
we'd
have
to
check
the
capture
information
for
the
closure
to
figure
out
at
what
point
we
can
change
a
path
that
begins
with
an
up
bar
like
at
some
point,
there's
some
place
that
we're
building
and
it
begins
with
an
up
bar
and
it
can
get
converted
into
a
concrete
field.
Reference.
A
B
B
I
was
thinking
initially,
we
might
have
to
use
upwards
mentioned,
but
what
we
really
can
do
is
just
use
just
put
an
extra
check
which
is
like
oh,
if
this
is
not
enclosure
captures,
but
wasn't
upwards
mentioned
just
still
return
and
upward
type
like
like
you
were
just
suggesting
if
you
want
okay
and
what
I
did
last
night
was
kind
of
marked
places
where
this
will
get
end
up
handling
handled.
So
let
me
just
pull
that
up,
and
maybe
that
adds
a
little
bit
more
clarity
to
this.
B
B
B
B
This
one
is
basically
where
we-
and
I
guess
this
is
this-
is
where
this
sort
of
ends
up,
if
you
have
an
f
and
an
fm
closure
which
will,
at
the
end
go
over
here,
so
we
just
as
long
as
we
refer
to
ourselves.
I'm
assuming
this
just
means
self-resistance.
B
Like
at
the
end,
this
is
where
the
closure
will
end
up,
because
you
need
to
refer
to
yourself.
B
So
there's
that-
and
this
is
this-
is
mere
build
and
there's
this
other
part
which
okay,
that
is
already
so
yeah.
So
this
is
where
we
really
construct
closures
and
mirror.
Is
we
we
go
over
all
the
operands,
we
see
if
it's
a
place,
or
this
would
be
a
by
value
capture
and
we
kind
of
we
create.
Instead
of
creating
a
temporary,
we
just
create
a
place
and
we
consume
it
right
away.
So
what
I
was.
B
B
So
what
I'm
trying
to
understand
is
how
would
this
part
really
look
around
here,
so
so
this
closure
basically
captures
x.0.0
and
x0.0.1.
So
I
guess
this
thing,
and
this
thing
assuming
I
wrote,
but
let's
just
assume
it
captures
this
thing
regardless
of
what
x's
I
got
it
to
an
acid,
and
it's
confusing
me
now.
B
So
what
I
was
thinking
was
this
turns
into
something
like
we
basically
have
a
consume
for
x.0.0,
which
we
basic
and
then
everything
kind
of
references
itself
from
there
that's
sort
of
something
I
was
picturing
or
even
if
we
don't
have
this
it
just
basically
like
this
will
come
down
to
what
we
were
discussing
the
other
day.
Was
we
figure
out
that
okay,
at
least
some
of
the
partial
part
that
we're
dealing
with
is
already
captured?
So
we
have
a
complete
upper
of
search
right.
A
Like
right,
so
there's
two:
why
don't
we
switch
over
back
to
the
hackmd
for
a
moment?
Okay,
do
you
just
want
to
drive
just
share
it?
Just
keep
your
keep
your
sharing,
but
I'm
gonna
type
on
my
side
a
little
bit.
B
Okay,
let
me
open
the
hacker
yeah.
Okay,
I
would
open
it.
A
B
Oh
yeah,
let
me
share
my
yeah
that
works.
A
Yes,
okay,
so
I
think
there's
two
parts
we
have
to
consider
there's
like
constructing
the
closure
and
then
there's
accessing
important
words
yeah
from
within
the
closure.
Right,
yes,
and
you
were
you-
were
I'm
not
quite
sure
which
one
you'd
rather
talk
about.
First.
B
B
A
We
get,
I
think,
that's
right.
The
first
one,
I
think,
is
fairly
trivial,
like
the
current
code
that
we
were
just
looking
at.
You
know
it
makes
a
closure
r
value
and
for
each
capture
it
references.
A
particular
local
verb
instead
is
to
reference
the
place
yeah
so
accessing
up
bars.
This
is
a
good
one,
so
the
basic
strategy
I
have
in
mind,
let's
assume.
First
of
all,
we
extend
t
here
with
a
upboard,
node,
okay,
and
I
think
we
can
remove.
A
In
that
case
the
self
thing.
Okay,
I
might
be
wrong,
but
I
think
that's
true.
I
think
that's
only
used
for
closures.
B
A
Yeah,
what
is
the
name
here?
It
is
actually
maybe
I
should
share,
because
I
want
to
pull
up
another.
B
A
B
A
A
Yeah
yeah,
I
forget
how
it
was.
Let's
assume
some,
though.
A
No
okay,
we
we
don't
know
what
the
whole
closure
is,
but
suffice
to
say
that
it
yeah
it
captures
x,
dot,
zero,
yeah
yeah,
but
we're
but
we're
gonna.
Look
at
this
reference
that
is
x
0.1.
So
so
what
happens?
Then?
We
right
the
t
here
for
this
looks
like
up
rfx.
A
Up
ref
x,
these
are
sort
of
bullets.
Does
that
make
sense?
Yes,
the
notation
I'm
using
here,
yeah,
okay
and
then
the
so.
What
will
happen
in
the
mirror?
A
Construction-
and
I
partly
reason
I
wanted
to
share-
is
that
I
wanted
the
ability
to
refresh
my
memory
on
how
this
stuff
works.
But
let
me
let's
first
take
a
little
bit
of
a
segue
to
talk
about
mere
places.
A
Yes,
yeah
it's
more
yeah
exactly,
and
so
it's
just
like
yeah
just
like
your
place,
it
begins
with
a
local.
It
has
some
list
of
progression
projections
and,
as
it
happens,
this
list
is
interned.
Yes,
now,
that's
not.
You
know
particularly
interesting,
except
for
the
fact
that,
as
a
result
of
it
being
interned,
we
added
this
thing
called
place
builder
for
making
places,
and
the
idea
of
place
builder
is
that
you
have
a
vector
that
can
grow
and
then
only
once
you
know
the
full
place
you
go
and
turn
it
right.
A
B
You
can
use
the
source,
I
think,
all
right.
I
guess
that
works.
A
B
A
A
A
But
I
have
to
just
go.
B
A
A
Let
me
just
pull
this
up,
because
I'd
rather
read
the
code
in
github
anyway,
so
it
looks
prettier,
okay,.
A
Yeah,
so
what
I
was
saying
now,
I
can
replace
this
with
a
proper
link,
the
what's
going
to
happen,
we're
going
to
start
with
the
field
right,
which
is
here
we're
going
to
convert
that
to
a
place
and
we
get
a
place
builder
and
then
we're
going
to
so
we're
going
to
recurse
and
we'll
end
up
with
a
place
builder
here
with
an
empty
vector
or
if
this
were
a
regular
variable
with
an
empty
vector
and
a
variable.
A
B
Wait,
do
we
start
inside
out
so
do
we
start
from
up
our
ref
and
build
towards
field
one
or
do
we
do?
I
mean
that's
what
we
kind
of
end
up
happening,
but
what
does
the
call
stack
look
like?
Do
we
see
field
one
and
then
we
recurse
and
see
field
zero
and
then
a
part
f
or
the,
or
do
we
actually
see
up
for
up
first
and
then
field
zero
field,
one
yeah
so.
A
A
B
A
Is
that
we
will
do
something
like
it'll
get
a
little
bit
more
complicated,
but
it's
going
to
do
something
like
this
place.
Builder
will
become
some
kind
of
enum,
okay
and
instead
of
being
created
on
a
local
variable,
or
it
will
be
either
starting
with
a
local
variable
or
starting
with
an
up
bar.
A
A
Yes,
what
is
the
name
of
that
field?
It's
called
local,
I
think
okay,
so
it's
gonna
have
to
change
its
name,
probably
but
yeah.
So
let's
call
it.
Let
me
just.
A
A
A
B
Okay,
yeah
and
you
can
just
put
another
bracket
or
something
yeah
yeah
and
assume
it
captures
it
0.0.
Okay,
okay,
I
guess
that's
not
important,
but
yeah.
A
B
A
A
A
We
probably
want
some
way
to
make
this
a
little
more
efficient,
but
the
dumbest
version
would
just
do
it
every
time
and
when
you
find
a
match
like
oh,
we
now
have
the
exact
path
that
corresponds
to
snapchat
and
we're
going
to
replace
it
with
a
de-sugared
place
that
is
rooted
in
self,
so
that
logic
that
figured
out
like.
Oh,
what
kind
of
capture
was
it
I
have
to
add
a
star.
I
have
to
do
that
other
stuff.
That
logic
moves
from
t
here
into
mirror.
A
So
here
we
observe
that
up
our
x
zero
one
is
in
our
capture
set
hey,
let's
call
it
a
bi
rest
capture
because
that's
what
it
would
be
in
the
example.
Then
maybe
we
generate
so
we
return
a
new
placeholder
place
builder.
B
Can
you
turn
the
star?
Can
you
replace
star
with
data
there
just
so
that
it's
a
little
less
just
more
yeah?
Okay,
so
I
guess
one
thing
we
also
need
to
do
is
write
some
way
of
translating
more
sorry,
her
projection
list
into
our
projection
type
into
more
place
element.
A
A
But
I
don't
I
don't
know
you
have
to
play
with
the
code
a
little
bit
about
best.
I
suspect
you
would
that
might
work.
I
have
to
look
the
mirror
places.
Don't
have
a
lot
of
information.
Your
place
doesn't
have
like
spans
or
anything
in
it.
So
nar
does
hair
place.
Yeah,
that's
what
I
was
talking
about.
I
was
concerned
that
maybe
there's
more
information
like
if
you're
building
up,
if
you
wouldn't
have
the
information
you
need
to
make
a
mere
place,
but
I
think
that's
not
true.
A
B
A
It's
pretty
simple,
really
so
yeah
yeah,
I
don't
so.
I
don't
know
whether
that's
an
interesting
question
of
whether
like
it's
nicer
to
make
place
builder,
have
two
modes:
it's
either
in
mirror
place
or
hero
place
mode,
and
it
it
starts
in
here
place
when
you're
doing
up
cars
up
until
you
find
a
match
that
might
work
really
well,
but
regardless,
what's
going
to
happen
now,
so
this
is
then
just
like
as
above
right
and
the
main
thing
I
was
going
to
say
is
when
you
call
into
place,
you
know
it's
a
span
bug.
A
If
this
is
not
yet
a
mirror
place
now,
yes,
now
the
problem
we're
gonna
encounter,
probably
right
away.
Oh
actually,
I
don't
know
we
have
to
look
at
how
match
construction
works,
because
that
might
be.
A
B
B
A
B
The
irrefutable
ones
right
give
me
one,
I
I
definitely
looked
at
that.
I
guess.
A
The
scrutiny
thing
well,
I
think.
B
It's
something
sorry,
it's
called
expert
into
pattern.
That's
the
name
of
the
function,
I'm
just
trying
to
find
where
it
goes.
Okay,.
A
A
A
Oh,
yes,
I
think
I
know
what
yeah
so
if
it
indeed
calls
and
tries
to
convert
this
to
a
place
you
might
be
able
to
get
by
with
something
actually
simpler.
Now
that
I
think
I
take
it
back
instead
of
converting
to
take
a
place
builder
might
work
to
convert
this
so
that,
like
okay,
let
me
let
me
just
back
up
a
second,
the
way
that
match
works
more
or
less.
A
Candidate
is
kind
of
what
I
wanted
to
look
for
yeah
at
the
match.
Kind
of
I
guess
it's
more
match
pair,
maybe,
but
it
basically
walks
down
and
walks
down
the
patterns
and
and
looks
at
what
they're
doing
and
along
the
way
it
keeps
a
place
of
like
what
is
the
value
currently
being
matched
right
here
and
oh,
is
this
going
to
work?
No,
what
I'm
saying
is
not
true.
A
B
Now
only
x
x
will
come
get
completely
captured
here,
because
when
you
match
on
x
it
will
capture
x
by
a
by
ref,
or
at
least
that's
what
I
remember,
but
I
think
last
time
we
decided
to
discuss
that.
Maybe
that's
not
the
case,
but
give
me
one
second,
I
I.
B
Yeah,
I
I
the
reason
I'm
a
little
confused
is
oh,
I
do
not
it's.
B
Read
or
something
right
yeah,
if
you
go
an
expert
use
visitor
or
I
can.
A
B
A
Does
it,
how
smart
is
it
what
if
there's
like
multiple.
B
A
Stupid
bro,
I
don't
know
why
or
how
exactly
that
comes
to
be
true.
We
have
to
look
as
long
as
we
don't
like.
A
Certainly
if
we
capture
all
of
x,
it's
okay
for
us
to
say,
closures,
we
need
to
like
document
this
somewhere.
But
you
know
if
closures,
if
the
analysis
is
not
as
precise
as
it
could
be,
it's
okay
to
me
so
that
it
gets
a
read,
you
know,
but
it
is
something
where
changing
it
can
affect
the
like.
It's
not.
A
B
Actually,
I
might
be
wrong,
let
me
just
make
sure
I
might
sorry.
Let
me
just
give
me
one
second,
I
just
wonder
never
mind
it
does
get
used
yeah.
We
do
do
that.
So
I
send
I
wasn't
able
to
send
it
on
here,
but
I
sent
it
on
zulip
the
screenshot
of
kind
of
what
gets
how
we
do.
A
This
code
yeah,
there
must
be
something
there
must
be
a
special
project.
Rs.
Okay,
I
think
where
is
matt?
Where
are
matches?
Is
it
r
value,
probably.
B
No,
it's
expert
slash
into
dot
rs.
A
B
A
B
B
Yeah,
I
do
not
know
this
okay
yeah
this
one.
So
basically,
as
you
can
see
in
every
one
of
these,
if
we
have
a
binding,
if
you
have
an
array
or
anything,
if
you
scroll
down
a
bit
and
while
we
don't
really
do
anything,
so
I
think
it
just
skips
over
instead
of
doing
an
actual
read.
A
Well,
but
no
because
this
function
called,
I
don't
think,
I'm
not
sure
about
that,
because
I
think
this
is
not
where
x.
Okay
right,
this
is
not
where
I
expected
the
read
to
come
from
where
I
expected
the
read
to
come
from
is
here
when
we're
generating
match
expert
we're
going
to
call
lower
scrutiny.
A
And
this
is,
it
says
here
something
to
do
with.
Maybe
this
fake
read,
because
it's
for
matched
place
has
special
treatment
in
the
borrow
checker,
where
it
doesn't
consider
it
a
full
read.
That
might
be
the
case.
A
So
it
doesn't
it's.
This
is
probably
something
to
push
for
later.
The
fact
that
we
add
a
like
read
of
matched
places
into
is
going
to
sidestep
this
problem
for
the
time
being,
which
is
good
because
I
I
definitely
would
want
to
push
this
out
to
a
fix
me.
I
think
this
is
not
the
not
the
first
pr
what
we
eventually
would
want
to
do.
If
we
wanted
to
remove
that
fake
weed
or
that
extra
access,
let's
call
it
is,
I
think
we
would
eventually
want
to
refactor
this
code
to
use
place
builder.
A
It
would
basically
be
the
exact
same
logic.
We
would
just
refactor
this
to
use
place
builder
instead
of
a
fully
created
place,
which
might
even
be
better
for
various
reasons,
because
these
are
this
is
indeed
building
places
it
might
be,
and
then
once
that's
done,
we
would.
B
Yeah,
okay,
can
you
quickly
go
back
to
the
hacker?
I
just
want
to
confirm
one
thing
scroll
up
a
bit.
I
guess
so.
When
we
do
this
convert
to
place,
do
we
would
we
have
any
problem
with
as
long
as
the
place
that's
generated
is
precise?
Will
we
have
any
issues
with
what
is
it
called
bottle?
Checker
like
again,
I
guess
my
question
is
still.
I
feel
like
a
little
bit.
B
So
like
just
right
right
around
your
hair,
it's
like
right,
where
we
just
discussed
the
yeah
so
where
we
call
it,
we
just
said.
A
A
Oh,
I
have
another
thought,
but
we'll
come
back
to
it.
It's
it's
a
minor
deal
so.
B
Over
here
yeah
so
over
here,
when
we
do
this
up
for
her
id
one
thing
that
I'm
a
little
concerned
about
energy
scroll
down
is
like,
even
if
you
find
okay,
we
have
this
exact
path.
How
do
I
refer
to
that
part
tonight?
Oh,
never
mind.
Okay,
I
see
yeah.
I
see
we
did
that.
Okay,
now
it's
it's!
It's
it's
good!
It's
good!
Okay,
yeah.
A
B
Yes,
at
least
in
the
non-fixed
micros,
there
shouldn't
be
the
stuff
yeah.
B
At
least
in
the
non-light
underscore
equals
x
case,
because
in
in
that
case,
you
will
never
build
the
actually.
No,
even
in
that
case
we'll
have
an
uprx
somewhere.
So.
A
B
A
B
A
Place
builder
wouldn't
change,
but
but
this
would
and
then
the
reason
that
we
might
do
that
is
that
then,
in
the
matches
code,
like
that's
you,
you
could
express.
A
You
could
express
it
kind
of
like
that
yeah
and
maybe
that's
nice.
I
don't
know
but.
B
The
matches,
one
is
sort
of
led
underscore
equals
x
handling.
So
I
think
that's
for
later.
A
My
point
is
that
we
could,
if
it
works
out
nicely
factor
out
the
logic
of
tracking
the
possibility
of
being
a
hero,
place
from
the
logic
of
manipulating
mirror
places
or
building
mirror
places.
And
then
we
can
apply
it
not
only
to
place
builder
like.
If
we
build
it
into
place
builder,
then
we
have
to
refactor
the
matches
code
to
use
place
builder,
but.
A
B
Well,
I'm
I'm
just
a
little
confused
on
your
last
comment
about.
I
I
feel
like.
If
we
do
the
order
place,
that
would
only
affect
the
posture
we
use
upper
ref
right.
A
B
Okay
is
r
here,
please
just
okay,
it's
a
generic
enum.
Okay.
That
makes
I
I
missed
the
generic
key
number
and
that's
what
was
confusing
me.
A
And
then
you
would
have
some
methods
on
this.
This
would
be
the
the
main
point
of
this
would
be
that
there
would
have
been
that
like
are
useful,
that
do
the
logic
of
like
a
pen.
I
don't
know
yeah,
I.
I
don't
think
this
really
matters.
I
would
probably
start
with
modifying
place
builder
because
it
seems
more
natural
than
we
need
yeah
and
when
we
go
to
do
the
match
code,
we'll
either
refactor
it
to
use
place
builder
or
we'll
refactor
in
some
other
way,.
B
A
B
A
Yeah
and
then
extend
place
builder
to
cover
up
bars
would
be
like
the
next
step.
I
guess
we
would
want
like
you
could
just.
I
think
they
should
never
use
it.
That's
not
that
exciting.
You
can
do
it,
it's
a
first
refactoring
you
know
and
then
and
then
the
next
logic
will
be
to
actually
use
it.
B
Yeah
wait
when
the
first
require
the
second,
because,
if
you're
using
up
for
refs
or
when
you
say
convert
upwards,
is
it
to
convert
them
into
like
the
order
place
that
we
were
talking
about.
A
B
I'm
I'm
my
concern
is
the
second
part
that
we
have,
which
uses
convert
place
builder
converts
upward
ref.
Would
that
not
be
part
of
wouldn't
that
not
be
required
for,
like
the
mer
builder,
to
convert
it
into
more
places.
A
No
because
you
only
need
at
this
point
we're
still
not
capturing
the
science
spots.
Yes,
so
we
can
always
convert
an
up
ref
into
a
mere
place
in
one.
B
B
A
Right
so
this
would
be
just
a
plane
refactoring
to
modify
a
place
builder.
This
is
probably
not
even
a
full
pr
more
like
a
commit
this
this
this
code,
we
could
actually
land
and
should
I
think
this
would
commit
along
the
way
you
could
land
it,
but
it's
just
that
code,
cool
and
then
we'll
actually
be
done,
except
for
the
fact
that.
B
Improve
diagnostics
a
bit,
so
I
think
that
sort
of
I
I've
created
tickets,
I'll
work
and
to
make
sure
those
go
through.
A
B
A
The
thing
I'm
most
worried
about
is
optimization
and
measurements,
that's
the
biggest
unknown.
To
me.
I
think
that's
probably
out
of
scope
for
your
work.
I
mean,
if
you
all,
want
to
continue.
I
would
be
thrilled,
but
like
yeah,
I'm
really
hoping
to
get
to.
If
we
get
this,
that
would
be
fantastic
right,
like
the
fix.
B
B
Basically,
we
will
do
this,
but
the
idea
is,
we
will
kind
of
still
aim
to
get
it
done
by
december,
a
because
starting
or
like
at
least
early
december,
because
then
people
just
kind
of
vacation
and
stuff
end
of
december,
and
also
just
like
us
having
to
do
less
things
related
to
this
during
a
school
term,
will
kind
of
reduce
some
amount
of
just
work
that
we
have
and
like
focus
on
other
things.
Yeah.
A
A
B
Yes,
so
those
tickets
yeah,
I
did
something
around
it
so
well,
I
created
a
pr
so
that
we
start
tracking
a
little
bit
more
information.
One
min
capture
lines.
B
But
yeah,
so
that
work
is
happening
in
parallel
to
at
least
that
information,
because
that'll,
just
like
add
another,
feel
to
how
we
start
characters
today.
Another
thing
I
wanted
to
bring
up,
I
don't
know
how
much
time
we
have-
and
I
probably
should
leave
in
like
10
minutes
ish
as
maybe
we
can
okay.
This
is
like
part
of
optimization,
maybe
for
later,
but
I
don't
see
us
using
too
much
out
of
the
place
itself,
so
we
we,
we
have
a
lot
of
extra
information
there.
B
I
guess
well
not
a
lot,
but
we
store
the
type
of
basically
at
every
axis
at
each
field.
I
do
not
know
if
you
really
need
it
on
the
surface.
I
don't
see
why
I
could
be
wrong,
at
least
at
least
after
type
check
information.
Are
you
referring
to
so
when
in
her
every
time
we
apply
a
projection?
We
store
the
type
of
it.
I
did
not
know
if
we
needed
for
capture
analysis,
so
we
can
probably
store
some
in
less
amount
of
information.
A
B
Like
it's
it's
for
later,
it's
an
optimization
on
mem
storage,
but
that
that's
one
thing
that
was
on
my
mind
and
also
we
can
remove
like
instead
of
using
plays
directly,
we
can
kind
of
take
those
fields
put
them
in
directly,
because
otherwise,
every
time
we
use
place,
there's
that
check
of
oh,
if
the
thing
we're
working
with
is
a
up
for
place
or
is
it
otherwise?
You
got
a
bug
out
so.
A
Right
yeah,
you
might
not
need
it
you're
right,
you
might
not
need
it.
You
might
need
it
later
when
we're
building
mere
places,
okay,
either,
but
either
you
would
need
it
when
you
build
mere
places
or
it
depends
on
how
we
do
that
because
like
if
we
took
the
approach
I
outlined
initially,
then
I
so
okay.
So
let
me
back
up
a
second.
The
reason
you
need
the
type
information
is
that
sometimes
it's
not
reconstructable
because
of
associated
type
normalization.
A
Can't
just
take
the
type
from
the
struct
like,
ideally
you
would
take
the
type
from
the
struct
declaration
of
the
field
and
just
do
a
substitution,
but
but
that
doesn't
always
or
that
always
works.
But
then
you
have
to
normalize
and
sometimes
that's
annoying
and
inconvenient,
but
through
that
it
will
also,
but
you
only
you,
won't
necessarily
need
it
in
the
here
place,
because
it's
already
in
the
expression
like
it's
in
the
t
here,
and
so
you
can
get
it
from
there
so
yeah
we
could
maybe
take
it
out.
I
wouldn't
worry.
B
A
All
right
look
forward
to
it.
Talk
to
you
later
all
right.