►
From YouTube: 2020.06.09 RFC 2229 Sync meeting
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
A
Okay,
all
those
who
look
at
sometimes
came
for
like
lighter
weight
and
are
more
incremental,
updates.
I
figured
we
could
check
in
on
what
you
all
have
done
and
talk
about
the
next
steps
and
how
we
should
stay.
Organized
cuz,
I'm
feeling
a
little
one
thing
that
I
tend
to
do
is
get
involved
in
more
than
one
thing
at
a
time,
and
so
it's
important
for
me
at
least
to
have
things
in
a
row.
So
I
can
come
back
in
and
figure
out.
A
B
It's
it's
being
worked
on.
We
had
issue
with
span
because
currently,
if
we
use
capture
closures,
you
only
get
an
upward
ID
problem
with
that
is
there's
no
way
of
well.
We
configure
the
way
right
now
to
get
upwards
from
up
our
ID,
because,
as
I
mentioned
in
the
zubur
chat
means
we're
tracking
aliveness
using
span
yeah.
This.
B
B
B
A
B
B
B
A
A
B
Actually,
it
might
come
back
to
the
whole
problem
with
layered
place,
containers
fan
or
not,
because
this
is
closer
capture.
And
what
do
you
want
to?
Actually
capture
is
the
place
and
a
place
can
be
like
the
minimal
place
can
be
associated
with
multiple
spans
because
we
can
just
have
let's
say
food
or
that's
being
called
in
multiple
places
and
the
same
closure.
So
the
place
is
the
same,
but
the
span
might
be
different.
So
probably
how.
A
A
I,
don't
know
it's
probably
the
first
or
the
last
one,
okay
and
I
think
we
would
do
the
same
here
so
sort
of
some
representatives
stand
I,
don't
know
why
we
wouldn't,
unless
the
only
reason
I
can
think
not
to
do
so,
would
be
if
there's
some,
like
yeah
I,
think
we
already
have
some
similar
data.
So
let
me
show
you,
it
was
gonna
say
if
there
is
like
some
reason
not
to
have
a
span
in
this
data
structure.
I,
don't
think
that's
the
case,
especially
given.
A
Bar
capture
map-
that's
not
the
thing
I
was
looking
for.
I.
Think
closure
kind
origins
is
the
thing
right.
So
what
this
is
saying
this
is
recording
this,
isn't
that
same
construct,
and
you
see
it
already,
has
it
and
what
what
this
field
is
doing,
as
it
says,
is
if
one
of
the
things
being
fur
bite
is
it?
Is
it
an
FM
FM?
You
turn
effin
once
closer,
and
this
gives
us
us,
and
why
did
we
pick
what
we
picked?
Okay.
B
A
Uses
that
an
error
ring
so
this
the
purpose
of
this
ban
is
basically
the
same
right.
We
want
to
have
a
little
explanatory
information
that
we
can
use
for
error
reporting
and
maybe
will
remove
it.
So
one
of
the
things
Matthew
Jasper
mentioned
in
Zulu
up
is
that
we're
actually
moving
away
in
general
and
the
compiler
from
passing
around
spans
and
we're
preferring
to
pass
around
the
ID
of
an
expression
and
then
have
a
separate
way
to
say
what
is
the
span
for.
B
A
A
A
A
B
B
B
A
So
what
I
was
gonna
say
is
I
think
we
might
want
to
rename
this
to
something
like
oh
yeah,
so
this
type
probably
wants
to
be
called
capture
map
or
something-
and
this
this
this
inner
map
probably
wants
to
be
called
like,
oh
hold
on.
Let
me
make
a
document,
but
I
almost
have
it
my
computer's
being
mildly,
slow.
A
The
point
is
you
have
like
the
outer
things
like
the
closure
capture
of
map
or
something,
and
then
the
very
innermost
value
is
sort
of
captured
information
right
and
it's
the
information
about
a
single
capture
and
I
think
it
should
be
the
up
bar
that
we
captured
at
least
today
and
the
here
ID
or
a
representative
sort
of
span
for
why
we
captured
it
and
that
will
evolve
into
a
place
and
this
man
it
might
be
a
place
in
a
sense
like
a
curse,
to
meet
it
I'm.
Just
thinking
if
you
use.
A
B
A
All
right,
so
the
only
advantage
to
living
here
is
that
we
can
all
type
in
it
the
so
this
type
I'm
gonna
rename.
A
A
A
A
B
Think
they
heard
he
was
lady,
local
one
and
the
HR
ID.
The
party
was
the
pot
to
do
it
with
some
bread,
the
ID
to
the
local
thing
with
them.
I.
A
A
A
A
B
Think
when
I
think
even
in
your
dog
and
when
I
was
splitting
up
to
us,
we
had
split
this
in
like
two
separate
parts
where
first,
we
just
get
like
the
sort
of
minimal
or
lay
the
maximal
among
the
minimum
work.
So
like
we
capture
everything,
and
then
we
try
to
a
minimal
one
where
we
try
to
only
get
a
dot
B
out
of
those
three.
So
okay.
B
A
B
A
A
A
We
can
do
maybe
it's
not
even
that
important,
because
we
were
just
saying
that
we're
going
to
want
to
capture
a
span
or
some
location
in
the
closure
where
the
place
was
used.
So
maybe
we're
gonna
end
up
wanting
to
capture
that
anyway
feel
like
it
conceptually
aids
me
in
these,
but
the
other
thing
is
that
the
existing
gear
place
is
not
very
precise
and
we
need
to
make
it
more
precise.
Does
everybody
on
the
call
know
what
a
place
is?
A
A
Welcome
back
to
this
type,
but
the
projection
has
different
kinds,
and
these
are
the
kinds,
so
it
can
either
be
a
DRS
or
an
access
to
a
field
or
some
index,
and
we
don't
here.
We
are
not.
If
you
compare
this
to
the
mere
place,
you'll
see
that
we
lost
a
little
data,
but
that's
because
we
don't
think
we
need
it.
A
B
B
A
C
A
B
A
A
Yeah,
so
this
would
be
the
kind
of
target
we're
reaching
for
and
I
said,
I'd
come
back
to
this
type.
The
idea
here
is
that
we
store
in
the
in
the
current
here
place
structure.
We
go
back,
we're
storing
the
type
of
this
place
for
the
entire
thing,
but
in
this
version
we
kept
the
type
at
each
point
as
we
extend
it
with
each
projection.
We
keep
the
intermediate
type
and
the
reason
is
that
that
might
be
useful
to
us
that
avoids
the
need
to
sort
of
recompute.
A
In
principle,
we
can
kind
of
recompute
those
types,
because
if
you
know
the
starting
type-
and
you
know
that
it's
this
given
field-
you
know
the
type
of
that
field,
but
it's
some
work
to
do
and
there's
some
annoying
complications
that
have
to
do
with
associated
types
and
so
on
that
make
that
potentially
non-trivial.
So
it's
usually
better,
since
we
already
have
the
type
computed
once
to
just
store
it
as
we
go,
and
then
we
can
come
back
for
it
later
and
the
reason
we
might
want
to
know
the
type
as
an
example.
A
Remember.
But
I
was
saying
that
if
you
have
like
a
struct
with
a
destructor,
so
it
implements
drop,
you
can't
move
out
of
its
fields,
so
we
would
probably
just
capture
a
dot
B
in
a
case
like
this.
Assuming
that
field
B
is
a
type
II,
and
so
we're
gonna
have
to
do
that
sort
of
analysis
where
we
like
walk
along
the
path
and
see
just
how
much
of
it,
what
prefix
of
it
we're
actually
going
to
capture
and
for
that
the
types
of
these.
A
So
in
order
to
refactor
to
get
there,
we
have
to
take
some
steps.
You
know
there's
one
step
of
separating
out
this
part
like
I,
said
I'm,
not
that's
a
relatively
easy
I'm,
not
sure
how
important
it
is,
but
we
can
do
it.
The
other
step
would
be
introducing
these
new
kinds
of
projections
and
I
talked
a
little
bit
about.
B
A
B
Just
one
quick
thing:
so
when
we
try
call
type
text
tables
off,
we
need
a
local
deaf
ID,
and
is
that
also
expected?
Behavior
looks
like
I
would
have
thought
that
when
we
were
using
type
check
tactic
tables,
we
were
reusing
sort
of
a
global
deaf
ID.
You.