►
From YouTube: 2020-10-08 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
B
A
B
We
yeah,
I
was
saying
that
we
could
probably
do
something
like
we
could
probably
just
alias
dy
tuple,
to
be.
B
Upper
type
inference
thing
so
that
in
case
every
change
or
something
at
least
it's
easier
to
program.
But
I
don't
know
if,
like
I
can
go,
do
it
that's
not
a
problem
but
other
than
that.
A
So
yeah
and
the
original
plan
that
I
had
with
the
last
time
we
tried
this-
was
to
modify
the
obligation
card
obligation
cause
so
that
we
would
know
to
skip
it
based
on
that.
But
and
there
would
be
other
ways
you
could
imagine
like,
we
could
introduce
a
new
variant
of
tuple.
That's
like
internal
tuple,
yeah
yeah,
but
it
just
seems
like
a
lot
of
code
for
like,
but
it's
ultimately
you
three
lines
of
code
in
this
yeah.
A
B
B
So
hopefully
we'll
clean
this
up
over
the
weekend.
I
think
there's
only
a
couple
small
things
and
get
it
sort
of
just
like
looked
at
within
ourselves
to
catch
any
obvious
errors
and
then,
hopefully,
by
monday,
we'll
have
this
review.
A
Great,
can
you
if
you
want
me
to
review
it
well
actually,
this
weekend,
I
plan
to
clear
all
of
my
github
notifications
and
actually
try
to
keep
up
with
them
again
declare
bankruptcy.
But
if
you
nonetheless,
please
do
like
mercilessly
ping
me
with
things
that
need
review,
because
no.
B
No
yeah
this
was
like
on
monday,
when
I
said
internally,
I
meant
like
within
the
five
seven
of
us
just
take
a
look
so
that,
like
we're
not
wasting
your
time
for
obvious
errors,
if
it
get
yeah,
if
it
gets
so,
there's
that
if
you
want,
I
can
so,
we
ended
up
doing
most
of
the
code
for
minimum
analysis
using
a
bridge.
But
if
you
want,
I
can
it's
it's
not
too
much
from
like.
I
can
show
you
what
the
final
structure
now
looks
like.
A
Can
we,
by
the
way,
I
think
it
would
be
really
useful
to
me
this?
These
meetings
are
great,
I'm
wondering
is
there
somewhere,
we
should
be
taking
notes
or
like
do
you
have
a,
I
guess,
I'll,
just
post
some
random
things
in
the
zulu
for
now,
but
okay,
so.
B
Yeah,
okay,
I
think
that
would
be
yeah.
We
probably
should
do
that.
I
do
have
some
like.
Most
of
these
are
being
based
on
comments
that
we
have
already
had
I'll
share.
Another
dog
video
that
I'm
working
on
but
haven't
got.
A
B
Oh,
no,
everything
up
there
is
basically
up
to
date
from
it.
It
doesn't
have
as
precise
information
of
what
we're
doing
like
internally,
but
what's
being
worked
on
right
now
is
up
to
date,
so
I'm
making
sure
that's
there.
A
B
Talked
about
question
issue
four,
so
we're
talking
about
issue
9,
which
kind
of
builds
up
on
issue
7.,
so
they're
kind
of
we'll
go
in
together,
because
unless
yeah.
A
B
Thing
yeah
that
also
got
fixed.
It's
a
very
similar
thing.
If
the
first
thing
we
see
is
a
tuple,
then
we
ignore
it
and
just
ignoring
that
fixes
things.
B
So
the
only
ui
changes
that
are
there
is
something
that
should
have
fixed
in
print,
so
there's
it
would
print
the
generator
witness
if
things
are
resolved.
But
now,
if
we
have
an
inference
variable
for
the
upward
types,
it
won't
burn
the
generator.
So
again,
if
you
go
on
the
same
pier,
that's
linked:
okay,
yeah,
it's
the
pr23
that
you
see
up
here,
rexella,
throw
if
you
go
to
the
bottom-
that
right
above
that
one
all
right
that!
B
Yes,
if
you
look
in
the
diff
for
this
yep
or
like
file
change,
the
only
outputs
that
are
different
are
like.
We
do
not
have
unresolved
witnesses
being
printed
anymore,
which
I
should
have
fixed
like
it's.
Nothing
that's
going
to
cause
problems,
but
I
felt
like
this
could
have
this
vr
could
have
been
cleaner.
If
I
caught
this
in
the
pretty
print
stuff.
A
B
Okay,
so
it
might
be
easier,
I
can
either
just
send
a
teammate
link
or
I
can
just
share
my
screen.
Either
works
with
me.
B
B
B
B
Basically,
like
keeps
a
most
recently
used,
it's
it's
cd,
but
it's
smart
about
it,
so
it
keeps
a
track
of
substring
search
and
then
does
most
recently
used,
and
where
does
I
think
this
is
that's
where
that
is
and.
B
B
B
So
we
discussed
last
time
that
our
kind
of
the
structure
we
sort
of
going
within
storing
information
is
going
to
be
character
information.
B
So
this
is
going
to
have
an
expression
id
which
is
basically
the
where
a
place
is
being
used
so
that
we
can
use
it
for
diagnostics
reason:
it's
optional
is
because
when
we
do
the
initialization
for
old
analysis,
we
would
not
have
this
use
expression,
so
we
initialize
it
to
an
option.
Worst
case
scenario
or
fallback
would
be
the
span.
That's
recorded
and
upwards
mentioned.
B
Let's
just
go
with
the
discard
case
again,
so
we
have
something
like
let
this
within
a
closure.
So
so
that
means
when
we
do
the
new
analysis
part
of
this,
we
will
never
see
the
use
of
this.
A
B
B
Yeah,
it
will
end
up
being
that.
I
had
also
done
this
because
of
some
of
the
work
that
was
done
around
improving
diagnostics
for,
but
I
think
we
have
a
better
workaround.
So
if
there's
something
like,
I
think
it
might
be
good
to
have
a
comment
about
that.
In
the
you
know,
yeah,
it
won't
be
about
the
why
this
is
an
option
yeah.
I
need.
B
Okay,
I'll
do
that,
otherwise,.
A
B
Okay,
I'll
do
that,
then
we
have
the
captured
kind,
which
is
basically
the
upper
capture,
as
things
are
today.
This
is
just
like,
maybe
rename
it,
but
that's
not
important
okay.
So
this
is
what
the
final
structure
sort
of
looks
like
for
this
one
is
the
final
structure
that
will
be
for
that
will
be
within
our
closure,
so
this
is
for
a
given
closure.
Give
me
the
root
variable
main
list.
If
someone
has
better
names,
we
I'm
bad
at
naming
things
so
suggest
them.
B
B
A
I
have
a,
I
have
a
total
knit
that
helps
me,
which
would
be
that
if
you
reordered
these,
I
would
find
it
easier
to
read
them.
Okay,
yeah
I
like
to
start
from
the
top
down,
but
it
doesn't
really
matter.
I
see
how
I
see
now
how
it's
set
up,
so
the
min
capture
information
map,
that's
the
main
thing.
What
is
this
def
id.
B
A
B
This
is
this:
is
the
it's
similar
to
what
your
calculator
captures
is
done.
A
B
B
B
I
think
I
have
a
video.
I
have
shared
it
on
zulip,
where
I
did
all
of
that,
but
I
should
have.
I
guess,
love
the.
I
explained
it
right
above
this,
but
then
I
ended
up
deleting
them.
Yeah
feel
free
to,
like,
I
guess,
post,
that
on
the
we
have
like
the
229
playlist,
so
it
kind
of
explains
capture
analysis
and
how
it
has
changed.
B
So
yeah,
but
basically
the
way
it
will
store
things
would
be
foo
and
basically
parts
from
food
that
will
end
up
getting
captured
and
whatever.
So
it's.
Basically,
this
is
what
we're
trying
to
store
and
oops.
So
that's
essentially
what
we
will,
what
the
structure
will
end
up.
Looking
like
once
capture
analysis
is
done
and,
okay,
I
see
and
the
way
arrays
are
going
to
get
handled
as.
A
A
B
Can
just
kind
of
take
the
keys,
and
then
you
have
the
old
result
that
and
naughty
also,
just
even
if
we
actually
knew
oh
yeah
yeah.
B
A
Think
in
mirror,
I
think,
you're
going
to
want
it
in
your
construction
when
you
get
there
because,
what's
going
to
happen,
is
you'll
have
an
expression
like
foo,
dot,
z,
dot
bar
dot
whatever,
and
you
are
going
to
start
from
that
outer
expression
and
the
first
thing
you're
going
to
do
is
recurse
all
the
way
down
to
the
base,
which
is
going
to
be
foo,
yeah
and
then
you're
going
to
want
to
look
up
and
say:
are
there
any
things
that
start
with
this
base
that
we
captured?
Because
this
this
is
gonna?
A
B
We
already
wait
is
this:
are
you
saying
something
like
if
I
have
food.
x
and
food.x
dot
bar
then
reduce
it
to
food.x.
A
B
B
A
Why
not
keep
food.x?
Sorry,
that's
not
what
I
meant.
I
meant
what
I
meant
is
there's
a
field
in
the
closure
that
represents
a
captured
place.
Yes,
and
you
want
to
identify,
like
you
have
some
expression
in
the
code:
that's
like
foo
dot
x
and
it
needs
to
be
changed
to
a
reference
to
that
field.
B
A
B
A
A
B
Yeah
other
than
that
is
its
implementation.
If
you
want
to
go
want
me
to
go
into
that,
I
can
go
into
that.
A
B
A
B
So
testing
right
now
has
been
making
sure
that
the
data
set
that
we
have
like
a
what
the
current
test
data
is
works
and
kind
of.
What
we
have
done
is
like
kind
of
go
through
a
couple
examples
and
make
sure
they're
fine.
What
in
what's
in
the
works
is
have
a
very
simpler
test
suite
that
goes
through
each
and
every
case.
So
I
can
kind
of
show
you
that
as
well,
that
we
plan
on
just
putting
it
in,
and
I.
A
Have
one
more
before
you
go
there?
I
have
two
questions.
First
of
all
I
assumed,
but
I
didn't
say
you
also
have
this
bridge
code
that
you
were
talking
about
before
right,
just
takes
the
minimum
captures
and
creates
the
old
style
stuff.
Yes,
yes,
we
have,
and
does
that
is
that
bridge
code
for
this,
let
underscore
equals
x
case
handle
that
preserves
the
current
behavior
right
now.
Yes,
yes,.
B
It
does
actually,
if
you
say,
if
you
use
all
the
analysis,
then
yes,
if
you
don't,
then
no.
B
Yeah,
so
that's
what
I
was
gonna.
Another
thing
I
want
to
talk
about
was:
do
we
want
to
come
up
with
the
name?
Because,
right
now
we
just
use
an
environment
variable
to
decide.
B
That
works
I'll,
probably.
A
A
We
don't
really
need
process,
but
we
should
document
it.
Let
me
see
if
there
was
a
name.
Usually
the
rfcs
are
supposed
to
include
a
name,
but
I
don't
know
if
we
actually
did.
Oh,
it
looks
like
closure
capture,
disjoint
closure
capture.
Disjoint
fields
was
the
name
of
the
rc
yes,
and
there
is
which
is
a
pretty
mouthful.
But
who
cares.
A
A
Links
on
how
to
do
that,
but
yeah
copy
and
pasting
some
stuff,
yeah
yeah.
It
would
be
nice
to
have
that
and
then
you
can
write
tests
that
have
the
feature
and
what
you
would
do
is
you
can
test
if
the
feature
date
is
enabled
in
the
current
crate,
and
so
that
would
replace
your
environment
variable.
It
would
be
like
if
futuregate
is
enabled
use
the
new
analysis
else.
Yeah.
B
A
B
Are
like
keep
a
track
of
our
like
the
structure?
That's
there
for
now
and
as
we
keep
fixing
things
and
like
yeah,
as
you
improve,
make
sure
those
things
resolve
correctly
and
don't.
A
Yeah,
okay,
something
else.
So
what
what
you
can
do
I'll
have
to
find
a
good
example
hold
on
I'm
taking
some
notes
in
this
issue.
Just
in
a
comment
that
I'm
drafting,
but
let's
see
I
want
to
put
in
the
feature
gate
name
to
select
new
algorithm
should
add
feature
gate
and
use
that
to
decide
instead
of
environment
variable.
So
that's
kind
of
an
action
item
so
right
so
in
terms
of
testing
there's,
let's
find
a
good
example.
A
A
So
there's
a
let
me
find
a
good
example
just
to
give
you
a
template
to
copy
well,
I
can't
find
any.
I
remember
there's
some
for
variants,
oh
yeah,
so
if
you
search
for
rusty,
underscore
variants.
A
Yeah,
what's
this.
B
A
Case
actually,
I
can
just
tell
you
the
test
file
to
open
it's
just
open
up
source
test,
ui
and
then
variance
and
then
variance
or
variance.
B
Okay,
wait:
I
might
have
just
opened
the
one
that
does
not
have
it
yeah.
Okay,
this
one
actually
does
not
have
it.
B
A
This
thing
nope
that
what
you
see
open
up
all
these
hidden
things,
that's
the
feature:
gate
yeah.
What
you
do
need
the
feature
gate,
but
let's
ignore
that
for
a
second
one,
go
down
one
line.
A
So
this
attribute
here
this
this
is
telling
the
compiler
hey.
You
see
that
error
that
occurs
on
the
next
line
with
the
minus
and
the
plus.
So
that's
a
special
error
that
is
just
dumping,
internal
debug
state,
that's
not
otherwise
accessible
and
it's
it's
generated.
Because
of
the
presence
of
this
attribute
I
see,
and
so
what
that's
doing
is
we
computed
the
variance?
A
I
don't
know
if
you
know
what
it
is,
if
you
don't,
it
doesn't
matter
for
each
type
parameter
and
so
that
debug
state
is
telling
you
the
first
one
is
minus
and
the
second
one
is
plus
okay.
So
you
make
something
like
that
for
for
every
closure,
you
dump
out
the
minimum
pads
that
were
captured,
and
then
you
just
have
to
add
error
annotations
that
will
like
log
what
you
expect
to
see
and
then
you're
all
set
done
all
right.
You
can
search
you'll
find
in
the
compiler.
A
B
Okay,
that
makes
sense.
Okay,
I'm
just
gonna
put
it's
in
this
chat
about
wrestling.
A
B
A
B
It's
kind
of
working
it's
we
still
need
to
do
a
little
bit
more
around
handling
erase
properly,
because,
like
just
making
sure
that
the
root
is
the
moment,
you
see
an
array,
we
just
stopped
doing
anything
after
that.
A
B
B
Yeah,
let's
see
I
have
a
let's
just
do.
B
B
So
a
lot
of
the
examples
here
are
for
precise
capture.
So
this
is
an
example
that
I
took
exactly
from
the
rfc
where
this
does
not
work
out,
because
one
is
mutable,
one
is
immutable,
and
so
there's
that
test
this
test
is
the
simple
min
capture
test,
where
this
is
being
p.
Dot
x
is
used
in
a
particular
way
and
p
itself
is
used
in
a
different
way
yep.
So
you
know
sorry,
I
can
open
that.
I
actually
no.
This.
B
Yeah,
this
is
to
make
sure
tuples
are
working.
Fine,
I
yeah.
I
I
don't
know
if
you
want
me
to
go
through
all
of
them,
but
yeah
we
have
a
bunch.
B
A
Yeah,
that's
exactly
what
I
had
in
mind,
so
you
would
just
add
an
attribute
to
each
of
those
tests
and
dump
stairs
yeah.
So
that's
the
other
thing
I'll
just
say.
One
more
thing
is
you
could,
instead
of
making
it
report
errors,
it
might
be
better
to
make
it
report
warnings,
though
I
have
to
double
check
whether
like
run
past
tests
or
whatever,
if
they
still
check
for
warnings.
I
can't
remember,
but
I
was
thinking
that
some
of
those
tests,
the
ones
that
are
meant
to
compile
correctly,
it
might
be
useful.
B
A
B
So
this
is
about
it.
I
think
what
I
have
to
share
right
now,.
B
B
Okay:
okay,
okay,
okay,
yeah,
no
yeah
yeah,
that's
the
first
one!
That's
the
first
part
of
this
where
we
do
the
basic
changes:
yeah,
that's
fine,
okay,
yeah!
That
makes
sense.
A
This
is
great,
I
mean
it
seems
like
you're,
making
great
progress.
I
think
once
jumping
back
to
the
project
board,
you
basically
got
all
the
because
all
the
in
progress
things
are
really
close
to
done.
Yes,
and
so
probably
before
the
next
week,
we
won't
get
like
we're
not
going
to
pick
up
any
new
items
right.
B
No,
hopefully,
by
the
end
of
next
week
or
like
about
two
weeks
from
now,
I
want
at
least
everything
that's
open
right
now
and
number
six
to
close,
because
number
six
will
is
basically
removing
the
bridge.
B
Number
six
is
partly
done
because
it's
required
in
some
of
these
places.
Okay,
another
thing
that
comes
out
of
closure
for
your
captures
and
the
bridges
that
the
order
in
which
things
aren't
upwards
mentioned
is
not
same
as
order.
Anything
for
your
captures
anymore.
So
is
that
relevant?
B
B
Yes,
so
from
that
perspective
we
saw
some
errors,
so
parts
of
this
is
will
already
be
done
by
the
time
we
are
done
with,
like,
I
think,
number
four,
but
more
of
them
will
change
by
the
time
we
remove
the
bridge.
All
of
that
will
be
done
so
hopefully,
if
in
two
weeks
or
so,
we
can
probably
finish
most
of
this-
that's
there
and
then
again.
This
is
hopefully
because
most
of
us
are
kind
of
on
co-op
or
have
like
busy
school
schedules,
but
yeah.
B
A
Okay,
so
we
have
that
sounds
really
good.
We
have
five
minutes
left.
I
could
go
back
and
explain
the
thing
I
was
trying
to
explain,
but
it's
really
it's
really
about
in
terms
of
the
project
board.
I
was
really
talking
about
number
10,
I
think,
and
how
it's
actually
be
implemented.
So
maybe
yeah.
A
A
A
Was
that
in
in
here
lowering
right?
Imagine
we
have
something
like
this
okay,
so
when
we
actually
or
yeah
when
we're
generating
the
mirror
this
we're
gonna
have
a
here.
Like
you
know,
I
don't
know,
I
forget
what
the
names
of
the
yeah
the
heroes
are.
But
you
know
it's
a
standard
ast
thing
right.
A
And
what
I
was
suggesting
is
that
you
don't
actually
like
we
want
to
replace
this
entire.
Let's
put
a
little
function
called.
We
want
to
replace
this
entire
subtree
with.
A
With
a
reference
to
the
field
that
represents
food,
I
bought
up
as
right,
yes,
and
the
annoying
thing
is
that
the
way
it
works
today,
let's
just
start
with
that,
is
we
compile
we
compile
baz,
it
says
first
compile
bar,
it
says
first
compiled
foo
and
now
because
foo
is
an
up
bar,
we
refer.
We
return
a
reference
like
we
return
a
place
like
you
know,
self.0
or
something
okay,.
B
A
And
and
then
this
becomes
self.0.r
and
this
becomes
cell.zero
dot
or
bar.best,
and
that's
kind
of
easy.
It's
a
little
bit
harder
when
it's
not
always
the
leaf
that
you
want
to
replace
with
self.0,
but
some
subtree
that
you
have
to
recognize
not
super
hard
right.
There
are
a
bunch
of
you
could
do
this,
but
the
way
I
think
would
probably
be
easiest
is
when
you
get
to
the
leaf
when
you
get
to
the
leaf.
A
A
B
Yeah
just
doing
it,
I
think
I
know
so
just
to
make
sure
we
first
do
a
check
just
based
on
the
root
variable,
and
then
we
know
that
some
parts
within
like
like,
if,
let's
say
the
only
thing
out
of
this,
we
were
capturing,
was
food.bar
like
that
was
like
the
precise,
how
we
are
store
things.
So
we
know
we
have
a
reference
to
food
or
bar
somewhere
and
we
can
just
quickly
go
from
there.
A
Yeah
so
so,
basically
you'll
start
out
with
the
set
and
then
you'll
return
it
to
your
parent
and
the
parent
will
say
I
am
loading
bar.
I
see
that
I
see
that
like
bar,
you
know
that
can
further
narrow
the
set.
If
it
once
it
gets
down
to
a
single
item,
then
you
can
make
a
reference
to
that
field
until
it
gets
to
a
single
item.
A
It
should
never
get
to
zero
items,
because
that
would
be
bad,
but
it
should
it
can
be
still
ambiguous,
which
field
you
need
until
you've
gone
far
enough
up
the
tree
to
identify
it.
Does
that
make
sense.
B
Sort
of
so
basically,
we
want
to
make
sure
that
some
parent
path
is
in
the
capture
list
that
we
had
generated
right.
Yes,
I
think
I'm
still
a
little
confused,
so
you
might
need
me
to
look
at
code
and
get
a
better
idea
what's
happening
but
yeah.
I
think
that
sort
of
makes
sense.
A
So
yeah,
okay
I'll
just
say
one
last
thing
which
is
today
today
mere
construction
says,
like
you
know,
it's
like
here,
node
to
mirror
place
essentially
and
what
I'm
proposing
is.
It
would
return
here
node
to
either
a
mirror
place
or
a
like
set
of
upfar
captures,
and
the
reason
is,
you
may
not
know
yet.
A
You
need
to
know
information
from
the
parent
like
the
leaf.
Node
doesn't
have
enough
information
to
actually
construct
a
mirror
place,
and
so
you
could
you
could
do
one
of
two
things:
either
the
parent
can
pass
down
the
information
it
needs,
but
we
don't
already
have
a
data
structure
that
can
represent
that
or
or
you
can
pass
it
back
up.
A
I
don't
really
have
a
strong
opinion
about
this.
This
is
just
sort
of
how
I
imagine
it
could
work
and
then
the
field
bar
node
would
see
would
get
back
a
set
of
captures.
That
is
like
not
a
singleton
set.
That's
not
quite
right.
It
is
a
little
more
work,
but
the
idea
is
that
you
would
narrow
it
down
and
eventually
and
return
it
up
and
the
field
baz
node
would
return
the
mirror
place.
A
Self.0,
so
why
am
I
saying
multiple
I'm
talking
about
multiple
because
you
might
have
foo
dot
bar
dot
baz,
two
right,
so
you
don't
know
when
you
just
look
at
these
foo
nodes,
you
don't
yet
know
which
one
of
those
you
want.
You
won't
know
when
you
get
to
baz
or
baz
too.
Oh
okay,
but
okay,
yeah!
That's
the
idea!
So
it's
we
we'll
figure
it
out
when
we
get
there.