►
From YouTube: Lang Team Meeting 2019.06.06
Description
Main topic: std-aware cargo
B
B
A
Before
we
go
so
for
those
of
you
from
the
cargo
team,
usually
we
start
with
some
light
triage,
which
probably
will
be
boring
for
you.
Oh
yes,
we
show
that
and
then
we'll
get
to
the
standard
aware
of
cargo
should
I
switch
the
order
of
things.
We
could
do
that
that
won't
work
for
me.
If
we
want
to
start
with
discussing
standard
or
cargo
and
then
switch
back
I,
don't
expect
well,
I,
don't
know,
let's
try
that
all
right,
I
think.
D
D
Right,
so
this
RFC
is
quite
old
at
this
point
and
I
believe
pretty
eated
to
the
point
that
a
lot
of
things
have
changed,
just
the
general
background
and
kind
of
where
it
wants
to
go
from
what
I
understand
the
very
high
level
motivation.
Is
it
kind
of
sucks
that
cargo
doesn't
really
understand
that
every
crate
in
the
world
depends
on
stood
or
court
or
whatever
sister
said?
This
is
your
case.
D
There,
and
so
the
goal
of
this
RFC
is
to
basically
enable
that
in
one
form
or
another,
and
so
it's
largely
a
carbon
related
thing
as
far
as
I
know,
as
I
suspected
with
my
touch
language
stuff
as
well
in
terms
of
crates
and
sisters
and
whatnot,
but
that's
sort
of
the
general
thrust
and
then
the
actual
details
of
the
RFC
I
think
have
changed
a
lot
over
time.
It's
sort
of
unclear
like
what's
in
cargo
tamil,
what
exactly
is
inferred
where?
What
exactly?
When
does
cargo
recomposed
any
library?
D
When
is
it
not
recomposed
in
your
library
and
so
I?
Think,
at
least
from
my
personal
opinion,
we
probably
want
to
keep
today's
system
by
default,
which
is
if
I
type
Karl
go
to
Linux
I'm,
not
going
to
recompile
the
standard
library
just
keep
using
whatever
I
previously
downloaded.
But
somehow,
when
something
reasonable
happens,
maybe
we
do
switch
to
the
mode
compiling
things
is.
B
D
I
think
that
so
number
one
it
would
be
a
big
compile
time
we
hit
it's,
not
huge.
The
standard
library
actually
compiles
pretty
quickly.
It
is
noticeable
for
like
a
hello
world,
but
I
also
think
it's
an
issue
in
terms
of
just
functionality.
Sometimes
we
have
like
building
Lib
batteries
for
standard
stuff
like
having
a
C
compiler
one
way
or
another.
D
We
don't
typically
need
that,
but
users
don't
always
have
a
fully
configured
environment
that
is
guaranteed
to
compile
those
kinds
of
things
and
so
for
those
use
cases,
it's
often
very
useful
for
us
to
build
it
ourselves
and
then
ship,
something
that
we
know
works
to
users
or
something
like
that.
So
that's
a
much
more
esoteric,
the
in
the
build
time
which
is
and.
F
G
D
A
Sense
things
so,
there's
the
first
of
all
I
think
earlier
you
were
saying
there
was
fair
amount
of
lis
interaction.
You
want
to
outline
some
already
had
in
mind,
but
I
did
have
a
few
other
questions
too
about
features
and
stuff
I'm,
not
sure
how
off
to
date,
this
cuz
I
was
looking
over
my
pronounce
like
there's
some
notion
of
the
features
like
basically
Pargo
features
applied
to
live
standard,
great.
D
So
the
idea
here
is
that
it's
there's
nothing
stable
if
initially
and
we
as
a
lips
team
would
decide
what
features
are
stable,
but
the
idea
is.
This
would
eventually
allow
for
tweaking
the
function
a
little.
Everyone
really
other,
so
removing
binary
blue
via
a
number
of
mechanisms,
switching
implementations
for
whatever
reason:
okay,.
A
A
D
D
And
so
this
is
one
where
I
think
this
is
sort
of
an
end
goal
really
want
to
get
to
a
system
where
we
can
do
this,
but
we're
not
gonna
stabilize
this.
Unless
we
actually
are
confident,
we
have
a
non-breaking
thing.
It's
like.
Maybe
we
just
say
that
you
can't
turn
off
default
features
of
core
or,
like
a
feature,
has
no
default
feature.
A
B
Basis,
it
seems
to
me
that
removing
features
isn't
that
problematic,
because
it's
most
like
from
a
testing
point
of
view,
you
simply
comment
out
code,
whereas
with
switching
implementations,
then
you
need
to
test
those
implementations
and
consume
ibly
have
like
specific
builders
for
that?
How
can
you
keep
up
with
the
quality
in
terms
of
having.
D
Yes,
and
from
what
I
understand,
I
I
think
I'm,
also
I'm
speaking
I,
like
slightly
mixed
up,
because
I
actually
thought
this
was
mostly
about
the
really
really
old
are
sees.
This
is
actually
far
more
recent,
but
Green
is
back
into
mind.
This
is
from
discussions
at
the
All
Hands.
So
this
is
I.
Haven't
mentioned
this
in
the
library
a
lot,
but
this
is
also
sort
of
equally
applicable
decor.
D
B
B
D
And
that's
like,
basically
than
one
of
the
number
one
concerns
about
these
target
specifications,
but
I
think
it
also
goes
further
here
in
terms
of
not
so
much
LOV
em,
but
just
the
current
day
and
age
of
the
compiler
see
where
the
target
specifications
have
been
changing
all
the
time.
As
we
add
random
options
for
remove
random
options,
we
just
stop
interpreting
some
options,
and
so
it's
not
so
much
for
me,
it's
not
so
much
an
LVN.
This
is
the
compiler
to
question.
So
there's
not
really
a
library.
D
D
But,
and
also
to
reiterate,
this
RFC
was
explicit
explicitly
written
would
especially
when
I
talk
with
him
about
this
was
to
propose
various
phases
and
so
I
think
like
it
gets
much
more
questionable
as
time
goes
on
in
terms
of
like
whether
we
want
to
stabilize
all
of
that.
But
the
intention
was
that
there
should
be
some
kernel
subset,
which
is
very
useful
to
everyone.
Where,
maybe
you
don't
you
don't
touch
features
at
all?
You
don't
touch
about
new
targets.
All
you
can
do
is
on
the
standard
library
and
liqueur
on
the
stable
channel.
B
D
This
is
where
every
single
compiler
is
paired,
with
exactly
one
copy
of
the
standard
library
that
it
can
compile,
and
so
we
can
guarantee
on
stable
that
it
can
compile
its
own,
stable
and
so
cargo
will
basically
just
set
the
receive
stripe,
flag
and
say,
and
but
cargo
will
do
that,
knowing
that
it's
guaranteed
to
work,
because
it's
the
exact
source
code
and
so
every
channel
is
a
company
with
its
own
source
code,
and
so
they
can
all
compiled
its
own
source
code.
So.
B
D
A
B
B
C
Be
clear,
my
question
was
more:
it
wasn't
about
the
the
mechanism
we
used
to
enforce
the
consistent
variant.
That
describe
is
one
of
the
environment
in
the
RFC
and
I
now
see
the
invariant
he
described,
but
the
source
code,
the
1:1
mapping
from
the
compiler
version,
the
source
code.
It
is
actually
the
RFC
itself.
I
shall
make
sure
that
was
spelled
out
there.
A
B
D
This
is
sort
of
like
the
fundamental
kernel
of
all
nightly
users
and
things
like
that,
and
so
they
might
still
be
doing
crazy,
Netley
things
where
they're
touching
my
items
are
doing
various
aspects
but
they're
building
on
the
stable
baseline
of
where
recompile
assign
a
library
and
then
linking
things
in
later
and
then
otherwise.
If
you're
just
recap
on
the
state
of
library
plus
liqueur,
and
you
make
it
executable,
although
I'm
sort
of
provided
for
you
need
a
lot
starch,
the
middle
right.
A
D
Example,
where
I
think
it's
maybe
the
best
story
today,
is
that
I
think
with
enough
support
and
the
embedded
ecosystem.
At
this
point,
you,
if
you
put
if
you
have
a
crate
with
a
panic,
Handler
and
you
have
lib
core,
compile
with
pinnacle
board,
then
you
can
link
executables
that
only
have
low
core
that
don't
leave
the
standard
library
when
you
probably
also
grain,
allocate
or
somewhere
at
some
point.
D
But
if
you
compile
lib
core
with
panic
on
whines
and
you
tried
to
create
an
executable,
you
just
can't
do
that
on
stable,
and
so
it's
like
only
in
this
one
compile
mode.
It's
kind
of
secretive
that
now
you
can
produce
a
stable
executable,
but
if
you
compile
it
on
a
different
mode,
you
can't
produce
an
executable
on
stable
and
so
I
think.
D
The
idea
is
there's
some
like
atoms,
which
are
defined
by
stood
which
are
primarily
allocator
and
the
panic
Handler
and
it's
probably
gonna,
be
a
couple
of
the
random
ones,
but
it's
kind
of
like
we
try
to
work
without
it
if
possible.
But
it's
not
really
well
documented
in
what
situations
you
do
work
without
it
or
how
you
have
to
compile
things
of
that
point.
If
that
makes
sense,
so.
A
A
If
we
currently
don't
require
a
I
guess,
I
would
say:
I
currently
consider
it
sort
of
a
best
effort
that
we
try
not
to
require
more
laying
I
understand
necessary.
But
if
it's
really
inconvenient,
we
don't
try
that
hard.
You
know
you're
supposed
to
have
them
around,
and
this
sounds
like
it
would
definitely
be
on
mild
stability.
Hazard,
query.
It
used
to
work
without
this
link
item
and
now
doesn't
it.
B
C
D
In
terms
of
compelling
implementation,
this
is
it's
basically
only
effects
for
as
far
as
I
know,
laying
items
that
are
in
a
locker
stood
just
anything
above
quarter
because
you
may
not
have
a
locker
stood
and
so
like
there
is
the
ability
to
have
an
inherent
like
methods
on
stir,
if
you
like
Alec,
and
so
the
compiler
just
has
to
be
ready
used
for
like
oh
well.
Now,
maybe
some
crates
don't
like
to
Ella,
but
I
can
never
sort
of
crates
do,
and
so
there
could
be
like
some
interesting
details
in
the
compiler.
D
Like
the
other
larger
examples,
though,
I
mean
the
panic
and
the
panic
handle
is
probably
the
biggest
one
where
it
has
like
random
symbol,
references
and
or
compiler
intrinsic
for.
If
you
have
Pentagon
line
mood
and
that's
why
cuz
core
itself
has
to
reference,
those
somehow
have
to
be
pulled
in,
but
a
lot
of
this
isn't
necessarily
laying
out
on
business
more
so
like.
How
do
we
know?
What's
in
library
both
on
the
compiler
side
flavor,
so
I
was.
A
D
A
D
A
That's
basically
like
itself,
but
another
example
would
be
things
like
f/32,
runtime
or
whatever,
which
is
in
those
dangers
but
I'm
not
so
concerned.
Examples
I
see
at
least
don't
seem
that
hard
for
the
compiler
to
deal
with
I'm,
not
being
there,
because
it's
not
like
we
just
there
are
no
methods.
There
are
no
methods.
B
B
H
B
A
I
said
we
would
talk
for
about
30.
Let
me
talk
for
about
22
minutes,
I'm
wondering
in
the
last
little
bit
is
there
it's
just
like.
There
hasn't
been
a
lot
of
length
een
like
really
correlate
team
concerns
here.
Is
there
something
we're
missing
anyone?
Think
of
things
like
splitting?
The
RFC
feels
like
a
maybe
it's
good.
Maybe
it's
not
that
it's.
D
E
I
had
a
question
about
that.
There
was
an
RFC
and
Aaron
had
a
blog
post
about
how
he
would
like
to
see
sort
of
core
an
STD,
merge
and
then
used
features
to
select
exactly
which
things
are
enabled.
Is
that
still
any
desire
to
have
that
or
is
it?
Is
it
like
core
and
STD
are
always
going
to
be
separate.
E
B
F
Sure,
sorry
I'm
not
sure
if
we
were
just
talking
over
each
other,
but
I
think
that
it's
already,
you
know
pretty
clearly
observable
via,
like
the
actual
linking
arcs
and
things
that
you
give
to
rusty.
When
you
compile
programs
that
there
is
a
distinction
between
those
as
crates
and
as
like
units
of
compilation
right.
D
D
D
A
lot
of
ideas
about
how,
like
maybe
core,
will
just
react,
sport
all
stood,
and
so
it
dependency
will
go
the
other
way,
but
you
just
can't
really
tell
and
so
like.
Maybe
if
you
depend
on
corn
cargo
Tommy,
we
actually
depend
on
student,
but
with
less
features
or
whatever
it's
all
sort
of
magical
and
hand
wavy
and
like
I'm,
not
personally
convinced
the
future
will
ever
come
about,
but
just
for
a
lot
of
these
reasons.
F
So
today,
to
give
an
example
of
the
thing
that
I
was
talking
about
in
know
stood
programs.
We
don't
pass
a
linker
org
that
allows
rusty
to
find
Lipsy,
and
so,
if
you,
if
you
try
and
compile
something
for
fuchsia
with
without
that
is
that
is
no
stood
today
it.
It
would
fail
the
compile
and
in
this
world,
where
we
it,
where
we
had
like
merged
the
crates
into
one.
E
F
Right
but
we
can't
have
multiple
compilations
of
stood
right
in
in
the
same
program
or
in
the
same
look
like
linked
artifacts,
but
we
need
to
be
able
to
link
some
objects
without
the
standard
library
and
without
Lib
C
and
not
other
objects.
B
A
Don't
know
I,
don't
care
lips,
you
can
decide
if
they
want
to
cook
them
still
longer
I
feel
like
it.
I
feel
happy
and
I
be
in
this
discussion.
I,
don't
see
a
lot
of
yeah
that
doesn't
where
the
point
of
a
discussion
was
to
feel
make
sure
yeah
all
right
should
we
do
it
switch
to
triage
and,
like
these
four
people
actually
chewed
out
all
right?
No,
you
can
stay
or
not
thanks.
Everybody
Thanks.
B
A
B
B
A
Yeah,
we
could
talk
about
that,
so
you
had
this
on
the
radar
for
a
long
time.
I
think
both
was
going
to
write
her
some
responses.
Nothing
yet
I
also
have
been
looking
over
it
and
I
feel
like
I.
Have
my
own
personal.
Take,
which
is
I
would
like
to
see
us
be
kind
of
on
the
overall
plan
and
like
to
work
out
some
examples.
A
little
more
I
think
we
probably
do
know
the
overall
plan.
I
just
won't
feel
I.
A
Have
it
like
all
in
my
head
in
cash
I
actually
thought
the
RFC
had
a
pretty
good
summary.
Don't
when
I
read
it
reread
it
last
night,
so
it
seems
like
there
could
be
grounds
for
some
kind
of
meeting
to
talk
it
over
in
depth,
but
that's
probably
separate
from
quotes
and
specific
concern.
Although
we
could
talk
about
that.
A
B
A
A
A
A
B
G
A
G
B
G
F
A
B
A
F
To
express
all
the
things
either
way
the
night,
neither
of
them
allows
you
to
do
a
thing
that
wouldn't
be
expressible
under
the
other,
but
one
of
them
would
require
you
to
write
multiple
other.
If
you
wrote
the
explicit
existential
type
syntax
today
on
nightly,
you
would
have
to
use
multiple
existential
types,
and
some
of
them
would
have
to
have
generic
parameters
that
they
don't
have
today.
Sure
that.
F
It's
not
I,
think
I'll
write
up
some
examples
on
the
RFC
thread
to
clarify
this,
but
it's
not
as
trivial
as
you
would
think,
because
when
you're
declaring
it,
for
example,
inside
of
a
treat,
it
needs
to
capture
the
self
type
and
other
generic
parameters
and
scope
in
the
trait.
But
you
can't
actually
declare
that
extension
type
as
it
as
a
trait
part
of
the
trait.
So
you
have
to
declare
it
outside
and
then
just
pass
in
all
those
parameters.
F
F
A
Want
to
do
that
might
be
an
untrue,
but
the
other.
That
is
one
possible
way.
I
mean
one
Avenue
for,
but
it
seems
like
we
well.
Both
should
do
some
thinking,
but
we
should
also
is,
if
we
I
mean
I,
think
I
I
feel
like
it
wouldn't
hurt
us
to
like
I,
think
both
original
concern
about
the
teaching
and
so
on,
or
the
sort.
A
That's
still
a
nice
I,
I
sort
of
fundamentally
feel
like
people
are
going
to
want
to
write
infiltrate
anywhere
that
they
can
I
should
work
out
what
all
the
semantics
of
where
you
are,
and
that
and
that
and
work
on
the
teaching
from
separately.
I
mean
like
we
have
that's
what
they're
gonna
want
to
write,
whatever
you
give
them,
but
I
also
I
still
think.
That's
a
was
a
important
insightful
point
and
I'm
kind
of
wondering
I,
don't
know
I'm,
basically
feeling
like
I'm,
not
satisfied.
If
you
haven't
clear
plan
forward
and
ask.
B
F
B
B
Moving
on,
we
have
up
here
from
mentoring,
go
to
allow
CFG
fans,
eg
attributes
on
generic
parameters.
We
already
allow
attributes
on
generic
parameters,
but
not
the
edging,
specifically
because
a
little
bug
that
we
actually
not
fix
and
that
we
forgot
to
England
and
I
have
actually
this.
It
should
be
like
very
trivial,
and
you
knew
it.
A
A
A
I,
don't
recall
what
the
orison
said
about
these
cases.
Maybe
it
just
left
them
to
work
or
maybe,
if
they
were
explicitly
disallowed,
someone
wrote
a
PR,
they
kind
of
implements
it
and
the
question
was:
what
should
they
do?
It
shouldn't
ask
for
an
artesian
Landover.
This
feature
gate
for
what
it's
worth.
I
already
left
a.
F
A
Have
this
case
of
a
closure?
That's
called
from
two
different
places
because
of
the
current
design,
I
I'm.
Sorry
Nico.
Can
you
clarify
that,
because
we're
doing
the
coercion
based
on
the
expected
type,
that's
propagated
down?
That
basically
means
we
know
that
it's
being
assigned
to
a
location
that
has
the
type
extra
CFM.
So
there's
no
melius
with
another
adi.
F
A
F
A
This
would
be
an
error.
Basically
I'm
saying
is
this
closure
expression
itself
I
think
has
to
have
the
type.
The
way
we
do
these
collisions
has
to
have
it
touch.
The
coercion
has
to
be
known
at
that
exact
spot,
so
the
type
of
the
we
coerce,
the
actual
r-value
like
it,
never
gets.
There's
no
alias
Oh,
interesting.
Okay.
A
However,
I
would
say
that
in
general
I
think
we
could
it's
kind
of
a
side
comment,
but
I
think
we
could
be
more
liberal
about
maybe
ice
and
basically,
whenever
you
coerce
from
the
zero
size
type,
who
represents
a
function
to
a
function
pointer,
we
presently
require
it
to
have
the
same
API
as
you
grow
up,
but
you
don't
need
to
have
that
requirement.
We
could
make
wrappers
right.
A
F
Well,
because
we
already
have
we
are,
you
can
already
do
this
with
function
items
right
where
you
can
pass
the
same
like
function,
item
name
into
multiple
things
that
expect
like
a
function
pointer
or
an
unsafe
function,
pointer
or
you
know
something
like
that
right
and
it'll
coerce
differently
in
each
location.
In
that
case,
it's
a
different
like
it
sort
of
a
different
like
value
expression
or
place.
I,
don't
know
what
will
work.
It's
an
arm
value
whatever
those
things
are.
I
could
be
wrong
about
the
where
the
coercion
takes.
My
memory.
A
B
A
F
F
F
F
F
B
A
B
A
B
A
F
A
A
G
G
What
the
error,
what
the
none
should,
what
status
got
its
report?
I?
Think
we
should
let
the
lid
team
decide
that,
because,
when
we
did,
this
was
a
result
and
we
decided
to
use
the
debug
output
that
was
ultimately
like
users.
Similar
thing
I
was
wrong.
Mistake:
nineteen
that
kind
of
happened
because
we
decided
when
maybe
it's
marvelous
issue
and
maybe
lives.
Experience
would
be
more
relevant
here.
I,
don't.
F
Feel
strongly
either
way.
I'm
help
me
no
I,
think
yeah
I
mean
III.
Guess
I
would
have
more
opposition
to
this.
If
the
return
code
was
anything
other
than
the
one
that
seemed
obvious
to
me,
but
but
I
mean
mostly
I
feel
like
this
is
just
a
thing:
I
wouldn't
use
em.
It
seems
weird,
it
seems
surprising
in
a
way
that,
like
I.
F
B
B
So
we
are
skipping,
looks
like
ID,
because
it's
not
relevant
right
now,
so
moving
on
so
I
would
actually
prefer
to
talk
about
the
slice
thing
for
concerts.
Just
what's
the
slice
of
this,
the
slice
is
this
no
in
denominator,
Darcy,
first
to
go
ahead.
B
A
B
B
B
F
B
G
A
Just
been
traveling
a
lot,
which
is
why
I
keep
pushing
his
back,
but
I
think
things
happen.
Indistinct
you
don't
have
a
lot
scheduled
passing
should.
C
G
I
think
so,
for
you
thinking
like
I've
written
a
stabilization
report,
I'm
gonna
email,
you
a
gist
version
of
it.
I
think
it
doesn't
have
his
links.
Previous
discussions
didn't
need
to
be
added.
However,
I
was
going
to
do
that
into
us
today,
but
in
this
situation
involving
send
has
occurred
and
so
I
think,
depending
on
how
that
conversation
is
going
yeah
either
we
should
talk
about
that
or
we
should
talk
about
or
I
will
or
next
Thursday
I
will
post
a
stabilization
and
we
can
talk
about
other.
G
A
B
F
Think
that
the
feeling
was
that,
because
it
might
change
the
syntax
for
traits
and
we
wouldn't
want
to
have
a
syntax
or
traits
that
was
different
than
the
syntax,
we
used
in
free
functions,
and
so
we
might
want
to
adopt
something
different
for
free
functions
which
are
part
of
what
we're
stabilizing
right.
Yes,.
G
Think
that
we
should
be
really
active
on
this,
and
possibly
it
will
like
it
seems
like
this
we're
going
to
talk
about
the
other
alternative.
Is
that
like
before
then
it
becomes
obvious
that
we're
not
going
to
do
this,
in
which
case
I
will
just
post
stabilization
support
and
then
that's
what
we'll
talk
about
all.