►
From YouTube: 2020-10-15 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
All
right:
okay,
I'm
not
muted
yeah,
so
I
guess
the
current
status
is
manual.
Capture
is
kind
of
looking
good.
We
still
need
to
do
some
cleanup,
especially
around
which
expressions
we
pick
for
a
span
and
making
sure
arrays
are
being
handled
properly.
B
Other
than
that
we
ran
the
test
suite
last
week
we
had
a
couple
buttons
on
just
how
voucher
and
friendly
does
span,
but
it's
all
looking
good.
B
I
did
a
quick
rebase
last
night
and
the
only
failures
that
I
saw
were
on
things
that
I
hadn't
cleaned
up
or
was
the
better
way
to
put
it.
So
I
made
I
added
a
bunch
of
new
test
cases.
I
just
haven't
annotated
them
with.
This
is
where
error
should
be,
so
that's
the
only
thing
that
failed
in
like
the
first
set
of
tests.
So
that's
that's
good
after
it
changes
roxanne
made
conversion.
B
So
what
I'm
hoping
is
over
the
the
coming
weekend,
we
kind
of
start
doing
core
cleanup
and
start
fixing
whatever
little
bugs
are
on
expressions
and
stuff
is
left.
B
I
did
yeah,
I
can
show
you
what
that
looks
like
or
what
what
the
output
looks
like
give
me
one.
Second,
let
me
just
share
my
screen.
It's
gonna
be
easier.
This
way,
wait
where
to
share
screen.
B
B
No,
it's
yeah,
okay.
So
basically,
let's
just
take
some
simple
error.
So
let's
just
go
with
us:
okay,
let's
just
go
with
simple
struct
min
capture.rs,
so
we
have
a
very
simple
test
case.
It
just
ensures
that
minimal
assets
meets
both
the
path
requirements
and
also
the
capture
current
requirements.
So
basically
we
have
p
dot
x
by
immutable,
borrow
p
by
immutable
borrower.
B
We
want
p
to
be
overall
captured
by
to
be
captured
by
a
mutable
world,
so
the
output
for
this
kind
of
looks
like,
and
I
guess
I
should
just
split
my
screen
that
would
have
been
the
smarter
way
to
handle.
This
is
so
first
of
all,
since
I
have
this
feature
get
set,
we
just
captured
his
own
fields.
I
see
this
message
is
saying:
hey
I'm
using
the
new
style
analysis.
B
Then
it
just
prints
the
closure
id
and
kind
of
prints
all
the
places
we
captured
for
it.
So
this
one
is
the
first
place
we
see.
So
we
are
starting
off
at
our
id,
which
is
b
sorry
bar
like
root
variable,
which
is
p.
Then
we
apply
a
projection
to
access
the
field
and
there's
capture
information
for
it.
Similarly,
this
is
about
the
full
point.
We
don't
have
any
projections.
B
This
is
the
first
bus.
Then
it
prints
the
minimum
capture
analysis
in
which
we
capture
only
the
we
capture
the
full
place,
because
there
are
no
projections
and
but
then
it
turns
into
being
a
mutable
borrower.
A
Is
this
okay?
This
is
like
the
reduced
version
that
you
translate:
the
style
data
structures,
okay,
yeah.
So
I
have
a
few
comments
minor
points,
but
this
looks
great.
First
of
all,
it's
cool
that
it's
working,
the
one
thing
that
might
be
useful
and
the
problem
with
this
output
that
I
see
is
that
it's
so
detailed
that
people
are
going
to
be
like
not
a
bad.
A
No,
it's
not
that
big
a
deal
because
you
run
with
dash
dash
blast
and
it
like
gets
updated,
but
I'm
worried
that
if
it
changed,
no
one
would
ever
no
one's
ever
gonna
like
really
inspect
it.
I'm
wondering
when
what
I
think
would
be
useful.
If
we
can
do
it,
let
me
show
you:
okay,
go
back
to
the
rs
file.
B
A
Then
it
would
now
you
can't
dump
all
this
information
in
an
error,
but
just
for
a
second,
let's
ignore
that
problem
for
a
second,
if
you
did
generate
real
errors,
the
advantage
is,
you
have
to
actually
put
those
in
the
rs
file,
so
that
makes
them
like
we
actually
actually.
A
Yeah
make
sure
that
you
don't
accidentally
bless
things
that
are
not
supposed
to
change,
but
you
really
do
want
to
capture.
In
that
case,
that's
the
information
that
really
shouldn't
change
so
including
things
like
deaf
ids
and
so
on
can
be
a
problem,
because
then
somebody
refactors,
how
the
compiler
numbers
stuff
and
all
of
a
sudden,
like
you,
know
the
file's
out
of
date,
and
it's
a
painting
that
that
was
fair.
A
Yeah
so
like
okay,
the
new
new
style
character,
analysis.
You
know,
that's
just
yeah.
We
don't
need
that,
but
yeah
I
mean
you
could
put
it
as
a
warning
or
something
yeah
the
but
like
here
you
captured
the
bass
up
bar
and
then
a
projection.0.0,
and
it
has
this
capture
info
that
it's
in
that
it's
immutable
borrow.
I
could
imagine
issuing
an
an
error
on
the
line
of
the
closure.
That
said,
ideally,
it
would
print
like
p.0.0
and
mute
or
something
you
know
something.
B
Kind
of
human
we
we
can
go
implement
like
the
display
trade
or
implement
debug
ourselves.
A
A
B
B
Okay,
yeah:
I
can
look
into
that
yeah.
Actually,
it
might
be
interesting
how
that
works
out,
because
it's
possible.
We
have
multiple
sets
of
projections,
so
I
I'll
have
to
think
about
it,
a
little
how
that
gets
applied.
B
So
let
me
just
give
another
example:
multipla,
okay,
that
one
and.
B
A
B
So
like,
if
we
have
something
like
this,
so
we
have
like
two
levels
of
paths
that
we
are
capturing.
B
A
B
A
B
A
A
B
A
A
B
So
that's
this.
I
I
have
couple
questions
around
how
we
want
to
merge
once
this
is
sort
of
ready.
So
do
we
want
to
so
what's
going
to
happen
is
the
more
if
people
use
this
without,
with
the
feature
flag
set,
it's
going
to
tell
them
that
the
feature
is
incomplete,
so
it
will
not
work
and
somewhere
down
the
line.
Let's
say
we
do
not
have
the
bridge,
it
will
ice
because
the
we
we
are,
the
information
is
stored
in,
I
guess
an
interesting
way
or
like
it's
it's.
B
I
guess
so
I
don't
know
what
error
it
will
be,
but
it
I
suspect
that
there
would
be
some
error
if
we
just
use
the
output
out
of
minimum
captures
directly
without
a
bridge
which
I
guess
is
fine
from
the
standpoint
of
like
if
it
has
already
given
a
warning
saying
this
is
an
incomplete
feature,
so
this
is
kind
of
expected,
or
we
can
again
just
some
point
in
the
later
say
if
you
are
using,
if
this
feature
flag
is
set,
it's
failing
because
this
part
of
the
code
base
has
not
been
fixed
or
like
part.
A
B
Bad
things
will
happen
if
the
feature
gate
is
set,
because
now
we
are
okay.
So
basically,
if
okay,
if
this
was
without
the
feature
gate
set,
then
what
this
will
look
like
after
minimum
analysis
was
really
be.
Who
is
being
captured
right
like
on
my
screen,
so
it
will
really
look
like
oh
foo
is
being
captured
by
something.
Similarly
bar
is
being
captured
by
something.
So
that's
fine
and
I
can
just
look
at
the
first
index
within
this
array
and
I'm
good,
because
that
gives
me
all
the
information
I
need.
B
But
if
someone
has
a
feature
gate
set,
it
will
look
like.
Oh,
I
wasn't
supposed
to
do
that.
If
someone
has
a
feature
gate
set,
it
will
look
like
as
it
did,
which
means
it
might
have
not.
It
might
pick
up
the
correct.
Was
it
called
a
variable
to
capture,
but
it's
possible
that
it
does
not
pick
up
the
correct,
borrow
kind.
A
B
A
B
B
B
Like
it
will
look
like
what
do
you
expect
it
to
look
like
from
that
that,
so
it's
exactly
what
it
should
be.
B
B
A
A
I
don't
know
if
that's
significant.
We
can
certainly
measure
that
as
part
of
the
pr
I
have
one
question
about
the
minimum
capture
result.
That's
currently
in
the
type
check
tables
right
it
is
yes.
Is
it
plausible
that
we
do
not
put
it
in
the
type
check
tables
like?
Could
you
store
it
locally
and
feed
it
to
the
bridge
and
then
later
add
it
to
the
type
check
tables.
A
Oh
well,
there
you
go
even
better
because
yeah,
if
you,
if,
if
you
didn't,
have
it
in
the
type
check
tables,
then
there
then
the
memory
usage
is
going
to
be
just
transient
and
I'm
really
not
worried
at
all.
B
B
Okay,
that
makes
this
a
little
yeah,
okay,
that
it's
easier
and
quicker
to
deploy
this
okay.
My
second
question
follow-up.
I
guess
with
this
is:
how
is
there
a
way
on
github
for
us
to
test
with
the
feature
flag
set
on
all
the
testing?
We
do.
I
have
two
options
on
how
to
do
this,
but
I'd
like
to
hear
your
thoughts
with
like
assuming
that
the
feature
gate
was
set
and
we
have
the
bridge.
B
A
A
A
B
A
B
Yeah,
so
I
guess
the
memory
will
be
fine.
Okay,
so
I
guess
I
don't
see
too
much
work
around
here.
That's
left
on
this.
Do
we
want
to
run
capture
analysis
with
the
bridge?
Sorry
performances
with
the
bridge
to
see
how
much
extra
impact
yeah
has.
A
B
Yeah,
I
I
know
the
main
reason
I
bring
this
up.
Is
you
had
some
comments
in
the
plan
documents
that
this
so
I'm
not
sure
how
much
impact
this
will
have
like
it
isn't
too
much
code,
but
it's
it's
significantly
more
yeah,
more
more
analysis.
So
there's
going
to
be
impact,
I
just
don't.
B
Okay,
that
sounds
good.
I
created
an
issue
I'll
put
this
on
the
project
board.
Give
me
one
second,
actually
I've
ques,
I
haven't
looked
at
this,
but
we
for
the
most
part,
I
think
most
of
your
captures
has
been
replaced,
which
is
a
good
thing.
B
B
B
A
I
have
a
question
when
you
said
that
the
uses
of
closure
captures
has
been
replaced.
Did
you
mean
that
what
is
it
using
instead
and
is
this?
Is
this.
A
B
Type
suppose
type
check.
We
didn't
use
the
things
we
built
in
type
check.
Yeah.
Sorry,
I
misspoke
using
the
older
data
structures.
Data
is
using
the
older
data
structures.
A
A
A
B
Test
cases
fail
because
the
thing
is
with
men
capture
it
they're
places
where
it
changes
the
order
of
than
upwards
mentioned,
which
causes
inconsistencies
in
parts
of
the
compiler.
B
Is
liveness
so
there's
some
analysis
that
happens
over
here
to
figure
out,
if
basically,
certain
variables,
if
they
were
mentioned
in
the
quarry
or
later,
let's
say
they
were
mutated,
were
they
ever
used
again
and
at
least
that's
how
I
understand
at
a
high
level
what
this
part
the
the
like
this
file
kind
of
does.
B
B
B
A
I
think
that's
right
yeah!
This
is
really
just
at
the
level
of
variables.
This
code
is
a
it's
pretty
old
and
a
bit
crusty,
but
I
think
we
should
be
able
to
translate
it
in
a
relatively
straightforward
way.
Okay,
if
you
want
me
to
look
at
it
in
more
detail,
I
can
do
that.
B
Yeah,
I
I'll
let
you
know,
I
didn't
get
too
much
time
to
go
through
this
myself,
but
I
I
did
a
high
level
check
of
like
what
all
needs
to
change.
So
that's
why
I
was
just
I
wanted
to
like
get.
Is
there
any
high
level
concerns
that
you're
aware
of
before
we
go
and
spend
too
much
time
figuring
details
up.
A
Yeah
the
change
that
that
allowed
it
to
work
through
closures.
I
remember
that
landing
in
background
or
something
awesome
yeah.
I
might
have
to
familiarize
myself
with
that
code.
I
probably
are
plused,
but
I
don't
really
remember
that
the
basic
logic
before
that
was
pretty
straightforward.
I
mean
a
closure
was
kind
of
accessing
itself.
B
Let
me
see
if
I
can
find
the
comment,
but
yeah
I'll
go
through
the
pr.
Maybe
that
will
help
okay,
that's
actually
november
some
of
this
or
may
wait.
What
did
I
do?
What
did
I
do?
Okay,
I'll
look
through
this
I'll
look
for
this.
B
A
Okay,
I
mean
the
basic
idea:
is
that
at
each
point
in
the
control
flow
you
maintain
a
bit
set,
or
at
least
a
set
anyway
of
what
variables
are
live,
meaning
might
be
used
later.
Okay,
yeah-
and
you
do
this-
you
start
from
this
is
a
backwards
analysis,
because
you
kind
of
start
from
the
end
and
at
the
end
nothing
is
locked
right,
because
okay
yeah,
that
makes
sense.
B
A
A
Because
you
know,
there's
like
we
have
one
node
with
two
successors.
A
But
we're
going
backwards
so
yeah,
either
of
those
successors,
has
a
variable
alive
than
the
predecessor.
Yeah
makes
sense.
Yeah
makes
sense.
That's
the
basic
analysis.
What
we
do
for
closures,
like
the
simple
version
of
what
we
do
for
closures,
is
a
closure
expression
is
considered
to
access
all
of
the
variables
that
it
captured.
A
Okay,
I
don't
know
exactly
what
they
changed.
That's
the
part
where
I
have
to
look
like
this
commit.
I
have
to
go
back
and
reread
this
pr
to
see
what
they
changed.
Oh.
B
A
High
level
understanding-
and
if
you,
when
you
see
these
things
like
like
when
it
says,
live
node,
that's
just
a
node
in
this
control
flow
graph.
Oh
okay!
It's
we
don't!
Actually
I
don't
remember,
but
I
don't
think
we
actually
build
a
control
photograph
explicitly,
but
because
it's
code
predated
mirror
and
some
other
stuff.
But
what
happens?
A
Is
it
constructs
a
set
of
nodes
and
it
stores
a
set
of
bits
per
node,
but
then
it
walks
the
here
to
like
construct
the
edges
between
the
nodes,
if
that
makes
sense,
so
kind
of
correspond
to
things
from
the
here,
so
you
can
see
like
expert
node,
yeah,
all
right,
okay,
there's
closure
and
upward
wait.
There
are
two
well
you're:
okay,
there's
a
whole
bunch
of
nodes
there,
but
one
of
them.
Those
are
different
kinds
of
nodes
right,
but
one
says
that
that
means
a
node
that
corresponds
to
some
here
expression.
A
So
then,
if
we,
if
we
want
to
propagate-
and
we
go
to
like
a
here
expression
and
then
we
from
reading
here,
we
can
kind
of
see
what
expression
would
evaluate
right
before
that
one,
okay
and
we
can
say,
take
all
the
take
all
the
bits
from
the
successor
and
you
know
propagate
them
to
the
predecessor.
A
That
makes
sense.
Okay,
yeah,
that's
the
high-level
view.
Anyway,
we
can
walk
through
the
code
later
if
it's
useful,
but
no
okay.
That
makes
sense
and
I
think
ir
maps.
A
Yeah,
so
a
liveness
node
is
an
expression
or
capture
clause.
That
does
something
interesting.
A
Okay
yeah,
so
this
this
is
the
first
pass
and
then,
if
you
page
down
a
little
bit
more
you'll
come
to
the
second
pass,
which.
A
A
B
A
Is
some
work
on
closures
right
so
here
it
would
say
here
it's
first,
it
creates
a
liveness
node.
That's
the
line
up
above
where
you
are
and
then
right.
A
A
A
What
are
the
things
captured
by
this
by
this
closure?
What
I
imagine
is
going
to
happen
is
when
they
see
a
call
to
the
closure.
A
B
A
Anyway,
that's
enough
of
a
walk
but
you'll,
see
somewhere
in
there
that
it
does
a
similar
visit
of
the
here
and
and
like
propagates
bits
from
one
place
to
another.
Okay
makes.
B
Sense,
while
looking
through
this
idealized
one
thing
that
we
did
and
I'll
just,
I
think
it's
fine
for
now.
We
need
to
change
it
later,
but
let's
see
what
this
means
it
did.
Nice.
B
See
I
think
this
one
yeah
so
right
now
in
mod.rs
we
use
just
it's
kind
of
more
of
a.
I
don't
think
there
should
be
an
issue,
but
we
use
the
of
course
mentioned
span
to
get
information.
It
was
using
up
for
mention
directly,
but
this
is
just
to
get
places
in
order
at
some
point.
This
will
get
replaced
by
min
capture,
so
it
will
have
its
own
xp
use
expression
id.
So
we
can
just
get
this
fan
there.
A
B
And,
let's
see,
let
me
just
ask
okay,
let's
see
and
yeah,
I
have
a
one
question
around:
let's
see.
B
So
I
have
this
kind
of
a
simple
situation.
I
have
a
point.
I
create
a
pentagon,
so
it
has
like
five
points
and
we
have
this.
What
I
was
expecting
for
this
was
and
I'll
open
the
standard
out.
Okay
was
that
this
thing
will
have
two
sets
of
projections
so
or
more
like
three
sets
of
projections.
B
So
for
or
four
really
pentagon
will
have
a
d
reference.
Then
points
will
be
a
field
axis.
B
Then
we
do
an
index
access
to
get
the
array,
and
then
we
do
another
field
access
on
that
to
get
the
final
place
we
seem
to
only
be
doing
what's
it
called
a
single
projection
to
get
the
type
to
get
the
points
field,
and
I
was
hoping
to
see
at
least
a
d
reference
here,
but
I
guess
it's
moving
it
for
some.
A
No,
I
think,
what's
happening.
Is
you
don't
get
a
d
reference
because.
B
A
You
know
kind
of
and
there's
code
to
do
that.
But
let
me
look
real
fast
at
ps
code
to
refresh
my
memory,
but
the
thing
is
that
the
code
that
would
do
that
has
to
read
the
upvars
table
like
it
has
to
know
how
the
up
bar
is
captured
in
what
mode
in
order
to
know
whether
or
not
it
needs
to
introduce
rif
and
the
problem
is
when
you
first
analyze
the
code,
we
don't
yet
know
what
mode
it's
in.
A
A
B
Give
me
one
second,
so
that
is
filter
okay.
I
guess
this
one
makes
sense,
but
let
me
just.
B
Nope,
which
one
it
is
okay,.
B
A
A
B
Yeah,
okay,
I
guess
my
second
question
is:
why
do
we
stop
at
points
and
not
have
anything
high
more
than
oh,
I
did
an
index
axis
and
then
I
did
a
field
access
so.
A
B
A
B
B
Like
my
point
was
like,
I
want
to
make
sure
that
test
cases
that
ensure
that
the
level
of
detail
which
is
kind
of
like
the
only
you
go
ahead
and
I'll
show
you
how
I
was
able
to
get
an
index.
A
A
B
Wait
so
from
what
I
remember
was,
I
think,
you're
right,
because
it
says
if
there's
a
function
called
versus.
If
it's
the
actual
implementation
to
access
a
field,
then
one
gives
the
index
and
the
function
call
would
not
for
arrays
shouldn't
the
array
access
be.
Is
it
implemented
three
like
the
trade
stuff
that
you
just
mentioned,
or
is
it
should
it
not
be
the
like
kind
of
a
built-in
access.
A
We
start
by
sort
of
putting
it
through
the
trade
but
later
convert
it
to
a
built-in
operation.
A
I
see
I
have
a
memory
of
this,
but
I
don't
remember
exactly
when
the
later
is
and
it
may,
but
it
may
be
that
it
comes
after.
I
think
it's
in
right
back.
I
want
to
say
that
there
is
something
that
says
like
if,
if
this
is
I
know
for,
let
me
find
it
I'm
pretty
sure
it's
true
for
plus
it's
probably
true
for
index
two,
where
it
kind
of
says.
A
B
Okay,
I
mean
we
don't
really.
This
doesn't
really
cause
problems
so
right
it
it.
It's
a
it's.
It's
a
little
helpful
yeah.
While
you
pull
that
up.
Let
me
pull
up
the.
B
Yes,
that's
the
slice
pad
and
that's
what
I
was
that's
what
I
did
to
get
the
index
yeah.
So
slice
gets
me
the
index
projection,
but
yeah.
B
B
Yeah,
because
from
what
I
know
this,
this
will
resolve
into
sub
slides,
but
that
just
gets
kind
of
ignored,
because
it's
not
really.
It
cannot
be
used.
A
A
B
A
Find
that
one
right,
but
yeah
other
than
that.
Okay,
if
you
look
at
there's
a
method
called.
A
I
think
oh
down
below
there's
one
called
fix
index.
Oh
there
you
go
so
indexing
is
overloaded
until
right,
back
and
then
go
through
and
look
for
like
cases
where
we
where
it's
built
in
and
we.
B
Okay
sounds
good
all
right.
This
is
okay!
That's
all
I
have
in
my
mind.
We
discussed
the
bridge,
we
discussed
birth
and
I
got
answers
to
the
index
stuff
yeah.
Hopefully
this
weekend
we
clean
this
up
and
I'll
I'll
work.
I'm
assuming
that
when
archer
is
probably
gonna
work
on
cleaning
up
some
of
the
how
we
output
the
standard
out
and
more
like
move
it
to
standard
error
and
yeah
pr
land
yeah,
it
emerged
last
night,
great,
okay,
yeah.
So
if
you
want
to
look
at
the
project
board,
let
me
okay.
B
Let
me
know
if
you
want
me
to
reduce
the
size
of
the
screen.
This
is
I'm
gonna
edit,
this
a
bit
more
and
add
some
details,
but
hopefully
this
week
or
midway
through
next
week,
we
have
all
of
these
interview.
Type
check
using
closure.
Captures
will
be
mostly
done
as
part
of
these.
So
let's
worried
about
that
and
writing
mencap,
I'm
assuming
we
can
just
do
this,
the
right
backstage
when
we
do
the
more
lowering,
because
otherwise
it
doesn't
add
too
much
value.
B
Yeah
all
right
yeah.
This
is
all
right,
yeah,
okay,
that's
all
I
have
do
you
have
anything
else
for
us
nope.
This
is
great
all
right.
All
right!
Thank
you
see
you
next
week
see
you
next
week,
bye.