►
From YouTube: Languages & Runtime: .NET Community Standup - April 9th 2020 - All Things C# with Mads Torgersen
Description
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.
A
A
Hello
friends
of
the
net,
my
name
is
Damon
birth.
Welcome
to
the
I,
don't
know
646
episode
or
the
community
stand-up,
no
idea,
or
maybe
episodes
we
have
do.
They
have
a
bunch
of
fantastic
people
with
me
and
I
think
we
should
probably
start
with
introducing
themselves
from
the
top
left
to
the
bottom
right.
Good.
B
D
C
Hi
I'm
Matt
I'm,
not
on
the
see
sure
compiler
team,
but
I
am
also
a
c-sharp
language
designer.
So
you
get
to
be
here
with
these
guys.
A
It's
awesome
so
today
we
want
to
talk
about
everything
related
to
c-sharp
right.
So
if
people
in
the
chat
should
ask
questions
anything,
you
always
wanted
answer
it.
Now
is
your
time
to
ask
and
every
once
in
a
while,
I
will
go
over
the
questions
and
hopefully
get
you
some
cool
answers
and
other
than
that.
There's
some
cool
demos
that
I
think
we're
gonna
do
so
now
I
hand
it
off
to
the
other
people.
C
The
general
idea
loosely
speaking
for
many
years
as
being,
can
you
do
sort
of
more
abbreviated
data
types
where
you
don't
have
to
say
so
much
boilerplate,
and
can
they
also
be
more
like
values
more
like
data
and
less
like
objects
and
so
on?
And
so
we
we
finally
gotten
into
full
sync
mode
on
that
and
we're
pretty
far
along
and
E's
built
a
prototype
we
can
or
is.
C
But
we
have
some
public
bits
that
you
can
access
in
sharp
lab,
for
instance,
so
we
can
play
around
with
a
little
bit
that
I'm
sort
of
very
early
on
that,
and-
and
we
can
also
talk
about
how
we
envisioned
a
bigger
feature
set
so
I
think
that's
kind
of
what
we're
planning
to
to
show
for
a
bit.
So
should
we
digest
right
in
and
talk
a
little
about
records,
it.
C
C
Okay,
good,
let's
not
wait
for
it
to
show
up
and
on
the
stream,
because
there's
a
little
bit
of
a
lag
here
yeah.
So
the
idea
is
essentially
that
you
want
to
write
something
very
short
and
you
want
to
get
a
whole
lot
out
of
it.
That's
like
that's
the
evolution
of
c-sharp
right
there
in
a
nutshell,
since
v1,
but
the
the
syntax
that
we
have
in
the
bits
currently
up
there.
It's
probably
going
to
change
is
that
you
can
save
data
class
instead
of
just
class.
C
C
D
C
You
notice
on
the
left
here
we're
sorry
on
the
right.
You,
you
see
that
a
whole
lot
of
CTR
quit
generated
all
of
a
sudden.
It
generates
a
property,
it
generates
a
some
equality
and
there's
more
that
it
will
generate
that
is
not
in
this
in
this
in
these
yet,
but
we
can
see
now
if
we
go
to
the
program
and
start
using
them,
I
can
I
can
create
a
person.
I
do
indeed
have
a
first
name,
even
though
it
looks
like
I
just
declared
that's
a
parameter
here.
C
C
That's
a
general
idea
here
before
we
dive
in
maybe,
let's
see
if
there
are
some
questions
or
if
people
want
to
come
in
on,
like
my
colleagues,
so
one
question
we
got
is:
will.
E
Should
let
me
see
if
this
works
in
my
copy
of
Charlotte
before
I
said
anything
about
it,
but
the
idea
would
be
that
these
are
kind
of
the
default
implementations
and
that
you
can
provide
your
own
implementations
if
you
want.
So,
if
you
have
a
auto-generated
property
called
first-name,
you
normally
would
be
able
to
type
it
out
yourself
and
then
make
it
a
Get,
Set
property
I'm.
C
E
E
C
E
C
E
Of
Andy
yeah,
that's
that's
pretty
much
what's
been
implemented
so
far,
some
things
that
are
in
review
right
now,
structs
work,
there's
there's
an
interesting
side
effect
of
language
details
where
structs
always
have
a
default
constructor.
So
that's
a
bug
that
isn't
fixed
in
this
version
and
then
I'm,
currently
working
on
with
expressions
which
is
what
we're
thinking
of
as
non-destructive
mutation.
So
the
ability
to
say
I
have
a
record,
that's
Mads
and
you
can
change
the
first
name,
but
you
don't
mutate.
The
first
name.
C
C
Non-Destructive
mutation,
where
the
and
we
will
do
it
in
such
a
way
we
haven't
talked
about
inherent
yet,
but
we
will
do
it
in
such
a
way
that
the
the
new
object
will
be
a
coffee
included.
You
like
it
with
the
same
runtime
type
and
everything,
but
only
with
the
things
changed
that
are
specified
in
the
object.
Initialize.
E
Yeah
and
unlike
some
of
the
other
language
record
implementations,
this
one
should
be
robust
through
inheritance,
so
that
you
can
so
that
equality
will
continue
to
produce
the
right,
corrects
default,
result
back
and
have
customisation
along
those
axes.
Did
you
do
anything
within
hearing
kid
in
this
in
these
bids?
No
there's
actually
no
syntax,
because
the
base
with
with
arguments
syntax
doesn't
exist
yet
so
in
theory,
it
actually
should
work,
but
like
there's
no
way
to
test
it,
because
the
syntax
is
invalid.
Syntax.
C
C
You
know
where
you
have
a
fixed
number
of
of
options
of
different
shapes,
different
types
of
a
given
thing.
We
would
model
that,
as
kind
of
a
limited
inheritance
hierarchy,
where
this
nothing
are
not
much
in
the
base
class,
but
then
the
derived
classes
would
would
have
structure
and
would
have
content,
and
that
would
be
that
will
be
describable
as
a
hierarchy
of
records
as
well.
A
E
It
there's
the
background
is
its:
it
doesn't
exactly
fall
out
of
the
proposal
as
our
sorry
of
the
implementation
as
written,
because
strux
have
to
implicit
constructors
and
classes
only
have
one.
They
only
have
the
implicit
constructor
that
is
produced
when
you
don't
have
a
constructor
and
that
one
is
synthesized,
but
struts
always
have
a
an
implicit
parameter
list.
Constructor,
and
so
that's
a
bug
in
the
current
implementation,
because
the
implementation
was
not
expecting
to
synthesized
constructors
right.
C
So
this
is,
this
is
definitely
a
first
foray
into
records
just
so
we
could
start
getting
some
of
the
implementation
worked
out,
but,
as
we've
been
talking
more
about
records,
this
sort
of
embodies
the
core
of
what
we've
been
talking
about
for
a
long
time.
But
as
we've
been
talking
about
records,
we
we've
and
started
thinking
about
about
it
more
and
more
in
terms
of
to
some
degree,
separable
features
that
are
useful
in
their
own
right,
like
records
that
do
a
lot
of
things.
C
They're
like
a
Swiss,
Army
knife
of
of
expressing
data,
but
some
of
those
those
things
that
you
can
do
with
records
that
we
envision
that
you
can
do
with
records
might
be
more
useful
that
you
can
do
general
and
so
I
have
to
and
built
any
of
that
yet
or
not
in
some
of
it.
We
have,
but
some
of
it,
but
then
not
in
shareable
bits,
and
so
we
can
switch
to
slides
and
talk
about
some
of
those
elements
that
we're
starting
to
see
more
as
a
kind
of.
C
A
C
E
Yeah,
our
most
recent
proposal,
for
how
width
will
work
is
that
we
are
going
to
take
advantage
of
the
CRS
non-required
behavior
in
the
face
of
read-only
effectively.
If
you
have
a
read-only
field,
that's
not
actually
a
read-only
field,
according
to
the
CLR,
for
example,
go
compile
an
application
referencing,
a
library
where
the
field
is
mutable
and
then
change
the
field
and
then
go
back
and
recompile
the
library,
but
I've
read
only
to
the
field.
Your
application
will
continue
to
run,
just
as
it
did
before.
E
That's
because
modifying
read-only
fields
is
a
compiler
error
and
it's
unverifiable
I
out,
but
it's
correct
IL,
and
this
is,
for
instance,
fields
only
static
fields,
actually
read-only
matters
there,
but
for
instance,
fields.
It
doesn't
so
because
it's
all
compiler
safety,
effectively
very
few
things
actually
enforce
verifiability.
E
We
the
same
as
current
read-only
and
that's
that's
effectively
the
same
security
boundaries
that
we
had
before,
but
allowing
a
few
more
features,
including
object,
initializers
that
could
separate
only
fields
and
with
expressions
that
can
separate
only
fields.
So
that's
the
functionality
that
we're
envisioning.
C
C
C
E
That's
been
talked
about
sharp
lang.
We
have
been
more
focused
on
getting
the
core
features
out
before
kind
of
building
up.
The
extensions
that
particular
feature
is
kind
of
nested
within
is
an
interesting
idea
that
we'll
need
to
talk
more
about
there's
some
scoping
stuff
there,
it's
a
little
bit
tricky
and
then
there's
the
simple
aspect
of
the
fundamental
idea
behind.
E
That
is
that
you
would
be
able
to
take
what
what
in
c-sharp
terms
would
be
called
a
simple
identifier
that
is
like
not
a
dot
a
name
and
have
that
simple
identifier
refer
to
kind
of
a
nested
construct.
So
in
the
with
expression,
the
idea
would
be
that
you
would
be
able
to
take
a
property
and
say
this
property
is
also
whist.
So.
E
A
E
E
E
You
can't
just
assign
red,
but
you
could
envision
that
that
could
be
loosened
that,
because
you're
assigning
to
an
enum
called
color,
we
could
maybe
find
the
simple
identifier
in
the
context
of
the
left
hand,
side
and
say:
okay,
color
isn't
an
identifier
my
program,
but
it
is
the
name
of
a
property
in
the
enum.
Could
I
could
I
just
use
red
from
the
enum,
and
so
that's
like
kind
of
the
same
feature
if
you
squint,
and
that
those
would
be
the
kind
of
things
that
we
want
to
consider
together.
I.
C
Think
another
another
interesting
thing:
there
is
collection,
initializers,
so
that's
another
way
in
which
you
can
envision,
though,
with
expressions
being
expanded
to
be
able
to
reach
more
deeply
and
make
other
kinds
of
changes
than
just
swapping
out
the
value
of
a
given
property
directly.
So
it's
definitely
there's
a
path
for
us
to
grow
there,
which
we
we
haven't,
really
mapped
out
yet
and
probably
won't
do
in
there
in
the
first
version
of
it,
but
that
are
great
things
to
consider
to
grow
into
now.
B
E
B
E
B
E
B
C
C
E
And
that
one
makes
sense
in
the
general
idea
of
when
people
are
talking
about
immutable
data
structures.
It's
actually
pretty
common,
especially
with,
even
if
you
look
at
our
immutable
data
structures
to
end
up
wanting
to
kind
of
create
a
copy
and
then
have
an
element
appended
or
there's
something
like
that.
So
yeah.
A
B
Saying
does
it
work
with
civilization?
Is
I'm
gonna
pull
out?
My
little
like
you
know,
he'll
the
die
on
which
she
relies.
Are
you
talking
about?
Serialization
is
completely
ambiguous.
We
could
be
talking
about
JSON,
serialize
or
Newton's
off
you'd,
be
talking
about
data
contracts
that
just
yeah
you
know
buried
or
ins
serializer,
also
known
as
binary,
which
one
are
you
referring
to.
If.
E
B
A
stop
at
mine
so
by
the
rationalization
is
something
like
this
was
discussed
recently
with
I,
believe
we
had
a
discussion
of
some
runtime
recently
with
I
believe
a
mutable
array
or
a
mutable
list,
or
both
of
them
and
the
decisions.
The
decision
for
that
is
kind
of
what's
going
to
hold
here
in
that
there
are
a
number
of
types
in
there
in
the
runtime
which
have
binary
serialization,
and
that's
there
strictly
for
compact,
like
that,
is
something
that
we
kind
of.
We
had
that
you
for
compat,
but
we're
not
adding
new
types.
A
Yeah
I
guess
I
guess
the
adrenaline
question
is
like
in
order
to
support
civilization,
I
guess
you
have
to
either
be
able
to
put
attributes
on
members
or
be
able
to
implement
interfaces
right,
I!
Think
that's
I!
Guess
the
general
question
of
like
how
would
you
make
the
type
work
with
a
particular
civilizer?
A
E
I
think
records
would
definitely
be
able
to
implement
interfaces.
That's
fundamentally,
they're
they're,
very
similar
destruction
classes,
as
as
matt
showed
in
the
prototype.
You
can
put
open,
close,
brace
and
basically
write
a
full
class
body.
There's
there
very
few
limitations
on
the
kind
of
things
you
can
do,
there's
set
of
defaults
that
come
with
the
feature,
but
it
still
is
very
Seashore
like
in
that
it
really
does
allow
for
full
objects,
and
that
means
that
you
would
certainly
have
interface
implementation
as
for
as
far
as
as
any
kind
of
attributes
go.
E
Certainly
the
syntax
that
that
Mads
showed,
where
you
kind
of
replaced
the
property,
the
default
property
with
a
new
property,
there's
an
easy
place
for
an
attribute
to
go
there.
There
are
certainly
things
that
we
can
do
and
things
that
we'll
think
about
in
terms
of
attributes
and
how
we
want
to
support
them
in
general
on
properties,
but
there's,
certainly
no
like
abstract
limitation.
We
just
have
to
figure
out
exactly
how
the
syntax
and
the
semantics
work
out.
E
C
One
thing
that
we
kind
of
struck
us
that
has
always
sort
of
been
a
bit
of
a
one
of
the
more
painful
aspects
of
object-oriented
programming
and
certainly
in
this
sort
of
family
of
programming
languages,
kind
of
came
to
the
front
even
more
as
we
were
talking
about
records,
which
is
the
pain
around
constructors.
We've
sort
of
been
nibbling
around
the
edges
for
a
long
time
around
the
pain
of
declaring
how
a
how
a
class
is
or
how
an
object
is
made
from
a
class.
C
The.
If
you
look
at
a
classic
a
classic
class
here
or
like
person,
there's
a
lot.
A
lot
of
the
code
here,
like
the
essentially
five
of
the
seven
lines
in
the
body,
are
obsessed
with
the
creation
of
it
and
you
can
shorten
it
in
various
ways.
But
most
of
the
code
is
about
how
you
create
it,
and
if
we
start
using
inheritance,
then
it
gets
worse.
C
Because
not
only
are
you
adding
the
same
amount
of
overhead
for
the
new
members
that
you're
adding
new
data
members
you're,
adding
but
you're,
also
having
to
repeat
things
and
pass
on
things
from
the
base
class?
And
so
the
deeper
your
hierarchy
gets
the
bigger
your
constructors
again
and
it's
all
sort
of
boilerplate,
and
so
in
in
c-sharp
3.
We
we
introduced
an
alternative
which
is
object
initializers,
where,
instead
of
all
that
quote
unquote
gunk,
maybe
you
should
just
declare
your
members
and
the
derived
class
can
also
just
declare
its
members
and
then
object.
C
Initializers
are
all
you
need
in
order
to
create
a
new
instance
of
the
object,
so
the
introduction
of
object.
Initializes
really
gave
you
this
this.
We
call
nominal
form
of
creation
where,
yes,
you
have
to
say
the
names
of
the
things
you
pass
in,
rather
than
just
relying
on
the
positional
identification
of
them
that
are
in
constructors.
But
on
the
other
hand,
you
know
that
both
gives
you
flexibility
as
you're
creating
it,
but
it
also
means
that
it's
straightforward
and
simple
to
to
write
the
classes
and
there's
no
sort
of
that.
C
Essentially,
there's
no
repetition
anywhere
and
that's
really
nice
and
not
having
a
lot
of
gunk,
seems
to
be
like
a
goal
in
and
of
itself
for
records
as
well.
So
we
started
looking
more
into
nominal
again.
The
main
problem
with
nominal
creation
is
that
it
relies
heavily
on
setting
the
properties
after
the
object
is
created.
That's
how
object
initializes
work.
C
First,
the
object
is
created,
the
constructor
runs,
then
you
assign
to
the
properties
of
fields,
and
so
it's
strongly
tied
to
mutability,
whereas
for
records
we're
very
focused
on
helping
immutable
scenarios
as
well,
even
by
default.
So
that's
sort
of
a
that's,
a
painful
disconnect
that
we
wanted
to
address
and
that's
where
we
came
up
with
in
it
only
properties
and
probably
in.
C
That
is
during
the
object,
initializer
phase
here
ordering
a
with
expression,
if
you're
using
withers
that
we
talked
about
before
and
then
once
you
reach
the
end
curly
here,
the
the
center
goes
out
of
scope,
so
to
speak,
or
it
becomes
illegal
to
call,
and
so
this
gives
you
the
read-only,
the
immutability
that
you
need,
but
also
the
flexibility
to
declare
things
this
way
and
to
create
them
in
a
nominal
fashion,
and
we
touched
it.
We
touched
them
that
already
a
little
bit
with
how
with
the
read-only
stuff
that
we
discussed
before.
C
E
E
Also,
a
potential
that
that
would
be
a
potential
other
Avenue
for
for
serialization
that,
because
those
properties
are
user,
declared,
there's
a
great
put
place
and
put
an
attribute
for
them.
Yes,
yeah,
that
is
true,
and
for
D
serialization,
the
D
serialization
library
might
have
to
look
at
the
metadata
to
figure
out
that
that's
an
init
property,
but
that's
a
pretty
straightforward
thing:
Plus
D
serializers
actually
set
read-only
properties
all
the
time
right
now,
so
it
actually
might
just
work.
They
kind
of
play
a
fast
and
loose
with
the
rules
right.
C
In
a
sense,
these
are
these
ended.
Only
things
are
certainly
better
for
deserialize
errs
to
call
than
straight-out
read-only
things,
because
these
are
made
for
being
initialized.
They
actually
declare
their
intent
to
be
initialized
when
the
object
is
created,
which
is
kind
of
like
that's,
okay,
for
a
serial
is't.
To
do
it's,
it's
actually
less
okay,
for
it
to
just
go
coke
values
into
objects
that
are
strict
read-only,
and
yet
they
do
it
so
yeah
any
any
questions
or
things
than
that.
The.
A
C
B
An
it
is
likely
honestly,
like
one
of
sorry
I
had
to
like
drop
off
for
a
second.
An
infrastructure
issue
happened,
I
was
dealing
with,
but
I
don't
know.
If
we
talked
about
the
fact
that
an
it
is
a
building
block
of
Records
and
one
of
the
things
that
we
really
feel
it
important
is
the
ability
that
records
in
some
ways
like
is
kind
of
an
implementation
detail
like.
Should
you
as
a
consumer
of
a
record
if
I
switch
it
from
a
record
to
a
normal
class?
B
B
And
so
that
means
that,
when
we
kind
of
start
talking
about
things
like
an
it
as
a
way
in
which
records
work,
it's
like
we're
kind
of
in
some
ways
push
to
make
sure
that
that's
a
part
of
the
c-sharp
feature
base
so
that
you
can
make
records.
Essentially,
an
implementation
detail
to
some
degree,
and
so
I
think
that
I
I
would
say
that
it's
if
we
ship
records
and
an
it
is
a
part
of
how
we
ration
lives.
How
all
of
this
holds
together
that
it's
going
to
be
a
part
of
the
language
yeah.
E
C
That's
full
object,
validations
and,
for
instance,
here
just
checking
that
the
the
the
combined
size
of
of
the
name
isn't
too
long,
and
this
kind
of
whole
object.
Validation
is
yeah,
at
least
occasionally
useful
I
think
the
most
of
the
validation
that
happens
actually
is
probably
per
property,
but
sometimes
you
really
do
want
to
do
that
or
you
want
to
do
some
whole
object.
C
Final
initialization
or
something
like
that
and
and
object
initialize
is
sort
of
by
the
sign.
Can't
do
that
because
they
don't
run
any
centralised
code,
certainly
not
after
the
values
have
been
provided.
So
we
talked
about-
and
this
is
just
a
strawman
syntax
again.
Everything
here
is
really
a
strawman
syntax.
C
We
talked
about
having
something
that
we've
called
validators
or
I.
Don't
know
the
many
things
are
called
initializes
already,
but
they
should
really
be
called
that
initialization
finalize
errs,
which
is
a
new
kind
of
member
declaration.
That
is
like
a
constructor,
but
it
gets
run
after
all.
The
object
initializes
have
been
called
so
essentially
at
the
end.
Curly
here
of
the
object
initializer
after
the
the
client
here
is
done
poking
values
into
the
properties.
C
They
call
they're
compelled
to
call
the
validator
and
run
that
on
the
on
the
created
object
and
that's
sort
of
the
last
chance
to
check
that
everything's,
okay
and
set
the
last
bits
and
pieces
according
to
the
data,
and
that
would
essentially
take
care
of
the
whole
object
validation
in
the
in
these
and
in
this
more
nominal
approach
to
initializing
objects.
Again,
this
is
a
separate
feature.
It's
regardless
of
whether
it
says
in
it
or
set
here
or
whatever
it's.
C
It's
a
separable
feature
that
would
also
happen
to
benefit
records,
but
can
be
done
on
its
own.
So
that's
another
thing
that
we're
thinking
of
doing
and
making
sure
that
our
designs
will
work
with
and
evolving
them,
but
I'm
less
sure
that
this
one
will
make
it
into
v1
that
that's
I
think
that's
probably
a
discussion
about
how
how
critical
is
whole
logic
validation?
Can
we
ship
records
without
that,
so.
A
C
A
good
question
we
were
just
discussing
it
the
other
week
we're
really
looking
at
this
is
hot
design.
Stuff!
That's
going
on
right
now.
Alright,
our
tentative
plan
of
record
is
that
you
can't
have
both
generally,
you
would
want
like,
except
in
very,
we
think
very
contrived
cases
unless
you
have
a
really
good
scenario,
then
shoot
it
to
us.
You
probably
want
the
same
code
when
you
initialize
and
when
you
subsequently
set
the
probably
you
said
we
don't
want
to
separate
them.
We
just
think
of
in
it
as
a
as
a
setter.
B
C
E
C
E
C
Back
to
us
with
with
withers
and
then
we'll
talk
about
it,
so
it
so
happens
that
I
have
slides
so
I'll
pay
you
later.
This
is
an
idea
that
is
it's
kind
of
old
in
c-sharp
language
design
terms
in
that
I
think
Jared
came
up
with
it
three
weeks
ago,
maybe
a
little
longer
and
you're
muted
Jared
in
case
you're
yeah.
C
So
the
the
idea
here
is
that
maybe
so
we
have
a
little
detour
to
another
possible
generalizable
feature
that
would
happen
to
work
well
with
these
things
and
that's
the
idea
of
factories
or
we've
also
called
them
constructor
methods
I'm
using
factory
here
as
as
a
strongman
for
it.
Maybe
you
can
so.
Let's
say
that
my
class
has
a
protected
copy
constructor,
so
to
speak.
It
so
is
one
that
creates
a
copy
of
an
of
an
existing
person
makes
this
initializes
this
new
person
to
be
a
copy
of
an
existing
person.
C
Okay,
that's
easy
to
imagine
now.
Let's
say
that
we
have
a
method
called
width
that
is
virtual
and
it
creates
a
new
person
as
a
copy
of
this
person
that
it's
called
on,
and
then
it's
marked
as
a
factory
method.
Okay
and
student
might
have
the
same
thing,
but
it
overrides
the
width
method
to
create
a
student.
C
That's
a
copy
of
this
student
instead
of
creating
a
person,
so
the
width
method
is
virtual
and
it
will
return
a
copy
of
the
object
itself
and
the
virtual
methods
will
be
overridden
to
make
sure
that
it's
actually
a
copy
that
preserves
the
runtime
type
and
copies
all
the
all
the
properties,
even
though
or
fields
even
the
one
said,
aren't
statically
known
to
the
caller.
Now,
with
this
infrastructure
in
place,
we
could
allow
that,
because
it's
marked
factory
and
limited
to
only
it's
limited
to
only
return
new
objects.
C
We
could
allow
you
to
call
the
width
method
and
then
apply
an
object.
Initializer
to
that
call.
So
essentially,
when
a
factory
is
called,
you
can
apply
an
object
initializer
to
the
result.
Now,
wouldn't
that
be
a
useful
feature
in
general,
I
got
a
fresh
object
back
the
the
method
guarantees
that
is
the
fresh
object.
It
hasn't
been
leaked
to
it.
People
haven't
been
able
to
observe
its
current
state,
so
you
can
still.
You
can
still
override
some
of
its
properties.
C
That
seems
like
generalizable
feature,
but
it
also
is
a
way
that
we
can
implement
the
width
feature.
We
can
maybe
an
even
allow
you
to
not
give
put
the
parentheses
if
you,
if
the
method
call
has
no
parameters,
just
like
we
do
with
with
object
initializes
today
and
then
the
width
syntax
that
we
showed
before
would
really
just
be
syntactic
sugar
for
calling
me
with
method,
I
think
that's
kind
of
neat
it.
B
And
one
thing:
I
kind
of
one
thing
we
were
kind
of
looking
at
and
we
were
talking
about
is
this:
is
this
something
we're
generalizing
or
something
like?
We
should
just
make
it
specific
to
width,
and
you
can
actually
even
look
through
the
bcl-2
see
a
number
of
places
where
type
authors
have
essentially
like
opted
into
factory
methods,
and
one
of
the
reasons
why
you'll
find
pretty
commonly
is
generic
inference.
B
So
pretty
much
anytime,
you
have
like
a
generic
type,
which
has
a
lot
of
constructors
like
tuples,
is
one
all
of
the
more
kind
of
modern
collections
that
we've
built
with
their
patterns.
What
you
pretty
much
always
see
is
this:
this
a
this
pattern
that
we
have,
which
is
you,
define
the
generic
type
you
have
like
a
mutable
array
has
all
of
its
constructors,
and
then
you
have
the
non
generic
type,
which
is
just
a
static
class.
B
It's
saying:
hey,
yes,
you
can
feed
into
inference,
but
you
lose
object.
Initializers
like
you,
you
have
to
make
this
trade-off,
and
this
generalization
here
is
basically
a
way
of
saying
hey.
We
have
this
pattern
and
this
pattern
is
all
of
these
factory
methods
which
all
they
do
is
create
objects.
Why
are
we
acting
them
out
of
initializers?
We
can
basically
let
people
feed
into
the
inference
algorithms
missy
shark,
while
still
giving
them
the
flexibility
to
use,
object,
initializers,
and
so
it's
basically
finding.
B
C
B
I
really
love
is
watching
my
video
screen
as
I'm
talking
because
have
you
ever
seen
me
talk
before
I
like
to
use
my
hands
and
I'm
very
animated,
and
my
hands
are
like
lagging
behind
my
talking
by
about
10
seconds.
So,
if
you're,
just
looking
at
me,
talking
I'm
sure,
it's
like
very
confusing,
though,
as
to
like
why
my
hands
are
coming
together.
While
Mads
is
talking
I'm
not
like
clapping
at
Mads,
like
I'm,
but
was
actually
using
it
for
my
own
little
spiel
there.
B
A
One
question
I
have
is
because
you're
marketers
factory,
they
gazania
some,
that
the
thing
actually
gives
you
back
in
new
instance,
because
in
immutable
collections,
for
example,
we
very
often
also
have
factory
methods,
because
we
are
cheating.
We
have
things
that
you're
mutable
array
create.
You
pass
an
ienumerable,
and
if
the
item
will
happens
to
be
an
immutable
array,
we
don't
even
give
you
a
new
instance.
You
just
give
you
back
the
instance
you
you
gave
us
what
that
still
brought,
that.
B
B
Would
break
things
so
part
of
the
part
of
when
you
really
kind
of
look
at
like
what?
What
would
factory
methods
be
important
for
like
if
you
factory
methods,
if
we
didn't
do
in
it
only
you
could
say
anything's
a
factory,
it
doesn't
matter
because
all
object
initializers
can
do
today
is
mutate
properties
which
we
get
set.
So
who
cares
like
just
it's
an
it's
an
object,
construction
once
you
get
into
an
it,
only
we've
really
kind
of
said
that
construction
happens
in
phases.
B
We
basically
said:
there's
there's
the
constructor
and
then
there's
a
period
of
time.
You
can
kind
of
mutate,
some
of
the
state
that
makes
up
the
object,
but
then
the
construction
is
done
and
the
object
is
now
immutable.
Then
we
don't
want
you
to
change
it
going
forward.
So
there
is
a
tension
now
in
the
language
between
like
making
optional
eyes,
are
more
usable
and
respecting
how
we
wanted
with
construction,
and
when
we
talked
about
factoring
methods.
What
we
said
is
the
way
to
kind
of
solve.
B
This
is
to
say,
like
these
are
really
just
named
constructors,
and
so,
in
order
for
you
to
mark
something's
a
factory
method,
it
has
a
very
limited
set
of
things
that
can
return.
It
can,
for
instance,
a
return
new,
because
then
we
know
you're
giving
us
back
a
new
object
where
construction
is
not
complete
and
we
can
change
the
values
it
can
chain
into
a
factory
method,
so
that
this
is
true
and
then
there's
a
couple.
Other
values
that
you
can
proudly
return
from
factory
method.
B
B
Terrible
I
was
wrong.
Null
is
one
where
we're
kind
of
debating
like
should
that
be
allowed,
or
should
that
not
be
allowed
because
there
are,
it
does
kind
of
invalidate
some
assumptions
you
would
have
from
constructors
like,
for
instance,
new
and
c-sharp
generally
never
returns
null
unless
you've
done
something
very
bad
in
unsafe
code.
So
but
there
would
be
some
restrictions
that
come
with
factory
methods
to
make
sure
that
all
of
the
invariants
that
we
want
and
the
language
continued
to
be
helped.
C
Right,
so
that's
not
to
say
that
you
can't
have
those
factory
methods
that
return
that
might
return
the
same
object
you
just
don't
get
to
the
language,
won't
treat
them
a
spectrum
and
you
don't
get
to
call
them
factory
methods
in
that
and
therefore
you
don't
get
to
have
object
in
it.
Slices
apply
to
them
after
that's,
essentially,
I
mean
we're
not
preventing
you
from
doing
it,
but
we're
preventing
you
from
then
mutating
an
existing,
maybe
long-lived
object
and
making
you
know
doing
something
problematic.
There.
C
You
can
do
it
totally
in
a
nominal
way
like
like
we
did
with
the
hierarchy
before
and
still
get
those
nice
things
you
get
your
nominal
creation
just
for
using
in
it
only
you
get
a
none
destructive
mutation
because
you
have
it
with
method
generated
for
you
and
you
also
get
value
equality
generated
for
you.
The
way
that
we
saw
in
in
the
demo,
and
so
putting
the
record
on
really
gives
you
those
last
two
things
based
on
the
members
that
you
declared
now
a
an
interesting
question
is:
should
you
also
is
this?
C
This
is
pretty
terse
and
nice.
The
nominal
creation
really
gives
you
a
lot
of
gets
rid
of
a
lot
of
boilerplate
for
you,
but
should
it
be
even
nicer,
you
know,
should
it
be
even
terse,
or
should
there
be
some
sort
of
an
abbreviation
pattern?
You
should
probably
be
the
default,
for
instance
in
records.
That's
an
open
question
for
us
right
now.
C
Maybe
all
the
members
have
public
by
default,
just
like
the
iron
interfaces,
because
you
are
expected
to
not
have
a
whole
lot
of
private
implementation,
detail
record
the
the
sort
of
sweet
spot,
the
intended
scenario
for
records.
Is
you
declare
your
data,
maybe
a
little
bit
of
functionality
on
top
of
it,
but
there's
certainly
not
a
lot
of
encapsulation
or
hidden
stuff
going
on
so
maybe
public's
just
a
default.
C
Maybe
you
know
tell
us
what
you
think,
and
maybe
you
know
this
is
one
that
we've
this
sort
of
like
the
extreme
of
it
is
maybe
the
default,
if
you
don't
specify
any
any
accessibility
or
bodies
or
whatever.
Maybe
these
aren't
fields
by
default,
maybe
they
actually
declare
the
properties
and
the
backing
fields
automatically.
This
is
probably.
A
C
But
it
it
has
a
nice
property
that
you,
you
could
really
get
one-liners
right.
That
would
sort
of
take
it
to
the
records,
are
super
super
terse
and
they
fit
them
online
nicely
even
on
an
ad
character
display,
and
you
just
get
all
the
property
nests
for
free
as
well
as
all
the
other
stuff.
So
that's
sort
of
the
spectrum
that
we
have
to
find
our
place
on
and
and
we
haven't
really
found
it
yet
we
haven't
made
a
decision
here
yet,
of
course
you
saw
the
version
with
the
constructor
parameters.
C
We
think
it's
really
nice
to
be
able
to
declare
constructor
parameters
directly
on
the
on
the
class
slice
record
name.
That's
another
potential,
like
generalizable
feature
of
having
primary
constructors
that
are
declared
on
the
class,
and-
and
this
is
essentially
the
example
we
saw
in
the
demo-
and
that
would
just
you
do
that
in
records.
That
would
just
mean
that
by
default
you
get
these
members
declared
in
the
body
of
the
of
the
class
and
I
think
that
marks
the
end
of
what
I
had
in
slides.
E
Would
say
it's
a
little
bit
different
for
records
because
records
the
parameters
are
meant
to
be
public
surface
area,
that
records
are
kind
of
unique
in
that
everything
is
public,
surface
area.
So
it
makes
more
sense
when
you
think
of
methods
as
being
separate,
that
their
implementations
are
not
necessarily
the
surface
farm
records
kind
of
break
that
encapsulation
yeah.
A
C
Also
true,
but
name
parameters
were
only
added
in
tea
shop
for
long
long
after
MeetMe
had
them
all
the
time.
I
didn't
sure
they
were
owned,
but
they
were
only
added
in
in
version
4
and
in
VB
it's
not
case-sensitive.
So
we
were
kind
of
caught
by
our
own
by
you.
This
future,
coming
in
late,
yeah,
I,
guess,
I.
A
Think
pass:
go
ahead,
a
pescetarian
conditions
for
parameters
as
well,
never
never
correctly,
which
I
think
I
never
liked
this
directly
but
like
I
dislike
the
the
cognitive
dissonance,
the
V
maneuver
ourselves
into
both
tuples-
and
you
know,
constructors
in
general
know
that
we,
it
would
be
really
nice.
We
saw
this
in
Jason,
for
example,
where,
if
you
construct
a
Jason
object
in
you
happen
to
have
a
constructor
that
takes
all
the
things
you
know.
A
We
would
like
to
bind
property
names
to
instructor
parameters
who
I
didn't
like,
because
the
naming
never
matches
you
always
have
to
play
this
dance
or
sing.
Oh,
you
know
we
ignore
the
casing,
but
you
know
that's
also
not
always
the
right
thing
to
do
when
you're,
case-sensitive
well,
I
think
it
would
have
been
all
easier
for
this
deck
if
you
would
have
not
have
that
difference,
but
hey
so.
A
To
me,
it's
more
like
I
think
the
the
the
I
think
that
the
thing
with
naming
conventions
is
I
think
you
kind
of
have
to
be
a
visionary
early
on
and
imagine
how
things
relate
to
each
other
and
things
that
are
supposed
to
be
the
same
publisher
or
it
should
be
mapped
somehow
what
we
should
have
had
the
same
naming
convention.
Otherwise,
is
cool
yourself,
pretty
bad.
Oh
yeah,
yeah.
A
A
E
E
A
It's
for
the
returning
now
the
feature
from
constructors,
so
that
one
question
that
copped
up
in
the
chat
a
few
times
which
I
think
you
guys
have
entered
already
answered
in
the
chat,
but
it
might
be
worthwhile
doing
on
the
stream
as
well
is
what
happens
to
extensions
everything.
Is
it
still
something
we're
looking
into,
or
really
convinced,
also
that
that's
a
bad
idea.
C
We
we
kind
of
put
put
it
on
hold
while
we
were
going
all
out
on
records
and
it's
not
slated
for
c-sharp
9:1.
The
quote-unquote
mistake
that
I
did
maybe
a
year
and
a
half
two
years
ago
was
to
to
propose
a
set
of
features
that
was
very
involved
and
that
extension
everything
got
tangled
up
in
so
it
went
from
being
a
neat
little
compiler
trick
to
being
something
that
would
require
runtime
changes
and
so
on.
C
B
Another
thing
one
thing
that
said
there
he's
a
little
compiler
trick:
one
of
the
problems
we
found.
We
actually
we
had
a
design.
We
actually
really.
We
have
a
really
good
design
for
extension,
everything
like
if
I'm
sure
Mads
has
to
know
somewhere
where
he
he
had
kind
of
a
different
take
on
in
how
we
use
like
the
class
syntax
and
make
it
much
more
normal
and
that
when
Ashley
Howe
was
an
intern
a
few
years
ago,
we
actually
had
her
go
off
and
say
like:
let's
do
it
like
this?
B
Let's
implement
this,
let's
make
it
work
and
what
we
actually
found
out
was
this
kind
of
violated
an
internal
in
some
assumption
and
the
compiler
that
we
had
about
how
we
kind
of
represented
methods
like
if
you
think
of
extension
methods,
you
can
represent
them
two
ways
you
could
represent
them
kind
of
as
an
instance
method.
Why
is
this
like
a
receiver
in
a
series
of
arguments
or
you
could
say
no?
E
Second
part
of
that
is
that
when
we
started
digging
deeper
extension,
everything
also
started
questions
about
what
about
extension
interface
implementation.
Should
you
be
able
to
extend
a
class
and
implement
an
interface
that
it
previously
didn't
implement,
and
that
is
not
a
small
compiler
hack?
That's
a
lot
of
work,
so
we
need
to
think
about
exactly
what
we
want
to
do
there
and
it
might
it's
probably
going
to
incorporate
CLR
design
changes
in
order
to
make
that
work,
and
then.
D
From
there
we
have,
we
look
at
shapes
as
well,
which
we've
had
several
exploration,
proposals
on
c-sharp
Lang,
that
Mads
and
other
people
have
posted
around
structural
style
typing
and
c-sharp,
instead
of
instead
of
true
nominal
style
typing
like
we
have
now
I
know
we're
looking
at
some
of
we're.
Gonna
start
talking
about
some
of
that
for
c-sharp
ten
at
least.
D
C
It's
nominal,
but
in
a
way
that
it,
you
know
just
how
a
class
can
implicitly
implement
members
from
an
interface
even
with
members
that
it
itself
has
inherited
from
a
class
that
doesn't
implement
the
interface
like
they
just
happen
to
match
up
with
names
and
everything
works
out
and
c-sharp.
Today,
it's
structural,
the
proposal
that
I
have
out
there
structural.
In
that
sense,
you
can
say,
like,
as
I
put
this
extension
on
a
class
it
you
know
it
you
can.
Could
you
can
put
an
interface
on
wires,
yeah
and
it
could
happen
to
match
up.
C
B
A
Buddered,
alright,
I
think,
like
we
are
kind
of
out
of
questions.
I
think
the
the
the
thing
you
just
talked
about
kind
of
answers,
all
the
things
that
came
up
with
shapes
and
higher
kind
of
times
as
well,
though
I
think
then
this
is
it
as
anything
else
that
you
want
to
talk
to
call
to
action.
Looking
at
proposals
giving
feedback
or
anything
like
that
is.
D
C
A
D
Did
post
a
comment
to
the
to
the
YouTube
chat?
I
will
read
source
generators.
Initial
prototype
was
merged
into
our
main
branch.
A
week
ago
there
was
a
blog
post
in
the
works
that
should
go
out
next
week,
sometime
that
gives
every
map,
but
pretty
much
we're
going
to
be
shipping
an
initial
version
of
an
API.
This
is
not,
if
you've
seen
the
c-sharp
lang
proposal
for
replace
original.
This
is
not
that
this
is
purely
additive.
Source
generators,
we're
basically
a
analyzer
style
type.
D
Api
is
exposed
that
you
can
provide
additional
source
files.
You
can't
change
existing
things
about
source,
but
you
can
provide
additional
source
and
yeah.
So
so
we
are
going
to
be
doing
a
it's,
not
really
a
language
feature.
So
much
as
it
is
a
compiler
feature,
and
it's
going
to
be
a
slow
burn
of
all
right.
We're
gonna
ship,
this
API
in
preview
and
we're
gonna
get
feedback
from
people
who
want
to
use
it,
and
then
we
might
break
things
in
the
future
until
we're
ready
to
declare
it
stable,
I.
A
E
A
A
For
sure
I
mean
like
I,
don't
know
whether
people
are
aware,
but,
like
my
team,
is
heavily
investing
in
writing.
Analyzers
for
the
next
release
of
the
night
or
I,
don't
know
so
I,
don't
at
5:00.
We
will
have
a
bunch
of
both
analyzers
and
the
idea
is
that
you
will
have
a
bunch
of
own
by
default
analyzers
that
people
just
always
get
right.
They
don't
have
to
reference
and
you'll
get
packages,
don't
do
anything
to
the
project
file
they
just
get
like
built-in
analyzers.
A
The
thing
we
are
so
struggling
with
from
that's
the
general
problem
of
all
the
things
that
yell
about
the
source
code
is
what
should
be
on
by
default,
but
like
how
noise
do
we
want
to
make
it
and
there's
always
a
trade-off
between
you
know,
correctness
and
stylistic
things,
and
unfortunately
there
is
a
continuum
in-between.
So
just
yesterday
we
reviewed
an
analyzer
that
basically
yells
about
argument.
A
Exception:
construction,
when
you
don't
initialize
the
perm
name
correctly
right,
very
basic
pass
in
a
string
that
it's
not
actually
a
parameter
and
the
method
you're
currently
in
and
we
went
over
all
our
own
code
base
and
it
flex
a
ton
of
stuff
right
in
them
and
internal
implementations
where
yeah.
If
that
ever
happens,
you
know
we
consider
that
the
product
buck
or
crash
anyway,
because
something
bad
happened,
but
you
put
miss
construct
these
things
all
the
time.
A
So
if
we
turn
on
by
default,
can
design
a
real
world
copays
people
always
like
a
hundred
of
them
right
and
then
do
we
care
enough.
I,
don't
know,
maybe
maybe
not
right
and
I.
Think
that's
the
thing
that
you
know
it
was
also
for
the
compiler
people
right,
like
you,
guys,
also
talked
about
what
warning
waves
and
other
mechanisms
how
people
can
kind
of
selectively
opt
in
to
how
much
how
much
yelling
they
want
to
receive
versus
how
much
much
noise
right
and
that's
kind
of
the
thing
we
trying
to
figure
out
always.
A
E
A
D
C
I
think
yeah
we
were.
We
were
a
little
worried
about
using
using
postfix
explanation
mark
for
this,
because
in
in
expressions
now
with
a
nullable
feature,
it
sort
of
means
the
opposite.
It
means
like
don't
worry
about
null
ability
here
and
and
on
parameters.
It
would
mean
worry,
very
much
about
null
ability
here,
because
I'm
actually
going
to
throw
an
exception
at
you.
If
you
don't
so
we're
a
little
uncomfortable,
we
talked
about
maybe
having
double
exclamation
mark
or
something
the
syntax
and
I
think
that
we
yeah.
C
We
need
to
settle
that,
but
we
I
think
that
it
is
a
useful
feature
again
actually
independently
of
multiple
reference
types.
It's
a
useful
feature,
because
so
much
of
the
argument
checking
code
that
people
write
is
about
checking
for
null
I
I,
don't
have
a
percentage,
but
I
bet
it's
high.
So
if
you
could
abbreviate
that
that
would
really
really
save
you.
Some
boilerplate
yeah.
A
I,
don't
have
a
percentage,
but
like
the
the
one
thing
that
we
looked
at
at
some
point
was
the
the
code
contracts
library
in
the
VCL,
because
some
people
on
the
team
will
they
push
that
and
adopted
it
very
broadly.
We
looked
at
all
the
contracts
that
we
actually
used
and
I
think
95%
of
them
were
just
require.
No,
no
and
so
I
think
most
of
argument
checking
is
in
that
realm.
So
that's
and
pretty
much
in
the
VCL.
Every
public
method
has
argument
checking.
So
that's
pretty
much.
You
know
all
the
api's.
C
And
then,
of
course,
is
the
one
thing
is:
what
are
you
checking
for?
The
other
is
what
you
do
if
you
find
it,
but
again,
I
think
that
the
vast
vast
majority
of
the
null
checks
will
throw
an
argument
null
exception
right,
that's
with
the
name
of
the
property,
so
we
could
totally
generate
that
and
and
serve
most
of
the
scenarios.
We
really
just
need
to
decide
on
the
syntax.
C
A
I
think
this
is
it
then
I
think
we
answer
all
the
questions.
We
had
a
very
steady
stream
of
people
asking
questions,
then
I
think
this
is
it
for
today,
yeah
I
think
there's
a
book
post
coming
next
week
that
somebody
promised
right
about
fostering
writers
right
or
at
least
in
the
foreseeable
future,
and
then
we
will
probably
post
more
updates,
as
we
should
be
more
previous
of
at
five
as
well,
and
then
what
would
be
something
with
teachers
in
there
as
well
and
then
I
think
this
is
probably
it
until
until
further
notice,
yeah.
E
It's
really
hard
to
know
what
the
cause
of
any
given
performance
issue
is
it's
just
like
it's
hard
to
automate
right
most
times.
It's
just
me
looking
at
a
trace,
saying:
oh,
that's
a
problem,
but
it's
hard
to
figure
out
exactly
what
the
cause
is.
So
we'll
have
to
think
more
about
that,
and
it
is
a
little
bit
tricky
in
that
analyzers
run
as
part
of
the
compiler.
So
it's
very
difficult
to
differentiate.
E
One
thing
that
we
are
thinking
about
doing
is
just
making
a
universal
flag
for
the
compiler
to
say
turn
off
all
the
analyzers
and
that
would
at
least
make
it
easier
to
figure
out
whether
your
performance
issue
is
a
compiler
issue
or
an
analyzer
issue,
and
that's
that's
probably
gonna
happen
pretty
soon.
Yeah.