►
From YouTube: Lang Team Meeting 2019.05.16
Description
Discussed RFC 2582
A
A
So
this
issue,
we
talked
a
little
bit
about
last
time.
We
sometimes
leak
values,
I
think
there's
an
example
would
be
in
a
case
like
this,
where
we
have
and
or
rather
the
value
X
is
in
the
process
of
being
assigned,
but
there's
a
panic
while
we
drop
P
will
actually
never
run
the
destructor
for
X
and
we're
looking
into
why
this
is
the
case.
A
I
just
wanted
to
make
a
quick
sort
of
check,
there's
an
assumption
here
that
this
is
a
bug
and
basically
we
shouldn't
be
leaking
and
filling
to
run
destructors
unless
there's
been
a
member
yet
or
an
RC,
or
something
like
that
RC
cycle.
Unless
it's
moved
off
the
stack,
that's
my
assumption.
Does
everyone
anyone
object
to
that?
Now
is
your
chance.
This
has
been
there
since
1.0,
so
it's
a
little
hard
to
call
it
high
priority.
On
the
other
hand,
it's
one
of
those
bugs
really
better
fix
it,
some
point
or
don't
so
on.
A
D
A
B
E
A
A
Well,
I'll
leave
it
as
it
is
for
now.
If
we
want
to
talk
about
in
more
depth,
we
can
do
that.
There's
a
couple
here
things
here
that
about
it.
Should
we
try
to
move
forward
and
stabilizing
them,
so
one
of
them
is
this
wrapper
align
X
attribute
on
enums,
it's
kind
of
intersects,
Ralph's,
unsafe
code,
guideline,
stuff
and
I
guess
a
little
bit
I
guess
this
has
been
proposed,
it's
roughly
equivalent
to
wrapping
in
a
struct
they're,
not
to
I.
C
B
A
A
Central
raise
this
one
underscore
is
as
constant
names.
This
was
an
RFC
a
while
back
that,
let
you
do
constant
underscore
colon
type
equal,
something
there's.
This
was
intended
to
improve
Docs
and
so
on.
I,
don't
know
how
do
we
feel
do
we
think
we
wouldn't
might
want
to
do
it
centrally?
You
might
want
to
talk
about
some
of
these
points.
B
So
if
you
rise,
for
example,
a
derived
macro
at
the
moment,
you
might
include
a
constant
to
like
make
sure
that
names
don't
rush
if
you
important
stuff,
but
when
and
to
make,
because
lands
have
a
sort
of
unique
name
that
doesn't
conflict
with
anything.
So
you
avoid
an
error.
What
people
usually
do?
Is
they
sort
of
make
a
long
name
and
upend
the
name
of
the
talk
to
it
and
then
that
this
impacts
Diagnostics
pretty?
Because
then
you
see
the
name
of
the
constants
in
Diagnostics.
C
I
think,
oh
dear
Lord,
okay,
so
I
have
sorry
back
on
the
retro
line.
Thing
I
actually
just
tested
it
in
playground,
and
you
can
make
a
you
know
them
that
contains
a
huge
64
and
you
set
it
to
a
lion
one
and
it'll
match
safely
and
not
give
you
an
edge
so
that
should
get
fixed
before
we
talk
about
the
stabilization.
B
B
A
B
B
Yeah
the
reason
I
think
it
an
underscore
makes
sense,
isn't
because
of
the
extensions
like
it
would
be
natural
tools
to
extend
this
to
patterns,
and
then
it's
not
inconsistent.
Sort
of
the
one
concern
I
have
is
that
I
would
like
statics
and
constant
items
to
be
in
sync
and
try
not
to
fall
apart
more
than
they
are
they
have
right
now.
B
So,
basically,
if
you
might
understand
starting
on
this
floor,
I
would
expect
that
this
is
this.
Does
nothing
because
you
sort
of
just
dropped
the
static
on
on
the
ground
and
it
really
created
place
in
memory
this?
If
you
pattern
match
and
you
unpacked
like
a
and
B
from
from
the
tuple
of
one
and
two,
then
you
would
presumably
create
two
cases
so
which
you
an
unscored,
that
you
should
create
zero
cases.
I
know.
G
H
A
G
C
I
also
think
really
I,
don't
know,
I
considered,
like
the
actual
impact.
This
is
having
on
people
trying
to
write
code
and
and
who
are
like
on
this
feature
and
doing
other
crazy
hockey.
Things
instead
like
or
do
we
think,
is
better
to
have
this
like
weird
thing
where
you
can
use
it
in
context,
or
do
we
think
it's
better
to
like
force
people
to
continue
doing
weird
hacks,
so
I
mean
I,
don't
think
you
should
I,
don't
think
that
makes
sense.
I,
don't
think
we
should
be
charming.
B
G
A
A
F
F
A
A
A
A
A
A
A
Okay,
so
main
topic
of
the
day
am
person
drawn
RS,
822
582,
how
I
guess
I
wrote
down
a
brief
idea
of
what
we
should
do
should
I
think.
Maybe
it's
used
it's
something
useful
to
review
the
problem
at
least
a
little
bit,
although
I
wonder
who's
who,
in
this
call,
is
familiar
with
this
I'd
like
to
hear
a
brief
summary
to
bring
it
back
of
what
exactly
we're
trying
to
solve
and
why
Ralph
do
you
think
we're
talking
about
it
first
or
should
I
or
someone
else.
F
Yeah
I
mean
basically
the
the
problem.
Is
that
currently
there's
no
way
to
create
a
row
pointer
directly
without
first
creating
or
or
creating
a
reference
and
then
casting
that?
So
in
particular,
if
you
have
a
row
pointer
to
a
struct
and
you
want
to
get
a
row
pointer
to
the
field,
one
of
the
fields
you
have
to
go
through
reference
County,
because
the
only
syntax
we
have
is
to
write
ampersand,
mute
star,
my
appoint,
ordered
field
and-
and
that
creates
a
reference
that
then
we
can
write
a
star
you'd.
F
But
then
the
reference
has
already
been
created
and
that's
a
problem,
because
references
promise
all
sorts
of
things
like
being
aligned
like
being
the
referenceable
for
the
entire,
like
sighs.
If
this
is
a
reference
to
an
integer,
it
must
be
like
the
reference
table
for
four
bytes
and
potentially
like
being
initialized.
We
haven't
finalized
the
invariant
there,
but
you
would
like
not
to
draw
ourselves
into
a
corner.
F
So,
in
particular,
the
use
case
where
this
probably
comes
up
most
often
is
when
you
have
an
uninitialized,
struct
Antti,
doing
the
right
thing
and
using
maybe
a
net
which
is
hopefully
soon
stable.
Then,
and
now
you
want
to
like
right,
get
a
pointer
to
one
of
the
feeds
or
of
the
struts
to
initialize
it.
You
can't,
because
you
have
to
get
a
reference
to
the
field
before
you
can
get
a
pointer
and
the
reference
is
bad,
because
the
feet
isn't
initialized
yet
other
places
where
riders
is.
F
And
so
the
RFC
says
we
should
have
a
way
to
create
a
row
pointer
from
a
place
when
we
have
an
expression
and
without
going
through
a
reference,
and
the
current
version
of
the
RFC
proposes
to
to
use
the
syntax
and
percent
wrong
mute
and
a
percent
roll
Const
to
create
a
mutable
or
Const
role
pointer,
respectively.
I
guess
that's
basically,
however,
if
there
wasn't
only
a
version
which
just
which
suggested
making
this
combination
of
ampersand
blah
blah
blah
mute
special,
but
there
were
some
people
not
liking
that
so
now.
F
G
Pursue
prefer
the
original
version
of
the
RFC
I
think
that
probable.
For
one
thing,
it
doesn't
require
you
to
change
your
easing
code
and
I'm,
not
completely
convinced
if
this
should
have
its
own
syntax.
Instead
of
just
like
the
way
that
people
have
been
writing
it
works,
except
for
the
fact
that
we
don't
want
to
declare
the
semantics
to
work
certain
way
that
doesn't
for
what
they've
been
doing.
A
F
Is
they
print
the
field
of
the
pack
struct,
which
implicitly
creates
a
reference
which
doesn't
get
cast
anywhere
so
for
most
of
the
cases
it
wouldn't
help
for
some
cases
it
would
have.
We
don't
have
any
data
on
getting
a
pointer
to
a
field
of
an
initialized
uninitialized
struct,
because
we
don't
really
have
infrastructure
to
get
that
kind
of
data.
F
F
If
you're
using
coercion,
that
seems
very
subtle
indeed,
because
because
you
kind
of
have
to
do
a
bi-directional
type
system,
kind
of
thing
to
figure
out
the
expect
to
type
or
whatever,
if
you're
using
it,
the
cast
which
I
mean
in
my
head
was
always
the
thing
that
people
should.
Then
it's
it's
fairly
explicit
about
variables.
I.
A
B
F
Once
once
you
have
it
with
coercion,
so
it
gets
interesting
because
what
if
you
don't
have
code
like
this,
but
you
have
like
it
like
a
conditioner
that
you
use
anything
as
an
expression
and
you
have
the
reference
as
in
the
return
in
place,
and
now
does
the
coercion
apply
like
before
or
after
the
block
close
I,
don't
know,
I
mean
all
of
this.
I
have
a
very
clear
model
for
this
in
the
murder.
Well,
none
of
this
is
even
a
question
anymore,
but
on
the
serious
level
it
gets
a
bit
messy.
Yes,.
A
A
C
C
F
That
suggests
that
should
be
a
lint
where,
if
you,
if
you
have
an
ampersand
and
then
we
kind
of
the
Linda,
some
kind
of
whatever
data
front,
something
look
at
all
the
places
for
your
ampersand
gets
used
and
if
all
of
them
are
just
for
pointers,
maybe
you
should
have
written
a
person
draw
constant.
So
basically
we,
the
idea,
is
to
notch
people
when
they
are
writing
and
press
a
mute,
foo
and
passing
that
to
pointer
right,
which
is
a
row
pointer.
D
A
D
B
F
But
certainly
the
lint
would
yeah,
I
don't
think
it
would
hug,
but,
but
certainly
the
lint
would
fire
in
any
case,
at
the
original
version
of
the
IRC
said,
should
have
the
new
semantics
like
when
you
cast
or
an
account
immediately
or
when
you
curse
any
of
those
cases.
The
Lynwood
fires
a
code
that
people
write
today
that
looks
like
this
would
get
the
Lindh,
and
so
they
would
eventually
hopefully
see
that
that
they
can
now
update
and
trip-hop.
Did
they
go
to
the
version
that
actually
works
for.
C
B
C
Gonna
say
this
has
an
interesting
interaction
with
the
the
barring
modes
RFC,
because
you
could
imagine
that
we
could
come
up
with
a
way
to
do
field
access
here,
where,
if
you
pattern
matched
on
like
a
raw
pointer
I,
guess
that
wouldn't
work,
it
would
only
work
for
beautiful
patterns
because
you
don't
want
to
have
to
inspect
the
data
behind
the
raw
planner.
But
if
you
had
an
irrefutable
pattern,
you
could
you
could
you
know
D
structure,
into
pointers
to
the
each
individual
field
without
having
to
link
your
reference,
which
is
kind
of
interesting.
F
F
G
Think
my
hesitancy,
what
this
one-handed
like
bias
like
about
you
know
this
is
how
we've
always
done
it
so
I,
don't
see
why
we
should
change
it
and
I
do
kind
of
feel
like
it
makes
more
sense
to
have
a
first
class
syntax
for
creating
real
pointers
than
doing
coercion
and
castes.
But
I
also
feel
like
it's
unfortunate
that
the
subtext
is
not
connect
like
most
of
our
constructor.
Syntax
is
pretty
connected
to
the
type
syntax
right,
and
this
is
like
completely
disconnected.
G
F
C
I
G
Maybe
looking
more
holistically
it
not
just
this
constructor,
but
like
the
ways
that
raw
pointers
are
currently
confusing,
and
maybe
we
could
create
a
better
user
experience.
It's
that
we
could
try
to
move
people
toward.
Of
course,
we
also
should
at
some
point
postmortem
whether
people
towards
something
I
had
experience
in
2018
was
actually
like.
G
H
G
F
Holistic
Lee.
Another
discussion
that
recently
came
up
that
register
wrong
pointers
is
having
a
post
fix,
D
Rev
operator,
because
it's
really
annoying
with
reponders
that
D
ref
is
prefixed,
because
then
you
end
up
with
like
having
the
star
that
arrives
a
thing
where
you're
far
away
from
like
the
place
where,
if
you
do
training
whether
you've
ever
actually
you
mean
the
arrow
which
is
I,
guess
one
reason
whether
that's
Gong
Kosar,
my
hypothesis,
that
that's
one
reason
why
people
use
walk-on
dress
instead
of
references.
F
F
B
I'm
certain
that,
like
CNC
customers
or
people,
languages
that
I
all-star
would
see
that
and
say.
I
should
use
this
all
the
time
and
they
would
not
use
references.
But
I
would
get
us
an
era
when
using
it
on
references
right
right,
but
they
will
just
keep
to
enjoy
since
then
using
reference,
and
since,
like
most
one
time,
I,
don't
think
that
that's
true
I.
F
D
To
something
that
Taylor
said
made
me
think
of
something
in
some
ways.
Raw
pointers
are
like
variants
of
references
that
have
fewer
guarantees
or
something
like
that.
If
we
imagine
we
could
imagine,
and
the
the
like
ampersand
raw
thing
makes
me
think
in
some
ways
that
this
is
like,
if
we
constant
arif
I'd
and
I'm
going
a
little
bit
crazy
here
for
a
second.
So
apologies
on
that.
D
So
if
we
think
of
the
things
that
of
the
metadata
that
we
attach
to
a
reference,
one
of
them
is
it's
always
aligned
to
the
alignment
of
whatever
it's
a
reference
to
I
could
imagine
a
pointer
type,
that
is,
is
exactly
a
reference,
but
it's
not
it's
aligned
to
some
different
amount,
so
that
could
be
both.
This
is
a
reference
which
is
only
one
aligned
and
thus
is
what
comes
out
of
a
pack.
D
Struct
I
could
also
imagine
a
this
is
a
reference
that
is
more
aligned
than
it
needed
to
be
that
it's
on
some
chip
might
allow
Co
gen
to
generate
different
things
or
something
like
that,
and
then
we
end
up
with
sort
of
a
right.
Now
we
have
the
fully
guaranteed
everything
reference
and
the
nothing
guaranteed
raw
pointer
and
the
there
might
be
a
sort
of
continuum
between
there,
which
is
sort
of
like
what
Taylor
was
saying
of
ampersand
tick.
D
B
D
B
A
C
A
A
Okay,
yeah
yeah,
okay,
I,
see
sure
I,
see
I,
see
what
I
was
wondering
about.
The
reason
I
ask
that
is
they
kind
of
wanted
to
get
a
feeling
like
what
are
the
mistakes?
People
are
making
that
we're
trying
to
fix
like
more
holistically
like
there
was
another
one,
maybe
you'd
be
useful
to
collect
them
like
with
the
is
the
arrow
bar.
Basically,
here
people
were
saying
they're
using
references
that
should
fix
that
yeah
okay
I
mean
the
other
way
to
solve.
This
is
to
change
what
we've.
C
F
Think
it's
getting
bigger
the
latency,
that's
fascinating!
One
of
the
avenues
we
have
one
with
the
dedication
tax
is
that
we
can
deprecated
and
then
the
long
run,
maybe
even
completely
for
a
bit
taking
a
reference
to
a
field
of
the
packet
struct
as
if
that's
always
inside
you
be
so
if
you're,
not
using
a
person
draw
it's
just
wrong
and
that
would
catch
all
of
these
cases
when
people
print
stuff.
F
The
solution
is
to
add
curly
braces
around
this
I'm,
not
sure
if
people
would
know
that,
but
at
least
it
would
like
tell
them
that
they
are
wrong.
Ideally,
we
can
affect
Diagnostics,
but
that's
Atlee.
We
can
do
similar.
Things
have
been
proposals
about
static,
mute
being
dangerous
because
you
end
up
with
these
really
long
lifetime
references
that
get
all
sorts
of
areas
who
you
don't
want.
F
A
A
You
just
want
to
raise
that
I.
Guess
it's
totally
crazy,
but
you
know
the
other
way
to
solve.
This
would
be
not
to
to
somehow
change
the
not
require
that
all
references
are
always
aligned,
I
guess
what
I
said
we
don't
have
to.
We
require
that
all
references
are
aligned
presently
in
the
way
we
generate
our
LLVM
and
so
on.
But
it's
not
like
those
rules
are
completely
unalterable.
A
E
F
A
I
guess
I
personally
sort
of
like
the
idea
of
an
unsafe
code
or
economics
initiative.
So
basically,
I
think
writing
on
zip
code
can
be
a
real
pain
and
it's
something
that
people
have
to
I
feel
like
making
it
easier
to
do
it
correctly
and
just
easier
is
a
win
all
around,
but
in
light,
I
like
this
concept
is
not
sure
that.
B
G
B
G
B
B
C
Think
also
that
writing
unsafe
code
today
adds
a
lot
of
verbosity
in
places.
Where
are
you
like?
Don't
really
care
about
it
and
doesn't
give
you
enough
ferocity
and
a
lot
of
the
things
like
just
like
function
call
sites
and
things
like
that
can
be
super
super
dangerous
and
like
the
worst
parts
of
unsafe
code
and
they're
like
no
no
less
ergonomic
or
have
no
extra
data
on
them
than
the
normal
safe
code
does,
whereas
things
like
pointer,
do
you
like
actually
you'll,
hopefully
mean-variance
it?
Oh.
C
You
know
that
to
store
this
thing
in
it
in
like
a
thread,
local
variable
or
something
or
I-
need
to
store
it
somewhere
and
do
something
and
like
so
I
need
these
lifetimes
to
be
static.
They're
not
really
static.
I
just
need
to
pretend
that
they're
static
and
so
I
have
to
like
do
all
these
crazy
pointer
casts
and
stuff
for,
like
mem
transmute
all
of
the
plate
over
the
place
when
I
really
want
like
something.
That's
clean
and
nice
and
says,
like
give
me
a
static
lifetime
for
everything
in
this
type
flight.
B
B
C
F
So
we
wanted
to
be
true
that
if
you
Vic
push
to
a
vector
that
has
enough
capacity,
the
existing
pointers
remain.
Okay,
we
have
arena
or
implementations
relying
on
that
and
stuff,
but
at
least
if
you
enable
stack
Burroughs,
that's
coming
off
the
case,
because
the
deck
push
implicitly
without
writing
anything
called
de
Graaff
mute,
which
creates
a
raw
pointer
covering
the
entire
vector
which
kills
previously
created.
Sorry,
a
mutable
reference
covering
the
entire
vector
which
kills
previous
Ponder's,
because
I'm
using
reference
is
unique.
E
Well,
to
be
clear
is
just
do
the
internals
of
this
is
not
because
the
implications
back
push
is
because
it's
a
method
call
on
ampersand.
You
method
right,
that's
using
your
app,
you
know
it's
cuz.
It
is
because
nothing.
This
is
through
the
actual
body
of
that
push
yourself
not
due
to
the
way
method
calls
dear.
It
isn't.
Okay.
A
A
little
ice
used
about
white
how
this
happens
because
it
exactly
around
that
point:
I
guess
so,
when
you
call
that
duck
push,
it
gets
an
Amazon
mute
to
the
Veck,
but
somewhere
in
there
it
also
gets
an
amp
see
a
mute
slice.
Is
that
the
idea
and
that
causes
a
problem
or
like
when
does
the
guys
into
the
back
I,
have
everything
in
the
issue?
Okay,
that's
fine,
I!
A
Definitely,
I,
guess.
The
reason
Taylor
I
got
excited
about
your
comment
is
that
it
does
match
some
feeling.
I
thought
I'd
I
have
to
go
fish
up
things,
but
I,
remember
one
specific
time.
I
remember
is
when
doing
the
gnome.
You
know
facing
code,
but
just
various
places
where
I
was
like
I'm
writing.
A
lot
of
random
casts
here
and
I
know
really
feeling
this
is
making
my
code
like
easier
to
understand
anyway.
B
A
For
costume
would
be
between
map
I
know,
one
one
specific
bug
that
they
got
it
really
got
me
which
had
to
do
with
testing
was
that
if
you
cast
a
fat
pointer
to
a
thin
pointer
it
like
strips
a
label
and
then
I
forget
exactly
how
but
I
somehow
got
a
different
view,
table
reattached
or
something
like
that
and
who
was
really
killing
me
for
a
long
time.
Yeah.
G
G
Think,
like
this
perfectly,
it
just
seems
like,
like
the
like.
The
whole
notion
of
our
Restless
be
empowering
idea
that
we
would
I
was
we
can
question
the
priorities
of
working
on
organized
events
of
cook
idea
that
we
would
not
make
unsafe
code
easier
to
write,
because
then
people
would
use
it.
It
is
like
totally
I
think
at
odds
with
that
value.
I
think
that
we
should
trust
users
to
like
not
use
unsafe
code
when
they
shouldn't.
C
Mean
particularly
a
lot
of
what
happens
is
that
they
don't
go.
Oh
I'm
gonna
go
write
this
in
safe
code.
Instead
because
it's
a
fundamentally
unsafe
operation,
they
go.
Oh
I'm
gonna
write
it
and
see.
Instead
right
cuz,
it's
cuz,
it's
more
like
when
I
write
it
and
see
it's
easier
to
read.
What's
going
on
because
I
don't
have
all
this
clutter
from
like
rust,
making
unsafe
super
or
bows.
B
So
I
guess
one
social
convention
that
we
could've
constantly
where
we
couldn't
you
know.
So,
if
we
work
should
establish
social
conventions,
then
I
guess
in
a
bunch
of
cases,
people
don't
write
comments
about
their
own
say:
it
happens,
a
bunch
in
the
compiler,
a
10-round
library,
there's
no
comments
and
I
think
insight
by
D
summers.
Long
that
mean
that
happened
was
because
of
the
lack
of
comments
like
if
anyone
had
written
anything
about
why
this
is
unstable
and
why
it
is
not
hidden
and
then
we
wouldn't
have
stabilized
it.
G
Lemmings
originally,
that
distinction
is,
we
can't
make
guarantees,
but
like
we
don't
have
taking
on
those
operations
like
I,
don't
think
that
it
has
to
do
with
dressing
eaters.
It's
like
that
means
like
there's
certain,
like
the
annotations,
that
we
have
created
a
certain
amount
of
like
overhead.
That's
inherent,
which
I
think
is
fine
and
also
like
does
help
diagnose.
G
You
know,
do
static
analysis
and
things
with
some
additional
overhead
of
like
having
like
annotate
specifically
what
operations
you're
allowing
this
because
of
which
invariants.
Let
me
say
why
just
making
just
not
trying
to
make
it
pleasant
to
use
on
the
idea
that
then
we
don't,
because
we
don't
be
able
to
use
it.
It's
like
not
I,
think
I
think
you
just
concert
to
the
idea
that
rust
is
trying
to
achieve.
A
Don't
understand
just
this
line
of
reasoning
like
I
understand
what
your
equated
central
like
having
a
having
a
distinction,
which
means
safety.
Unsafe
code
is
one
thing,
but
that
makes
a
lot
of
sense,
but
I
think
what
you're
saying
is
that
you
won't
like
we
have
to
make
it
for
both
I.
Don't
know
no.
B
Unzip
is
valuable,
is
one
you
have
you
have
like
explicit
Stokes
or
when,
when
things
happen,
and
because
it's
limited,
but
it's
not
everywhere,
but
if,
if
you
have
too
much
of
it,
then
it's
not
using
its
value.
I'm,
not
saying
that
one
solution
necessarily
being
like
under
economic,
which
is
the
distance
between
C
and
unquote.
G
I
also
I,
don't
know,
there's
no
point
in
it.
You
also
think
said
earlier.
They
don't
agree
with,
which
is
that
uncie's
could
value
is
from
fact
that
it's
rare
I,
don't
think.
That's
true
I,
think
that,
like
the
actual
value
of
of
zip
code,
is
that
these
particular
invariants
that
you're
upholding
with
it,
you
can
create
a
safe
interface,
but
then
no
one
else
has
to
care
about
like
on
see
if
code
way,
their
system
work
still
has
a
normal
amount
of
value.
G
G
B
When
you
have
made
those
same
faces,
then
there
budget
libraries
that
don't
have
to
care
about
them.
So
you
have
reduced
your
adjustment
computing
base
overall,
maybe
not
in
that
specific
library,
but
in
the
ecosystem
as
well,
but
I
mean
I,
do
agree
with
the
encapsulation
points.
I
made
it
myself
before
so
I
thought.
B
A
Be
a
good
idea:
I
just
want
to
interrupt
and
point
out
that
we're
at
58
minutes
in
I
don't
know
what
we
reached.
It
seemed
like
we
diverged
pretty
broadly
from
the
specific
RFC.
But
yes,
is
it
safe
to
say
that
we're
not
particularly
keen
on
introducing
the
syntax
in
isolation?
I,
don't
know
it
seems
like
we
need
some
way
forward
here,
but
we
also
have
I'm.
B
G
G
The
scale
of
this
change
seems
quite
dramatic,
but
yeah
exactly
that
it's
actually
very
huge,
even
though
it
doesn't
like
you
know.
Only
a
few
cases
are
currently
under
fund
behavior.
That
actually
is
sort
of
part
of
the
problem.
Instead,
like
they're,
a
very
small
number
people
who
are
currently
heavy
because
it's
the
way
that
we
do
it
and
we
would
tell
everyone
to
change
because
of
that
is
where
the
balance
feels
kind
of
one
will.
B
A
F
People
not
to
do
not
not
use
uninitialized
structs,
and
we
have.
We
have
a
module
talk
that
says
so.
Here's
how
you
do
initialization
for
arrays
and
office
trucks,
so
it's
like
I
feel
like
if
we
wait
until
we
have
solved
the
holistic
and
unsafe
code
economics
problem,
it's
gonna
be
taking
a
bit
too
long.