►
From YouTube: 2020-10-30 wg-traits: type library sprint planning
Description
Planning for a sprint to extract a standalone type library that can be shared by chalk, rustc.
A
Like
we
had
said,
I'm
trying
to
page
back
in
what
we
said
at
the
end
of
the
last
meeting,
we
said
that
we
wanted
to
kind
of
approach
it
a
little
bit
from
two
ends,
maybe
extract
some
things
from
rusty
and
extract
some
things
from
or
chocolate's
already
extracted.
I
guess,
but
bring
the
two
a
little
closer
together
until
they
can
be
actually
unified.
A
A
B
D
B
B
E
B
A
B
A
B
A
Yeah
I'm
what
I'm
imagining
is
I
mean
I
think
this
might
just
stay
the
same.
It's
just
that
you
might
be
able
to
do
this
in
chalk,
like
eventually
we
would
have
a
a
data
struct
that
you
can
call
also
right
now
we
don't,
but
for
I
actually
don't
know
what
we
have
now,
I'm
guessing
based
on
what
you're
saying,
because
I
haven't
read
that
pr,
yes,.
B
A
Really
wish
we
had
that
well,
whatever
I
would
like
it
if
at
some
point
we
get
some
kind
of
accessories
in
rust
so
that
we
could
do
this
stuff
in
other
ways,
but
I
don't
know
leave
that
aside.
So,
okay,
don't
so
I
guess
the
question
is:
should
we
it
might
be
more
convenient,
also
in
chalk,
sometimes
to
match
on,
like
there's
an
advantage
to
matching
on
the
field,
just
that
you
don't
have
as
much
reference
stuff
going
around
kind
of.
A
E
B
A
B
B
B
I
mean
somewhat,
but
I
I
not
worried
so
much
about
removing,
or
I
should
say,
I'm
not
worried
about
removing
things
that
we
add
to
chalk,
because
it's
in
rusty
versus,
I
guess
not
like
I
said,
I'm
I'm
sort
of
okay
with
just
adding
things
to
chalk
as
we
need,
because
if
we
eventually
remove
them
at
rusty,
I
think
it'll
be
easy
enough
to
remove
them,
remove
them
and
chalk.
As
long
as
we
sort
of
don't
build
new
logic
around
it
in
shock.
B
And
the
regions
in
particular,
are,
I
think,
really
simple,
because,
like
the
re-static
change
was
super
small
and
easy,
so
I
don't
think
adding
regions
will
be
hard.
I
think,
as
was
put
here
per,
am
and
perhaps
perhaps
re-early
ground
will
be
harder,
because
that
actually
requires
quite
a
bit
of
logic.
A
B
B
Yeah,
so
a
lot
of
the
work
I've
been
doing
so
I've
got
it
where
it's
actually
sort
of
whenever
you
call
binder,
binds
it'll
actually
sort
of
go
through
and
visit
all
the
types
and
then
collect
the
bound
bars
and
the
naive
way
that
I
had
done.
That
originally
was
just
to
count,
but
then
locally.
I've
also
actually
made
it
collect
the
actual
ones,
and
there
was
a
big
performance
hit.
So
I
had
done.
B
I
went
through
a
bunch
of
places
we
had
to
rebind
so
that,
rather
than
sort
of
going
through
and
visiting,
it'll
use
the
same
bars
or
at
least
in
theory,
let's
see
and
then
locally.
I've
also
changed
like
gone
through
in
a
little
bit
more
detail
and
basically
audited.
All
the
bind
calls
to
whether
or
not
they're
really
binding
or
if
they're
dummy
calls
and
I've
gotten
sort
of
to
a
point
that
I've
got
the
all
the
easy
ones
done.
B
A
B
Right
so
I
yeah
so
I'm
sort
of
at
a
sort
of
minimal
subset
in
terms
of
bind
calls
that
I
am
at
this
point
like
I
not
focusing
on
that.
Instead,
I'm
trying
to
make
it
so
I
had
done
for
the
variable
kinds,
thai
region,
const
and
but
also
unknown
for
cases
where
rusty
might
skip
binders,
and
so
I'm
trying
to
remove
that.
B
But
just
the
memory
of
why
that
is
well,
I
mean
so.
I
changed
it
and
there
was
like
three
places
that
it
basically
does
that
and
then
there's
a
couple
test:
outputs,
but
I
mean
it
the
pr
just
got
merged
last
night,
so
it's
now
at
zero
and
that
fixed
a
bunch
of
cases
and
there's
now
three
test
cases
that
are
failing
where
there
are
bound
bars
being
skipped
that
I
have
to
look
into
and
that's
sort
of
where
I'm
at
and
then
sort
of.
B
Progress
actually
yeah,
and
I
mean
we
can
talk
about
this
another
time,
but
also
it's
sort
of
come
up
that,
like
it's,
a
race,
late,
bound
regions
or
erased
regions
returns
back
t
rather
than
binder
of
t,
and
it
doesn't
do
any
erasing
of
types
or
comps,
then
anonymize,
anonymized,
late,
bound
regions
won't
respect
bound
types
or
cons,
so
it
I
don't
think
right
now
it's
a
problem.
I
think
those
are
called
sufficiently
weight
that
there's
not
going
to
be
bound.
B
A
B
And
then
I
don't
know
if
that
was
the
best
time
to
talk
about
it,
but
I
was
you
know,
sort
of
after
I
get
actual
tracking
of
bambara.
So
right
now,
I'm
essentially
just
mirroring
the
bound
bars
that
are
in
the
type
as
the
list,
but
I
think
probably
what
would
be
nice
here
is
to
move
even
closer
to
sort
of
rust
or
choc's
model.
Where
we're
not.
We
don't
have
all
the
different
region
kinds
we
just
have
or
like
the
bound
region
kinds.
B
A
E
B
A
A
A
A
The
the
only
my
only
real
hesitation
would
be
the
fact
that
this
has
this
allows
you
to
say
exactly
what
goes
in
there,
which
might
be
useful,
but
maybe
there's
a
I
have
to
think
about
it.
Maybe
there's
actually
rusty's
approach
to
predict
is
pretty
annoying
in
lots
of
places
like
having
the
flat
predicate
is
then
there's
all
this
random
code,
where
you
know
it's
only
coming
from
the
user,
and
it
can't
have
those
cases,
and
you
just
get
these
bug,
arms
and
stuff
yeah.
So.
B
B
Yeah
I
mean,
like
I
said:
I
think
a
lot
of
this
experimenting
can
happen
as
we
move
things
into
its
own
rust
sea
crate
to
sort
of
align
them,
and
I,
like
I
said
I
think,
that's
where
most
of
the
work
is
going
to
be
is
well.
I
should
say
that's
where
the
most
of
the
refactoring
is
going
to
be
is
trying
to
move
things
out
versus
sort
of
yeah.
B
C
A
A
B
A
B
A
B
A
B
A
A
A
B
A
B
A
Two
but
ready
b
or
something,
but
I
don't
think
he
will
it's
fine
or
they
will
I
yeah
I
might
I
might
try
to
play
with
it.
It's
it
would
be
cool
if
it
worked.
I
would
like
the
code
better.
If
we
didn't
do
this
trick,
I'm
worried
it'll
be
slow,
but
we've
been
pretty
good
at
finding
solutions
to
those
problems
over
time.
A
A
I
don't
know
what
the
word
is,
that
they
have
bound
types
in
them
from
their
context
and
then
another
one
that
instantiated
them.
On
the
other
hand,
if
we
start
actually
using
binder,
we
sort
of
solve
that
problem
a
different
way
yeah,
so
because
that
is
a
place
where
there
actually
are
a
non-trivial
number
of
bugs
due
to
people,
just
forgetting
to
substitute
when
they
should
have
done,
and
especially
rusty's
punting
means
that
that
actually
works
a
lot
of
times.
A
Like
you
know,
you
have.
You
have
two
contacts
with
two
logically
distinct
type
parameters,
but
both
with
index
zero,
and
you
could
be
substituting
one
for
the
other,
but
you
don't
and
it
still
compiles,
and
then
someone
makes
a
new
example
that
has
like
not
index
zero
and
everything
breaks,
and
it's
really
confusing.
B
A
A
E
E
B
A
I
think,
eventually
we're
going
to
want
some
subtract
of
interner.
That's
like
global
internet.
I
don't
know
what
it's
called,
but
the
point
being
that
it's
or
not
global
internet,
that's
the
wrong
name,
but
it
would
be
a
sub
trade
that
allows
you
to
get
the
intern
representation
without
supplying
the
internet,
and
that
would
be
useful
for
rusty.
A
She
has
that
capability
and
in
particular,
then
we
could
implement
dref
for
if,
if
you
have
that,
an
intern
that
meets
that
bound,
tai
can
implement
dref
and
draft
to
tie
data
just
like
rusty
does,
and
the
advantage
of
that
would
be
that.
Then
we
can,
you
know,
not
modify
all
the
rusty
source
code
that
takes
advantage
of
that
and
it's
more
convenient
when
you
can
less
convenient
when
you're
writing
generic
code
and
that's
okay,.
A
B
A
A
A
B
A
A
I
don't
like
there
could
be
two
possible
fixes
right.
One
would
be
that
you
just
do
figure
out
that
you
can
return
the
original
value
or
do
less
folding
yeah,
and
the
other
would
be
that
you
optimize
the
interning
stuff.
I
think
rusty
is
more
on
the
latter.
Actually
I
don't
think
we're
all
that
smart
about
the
former,
but
maybe
we
are
in
some
places,
maybe
there's
a
few
crucial
places.
B
A
We
can
go
florian,
be
interested.
Very
bold
it'd
be
nice
to
get
someone
from
rust
analyzer,
although
it
might
require
some
modifications
to
salsa.
If
I,
if
we
wanted,
if
the
answer
is
that
they
should
be
interning
their
slices,
we
may
have
to
modify
salsa
to
do
it.
Rusty
has
some
pretty
scary
code
to
do
that.
Since
I
recall
kind
of
subtle
code.
B
B
A
E
B
D
E
B
C
A
C
A
A
Okay-
and
that
was
my
least
favorite
part
of
it
all-
I
was
dealing
with
user
annotations,
but
for
the
rest
of
you
who
didn't
suffer
through
that.
The
problem
was
that
we
nll
completely
erases,
like
we
basically
don't
have
any
region
information
that
we
we
kind
of
reconstruct
everything
from
the
mirror,
but
that
worked
great,
except
for
when
users
manually
wrote
things
like
that
has
to
be
carried
forward.
Otherwise
we
use
nothing
from
the
older
classes.
So,
if
you
like
wrote,
let
x
ampersand
take
a
u32.
A
A
C
A
B
A
B
Yeah
I
mean
it.
I
definitely
I
would
like
it
to
be
in
in
small
pieces,
but
I
don't
know
how
well
that'll
work,
because
so
much
of
it
sort
of
interconnected
that
I
feel
like
we
yeah,
we'll
we'll
find
out
we'll
find
out
yeah
somebody
someone's
got
to
play
with
it.
I
don't
have
time
right
now
too,
especially
not
with
the
lit
bound
region,
morph
that
I'm
doing,
but
if
anybody
is
watching
us
and
wants
to
try
it
we're
here
to
help.
C
B
A
Probably
at
least
a
little
chalk
also
has
where
clause
right-
yes,
yeah
at
least
that
part
would
seem
relevant
right.
There's
there
are,
where
clauses
that
don't
no
other,
is
there
any
form
of
where
clause
that
cannot
appear
in
a
predicate,
maybe
some
of
the
weird
ones
like,
I
think,
maybe
not
actually
right.
The
only
thing
I
can
think
of
is
we
do
have
this
sort
of
odd
special
case
thing,
where
I
think
you
can
write
this
like
an
empty
list
of
region
bounds,
and
it
has
some
special
case,
meaning
like
that.