►
Description
This is a continuation of the API proposal here:
https://github.com/dotnet/corefx/issues/21281
A
C
A
E
G
C
C
You
know
a
thing
that
takes
a
byte
array.
Sometimes
it's
called
bites.
Sometimes
it's
called
value.
Sometimes
it's
called
B.
Sometimes
this
company
or
whatever,
should
we
be
consistent
across
all
new
api's
with
the
car
to
anything,
that's
a
span
of
bite
is
called
bites
or
should
we
map
to
whatever
the
thing
that's
being
overloaded,
currently
uses
like
consistent
with
the
current
API
or
consistent
across
new
all
new
API
is
to
be
blob
of
opinion.
I.
A
Would
say,
generally
speaking,
the
consistency
that
is
more
important
to
me
is
only
given
type
I
mean
if
you
introduce
a
new
concept
across.
You
know
a
set
of
types.
Of
course
it
would
be
really
good
if
you
could
have
consistency
across
all
of
those
types,
but
if
you
basically
just
add
logically
overloads
to
existing
stuff,
then
I'd
rather
pick
to
the
naming
that
the
existing
type
has
been
using.
So
if
one
types
of
bites
and
another
type
says
you
know
video
or
array,
then
that's,
unfortunately,
then
you
should
probably
stick
with
that
now.
A
If
it's
literally
called
array
and
the
new
thing
is
not
an
array,
I
wouldn't
call
it
array
of
which
is
called
it
bites
at
that
point,
but
ever
there,
but
I
think
we
need
to
have
like
consistency
within
you
know.
The
existing
types
you
know
locally
I
think
is
more
important
than
globally.
Oh,
that
makes
sense.
I.
E
I
A
G
C
K
L
K
A
H
H
C
Think
it
might
actually
belong
and
discoverability
if
you
want
people
who
are
currently
using
bit
converter,
get
bytes
to
be
able
to
easily
switch
over
to
the
span
based
thing
all.
Do
you
think
of
spam?
Bite
logically,
is
the
equivalent
of
bite
open,
brace
there
open
bracket
close
bracket?
There
is
no
right
Honore.
C
A
It
so
a
somewhat
undecided
acted
so
I
think
the
challenges
that
we
have
for
better
or
worse.
In
the
framework,
a
few
static
methods
that
probably
could
have
or
should
have
been
instance,
methods
on
the
x.
But
we
can't
convert
them
into
extension
methods
because
they
are
northern
aesthetic
type
so,
for
example
like
in
dot
parse
right
or
a
bad
example,
because
it's
not
should
be
an
extension
method,
but
there's
other
ones
I
forgot,
which
one
it
is
like.
A
A
F
With
one
bit
converter,
which
is
static,
so
we
couldn't
host
big
solution
methods
in
it.
If
we
put
them
on
bit
converter
and
we
write
them
as
if
we're
gonna
make
this
pan
extension
that
that's
been
done
both
at
this
keyword
on
it,
we
can
always
go
back
in
at
up
later.
That's
not
really
change,
but
I
do
agree
that,
like
with
stream
that
right,
the
stream
moves
when
you
write
to
the
spam
that
right
you're
the
same
span
so
writing
to
the
amp
that
place
is
over
right
and
ready
to
the
same
street.
H
A
N
H
Do
we
not
have
a
new
method
unavailable
today,
you
let
it
go,
get
whites
from
them
from
yourself
in
there
may
be
reviewing
together
in
place,
so
you
want
to
write
in
right
into
a
span.
No
I
want
to
get
a
fight,
get
the
whites
for
a
double
yes
and
I
want
to
write
it
into
a
ring.
So
I
have
to
get
whites
here.
Yes,
loop
over
that
no,
you
would
do
copy
a
rate
or
a
copy
would.
A
H
B
H
A
A
C
A
E
A
Be
I
would
be
I
would
generally
say
in
the
abstract,
I
think
receiver
being.
The
first
argument
makes
the
most
sense
from
not
OB
standpoint,
because
there's
just
said
like
logically,
even
if
your
aesthetic
methods
to
think
of
them,
as
instance,
methods
is
just
to
deposit
the
first
argument
right
and
so,
like
logically
I
think
the
receiver
should
always
go
first.
E
A
F
A
I
mean
gently
the
reason
why
I
like
the
receiver
being
first
also,
is
that
when
you,
when
you
write
to
something
usually
what
happens
over
time,
you
have
more
options.
So
if
the
receiver
is
first,
it's
more
logical
to
have
the
options
after
the
video,
it's
very
rare.
To
have
video
destination,
then
optional
select,
it
seems,
inverted
did
fine.
I,
don't
know
I.
Think,
generally
speaking,
it
makes
sense
to
swap.
H
A
L
D
Q
H
R
A
R
A
F
F
F
F
R
A
We
return
well.
I
would
argue
that
the
way
it
works
in
the
fabric
right
now,
it's
not,
then
it's
try
again,
but
it's
to
try
recorded
the
tryparse
pattern
because
it's
Univ
of
parse
but
even
looks
get.
We
have
used
try
as
the
general
prefix
for
operations
where
you
have
an
out
that
gives
the
actual
result
and
then
it
will
declutter.
It
succeeded
and.
R
A
I
I'm
doing
the
bull's
eye,
I
think
if
it.
If
we
have
a
try
that
doesn't
have
an
out,
it
doesn't
have
currently
Nicole
London
ephemera
I'm,
saying
that's
the
pattern
they're
trying
to
deduce
here,
because
it's
all
about
reducing
allocations
and
other
things.
So
we
basically
they're
try
to
be
smarter
about
what
we
do.
So
that's
really
about
using
try
in
other
cases,.
D
F
F
F
A
F
Okay,
so
on
this,
one
I
think
that
trying
to
play
64
is
fine,
but
last
time
we
were
talking
about
the
problem
with
base64
and
and
what
it
means
to
try
here
and
we
talked
about
it
would
throw
on
any
valid
data,
because
that's
what
the
current
baby
does,
but
I
think
that
this
data
is
not
legal.
Big
64
is
as
common
as
you
didn't
give
me
enough
space
to
write
so
I.
Don't
take
this.
What
it's
disciplined
tri-party
pattern.
F
Do
the
the
transform
base
multi-state
return
or
we
could
say
that
on
invalid
data
it
will
return
false
Eddie.
You
know
bikes
for
a
may,
be
0,
but
so
that
it
would
have
an
MD
give
us
false
value,
because
I
I
don't
think
it
you
throw
for
not
base64
data
of
every
curve
balls
for
not
enough
space
to
write,
but.
C
F
C
As
you
can't,
you
can't
I,
don't
think
we
can
have
it
mean
both
things,
because
if
you
just
return,
you
know
zero
bytes
written,
it
becomes
a
typical
loop,
we'll
probably
just
end
up
booming,
because
it'll
try
and
double
the
amount
of
space
required
call
again,
but
it
wasn't
family
because
of
lack
of
space,
eventually
you'll,
throw
so
I
think
either
you
throw
for
everything
or
you.
We
come
up
with
some
new
like
the
transformation
status,
but
you
know
bake
it
into
the
VCL
and
be
a
hundred
percent,
confident
that
we
have
it
right.
N
N
C
N
That's
why
I
was
bringing
it
up.
This
is
one
of
the
decisions
we
made
was
initially.
It
was
cool
and
there's
just
too
many
areas
that
didn't
make
sense.
So
now
it
returns
on
a
new
that
tells
you
your
destinations,
all
the
source
was
too
short,
or
there
was
an
error
somewhere
in
your
stream
right
or
is
it
seeded?
So
really
it
was
a
four-way
anew
and
that's
it
made
more
sense.
If
you
care
about
performance
at
all,
so.
C
A
Yes,
I
think
the
question
was
just
that
what
is
Italy
trying
to
achieve
by
it?
So
this
you
could
argue
multiple
ways,
but
you
could
say
the
perform
an
API
for
Spanish
on
a
different
type.
This
API
is
for
convenience
and
consistency.
What
we
already
have,
which
is
optimized
for
usability
not
for
performance.
To
begin
with.
That's
that's
even
igan.
That's
the
current
proposal
like
slightly
right,
then
the
other
one
would
be
you'd
say:
oh
okay,
very
habits,
hired
that
does
conversion.
While
we
introduce
your
new
type,
that's
just
more
per
phone.
A
Why
can't
you
just
merge
the
basics
before
design
that
we
have
in
core
of
X
lab
and
just
put
the
methods
that
we
have
there
directly
on
convert
and
then
just
have
one
place
where
people
can
go
to
to
convert
stuff
and
then,
in
spans
case
the
API
is
slightly
less
usable,
because
it's
both
gentlemen.
You
have
to
like
think
about
that
and
then
the
third
case
is
just.
We
have
two
different
api's
and
one
just
happens
to
reuse
the
implementation,
but
that's
just
something
that
we
care
about,
but
not
really
important.
So.
C
I
think
it
makes
sense
to
it
makes
sense
to
have
a
separate
type
with
a
separate
implementation
when
the
api's
are
so
drastically
different
in,
in
purpose
that
it
doesn't
make
sense
to
merge
them.
In
this
case,
it's
not
clear
to
me,
like
one
of
the
differences
would
be
this
new
API,
that's
being
done
outside
of
convert
beyond
the
return
type
is
literally
just
like.
Instead
of
cool
returns
of
enum
and
instead
of
string,
it
takes
a
read-only
span.
Char.
N
A
You
just
want
to
think
is:
is
emerging
the
members
type
yes,
I
mean.
Maybe
that's
what
I'm
saying
they
to
me.
This
is
one
opportunity
that
we
could
take.
I.
Think
the
concern
that
the
echo
post
of
the
reasons
I
think
that's
more.
His
opinion
than
mine
is
that
it
depends
on
how
strong
you
want
to
be
about
patterns
and
and
consistency
right.
So
if,
if
you
are
into
high
performance
code,
you
could
argue
it's
easier.
A
If
you
have
an
island
over
here
where
you
have
a
bunch
of
types
that
all
do
the
same
thing
basically
forces
one
of
them,
but
there's
like
seven
other
things
that
are
already
there
and
their
form.
You
know
their
own
little
universe,
and
then
you
live
with
the
fact
that
all
the
API
is
and
that
in
spades
are
not
super
convenient
to
use.
But
the
direction
of
of
those
api's
are
somewhat
consistent
is
and
they
return
either
the
same
enum
or
these
similar
enums
in
the
interaction.
A
You
know
how
you
thought
about:
how
do
you
think
about
that
now,
when
you
we
emerge
them?
The
risk.
I
guess
is
that
you
could
argue
that
you
create
the
worst
of
both
worlds,
where,
if
you're
an
existing
customer,
now
you're
confronted
with
a
bunch
of
api's
or
new
types
that
you
may
not
care
about,
and
then
for
the
exist
for
the
for
the
new
customer,
and
while
they
are
now
having
to
be
very
careful
which
api
is
they
call
because
some
of
them
have
shitty
/
other
other
ones.
A
F
If
we
would
add
this
for
the
video,
yes,
it
grows
on
the
data
we
would
immediately
put
in
the
documentation.
This
returns
false
only
if
the
destination
is
T
for
T.
If
you
would
like
to
avoid
the
overhead
of
an
exception
on
invalid
data
of
any
form,
then
please
call
this
other
function
instead,
except
we
should
have
just
use
that
function
in
convert
like
we're
going
to
tell
people
essentially
never
call
this
function,
it's
just
a
forwarder
to
the
fine
metal.
L
F
Like
we
could
have
been
it,
we
could
have
added
to
try
it
from
a
very
64
stream
that
didn't
pick
a
span
could
have
I
done.
The
array
one
like
several
releases
ago
and
the
obvious
error
would
have
been
one
of
this
doesn't
converted
to
a
64
and
we
would
have
had
that
and
he
would
have
and
then
now
we
would
be
doing
like
oh
crap.
What
are
we
doing
with?
Try
try
and
we
may.
C
C
F
A
Well,
but
then
you
could
argue
that
if
it's
about
convenience
and
I
think
for
span
where
it
slightly
inconvenience
to
the
sentence
very
hard
to
have
these
convenient
API
up,
because
the
ones
that
we
just
have
on
screen
also
not
super
convenient
right
and
everyone,
I
would
argue
if
you're
willing
to
call
those
but
the
one
that
corrects
that
are
not
that
much
worse.
To
call
did
anything
you
matter,
because
they
tell
you
clear
of
what
error
case
you
can
expect
well.
C
N
C
A
F
It
we
wanted
to
add
a
byte
one
now
or
later
we
could,
but
definitely
what
people
have
right
now
to
the
existing
thing.
You
can
have
a
string
and
change
that,
where
you
have
a
char
array
ready
takes
that
one.
So
you
can
have
a
smart
spam
saying
trying
if
you
have
advice
and
don't
need
to
call,
the
encoding
class
is
to
turn
your
bites
into
a
far
away
to
the
capacitive
bits.
Jordan
TV
I'd.
Ask
you
later.
B
F
That
indicates
they
can
be
courts
of
invalid
data,
or
it
can
be
a
little
bit
of
data
too
short
improper
on
a
lot
padding
may
be
able
to
take
long,
but
I
think
that
we
have
obvious
there
to
obvious
error
states
that
we
probably
don't
want
to
throw
in
any
medium
and
higher
performance
code,
which
is
this
data
doesn't
make
sense.
It's
a
64.
C
C
C
F
F
N
Now
I
remember
why
it
doesn't
matter
so
everything
in
the
basics
before
side
is
impure
asking
and
late.
So
if
you
want
to
come
up
to
my
actual
screen,
it's
very
easy
to
whiten
the
basically
every
piece
that
makes
everything
comes
in
each
essence,
because
it's
a
ski
only
on
the
other
end,
it
literally
is
so
if
you
want
to
take
a
stringing,
convert
it
to
basics
before
it's
just
that
spring
dot
as
and
I
advise
and
you're
done,
and
because
it
just
treats
it
as
a
binary
well,
but
that
there
can't
be
lightly.
N
Of
bytes
and
I'm,
making
single
followed
for
the
osculating
for
a
so
unit,
I
think
so.
Thirsteee
there's
two
directions:
writers,
I,
have
data
and
I
want
to
build
two
basics
before
and
then
I
have
basics
before
and
I
want
to
go
to
data
right.
So
it's
this.
It
is
a
string.
It's
string,
dot
s
and
adds
white
like
this
establish.
N
F
N
Right
yeah,
what
happens
is
this?
You
have
a
basic
support
string
and,
assuming
that
it's
valid
yes,
it's
a
span
of
utf-8
strength.
I
know
it's
been
better
spent
in
our
case
I'm
talking
about
it's
asking
for
sorry,
you
know,
sir,
with
a
little
that's
arbitrary,
binary,
yes
and
this
one
here,
because
it's
already
in
whatever
was
this.
If
you
literally
get
back
this
span
from
this
conversion,
that's.
F
P
A
C
That
have
effectively
had
to
double
the
link
that
they're
call
and
figuring
out
what
the
conversion
is
to
get
from
string
to
the
thing
that
this
thing
takes,
and
that
might
be
totally
fine
for
the
super
advanced
highly
efficient
API
but
I.
If
our
goal
is
just
to
allow
people
to
use
the
existing
convert,
thought
from
and
to
base64
string
encoding
eight
guys,
but
to
do
it
without
allocating
the
additional
batteries
I
think
that's
too
much
of
a
leap,
at
least
personally
I
think
that's
too
much
belief.
F
Q
A
A
C
B
A
A
C
A
C
Have
that
the
signature
public
static,
transform
enum,
whatever
it's
called
from
big
64
string
string,
ass
fan,
byte
bytes
out
in
doubt
int
right.
What
if
on
convert
you
have-
and
you
were
just
talking,
email
about
having
two
overloads-
one
that
takes
a
string
s
and
one
that
takes
to
read
only
span
byte.
What,
if
effectively
you
just
put
those
two
overloads
between
convert
and
the
base
64
class
convert
gets
the
string,
s1
or
read-only
Spanish,
r1
and
base64
gets
that
read-only
span.
Byte
one
I
mean
like.
F
C
C
So
just
drop
the
string
all
together,
welcome
string.
The
string
is
implicitly
convertible
to
read,
only
span
char,
I,
believe
or
as
though
there's
an
adder
read-only
spam.
You
have
to
call
so
yeah.
Maybe
you
have
two
overloads
here:
one
for
string
s
and
one
for
read-only
Spanish
are
yeah,
and
then
you
have
the
only
span
bite
on
the
a
64
one.
Yes,
I
I
agree
with
them.
That.
A
F
C
I
probably
add
those
in
as
well
I
mean
I,
don't
know,
I
have
zero
knowledge
of
how
often
that's
used
or
not,
presumably
because
the
existing
overloads
have
them.
We
want
to
add
the
yeren.
We
could
add
that
you
can
have
it
as
an
optional
parameter.
I,
don't
know
which
way
the
default
is
but
like
from
cryptography.
F
C
A
A
C
A
C
F
A
F
M
T
F
A
O
A
F
F
F
Q
A
C
C
All
right,
this
one
should
hopefully
be
very
straightforward.
Well,
I
always
say
that
so
random
that
there
is
one
complication.
Random
has
a
bunch
of
virtual
methods
on
it.
People
can
drive
from
random
and
override
stuff,
there's
already
a
next
bytes
method
that
takes
an
array.
This
was
just
a
byte
array.
This
would
just
take
a
span
by
the.
C
A
C
C
C
And
that's
where
the
the
span
version
is
handy
is
it?
You
know
you
have
some
sort
of
buffer
and
you
only
want
five
random
bytes
today
you
have
to
allocate
an
array
to
do
it
or
if
you
wanted
them
in.
You
know
on
the
stack,
which
is
also
sometimes
helpful,
with
the
span
one
you
can
just
you
know
stack,
allocate
some
memory
and
pass.
B
C
Went
through
all
the
various
options
and
I
think
I
found
the
right
one,
but
we
can
deal
with
that
when
we
put
up
a
PR,
normal
I
would
expect
that
next
next
wife
takes
a
span
is
called
the
one
that
takes
the
array
of
copies.
Well,
the
problem
with
that
is:
how
do
you
pass
a
span
of
bite?
That's,
for
example,
a
stock
outlet.
C
You
know
pointer
to
the
overload
that
takes
an
array
because,
if
someone's
derived
from
it-
but
you
could
do
something
internally
but
just
use
the
same
logic,
but
if
someone's
derive
from
the
end
of
it
over
within
the
bytes,
one
you'd
need
to
call
their
drive
one
which
expects
a
byte.
Not
a
byte
array
knows
man
tonight.
A
C
F
Had
to
do
in
some
places,
or
we
had
with
them,
you
change
the
crypto
stuff.
Mostly
we
did
this
at
illusion.
Dependent
we
broke,
somebody
is
doing
terrible
reflection
to
find
out
are
those
are
these
functions
derived
at
the
same
layer
or
do
we
need
to
be
like?
Oh
crap
I
think
you
came
from
the
whole
universe
and
I
either
in
their
records,
but
I,
don't
think
that
we
would
want
to
start
adding
on
physical,
adding
span
with
well.
C
C
Think,
though,
you
just
implement
this
as
a
for
loop
that
loops
and
guess
you
know,
gets
the
individual
element
and
stores
it
in
and
then,
if,
if
the
derived,
Mersenne,
twister,
random
or
crypto
secure,
random
or
whatever
wants
to
override
it,
that
it
can,
but
at
least
the
base
implementation
would
do
something
reasonable,
and
if
you
wanted
to
do
something
like
that,
Jeremy
was
saying
you
know
we
couldn't
detect
whether
the
other
things
were
overwritten
and
do
something
more
efficient
if
it,
if
it
wasn't
yeah
I
mean
so
actually
I've.
Given
this
women
specifically.
B
F
C
A
Well,
I
guess
you
could
argue
that
a
random,
the
real
primitive
is
sample,
and
then
the
other
ones
are
just
you
override
them
to
have
the
more
efficient
implementation
that
doesn't
literally
like
write
a
for
loop
over
the
sample.
So
in
that
sense,
spam
would
follow
that
I
mean
they
give
you.
You
will
get
I
mean
if
you
implement.
You
know
next
it
takes
and
is
our
next
bias
that
takes
a
byte
array
and
sample
an
inconsistent
ways.
Then
yes,
the
one
that
takes
the
spam
out
to
being
consistent
as
a
result.
A
So
are
you
you
could
say
the
implementer
of
the
type
it
up.
The
implement
of
the
type
did
something
right
with
meaning
that
sample
and
expires
are
in
alignment,
and
us
calling
sample
is
still
better
than
us
calling
the
bite
one
because
it
is
beyond
allocate
I
mean
you
really
want
something
more
efficient
in
your
in
your
in
your
next
bytes
would
spend
you
have
to
override
that
as
well,
and
do
something
smart,
so
I
think
that's
Xterra
within.
F
Net
FX
there's
one
type
that
extends
random,
which
is
in
service
college.
It's
they
have
a
synchronized
random,
where
they've
done
every
override
to
do
lock
call
base.
So
if
we
added
this-
and
they
call
this
fan
one
not
thinking
about
it-
then
they
would
go
from
doing
one
lock
operation
to
doing
the
number
of
flights
that
have
monitored
inner
and
monitoring
exits
slightly
tweaked.
C
Cuffs
are
there
is
a
concern
there
atomicity
or
is
the
concern
their
perch?
If
the
concern
is
perf
they're
explicitly
changing,
which
overload
they're
using
right,
they
should
be
doing
a
performance
analysis.
If
it's
atomicity,
then
yeah,
there's
potentially
an
issue
but
I,
don't
know
what
a
implementation
would
look
like
routing
Mississippi
in
that
case
with
matter.
That's
right,
so
I
guess
yeah.
So
they
because
they
also.
F
A
H
F
B
A
L
C
I
should
say
probably
the
parsing
format,
because
it
subsequently
added
format
but
I
forgot
to
update
the
title,
but
basically
every
primitive
type.
Now
there's
ten
of
them
has
parse
and
two
string
methods,
a
parse,
tryparse
and
two
string,
and
these
are
sort
of
the
span
based
equivalents.
I
took
the
liberty
of
rather
than
having
a
bunch
of
overloads
using
optional
parameters.
K
F
N
A
Well,
this
is
most
about
api
fits
right.
So
the
question
is:
is
you
implementation
wise
right
thing,
but
if
the
question
is,
should
we
have
two
different
sets
of
api?
It's
like?
Is
this
api
pattern
sufficient
for
FX
lab
or
the
boys?
Aren't
there
any
of
you
guys
know
there
you
later
take
remove
the
same
thing
except
then
they
have.
F
N
Q
C
J
A
F
C
C
B
C
And
got
logically
yeah
lots
of
people
the
same
and
I
thought
I
may
have
made
some
copy/paste
terrorism.
Basically,
whoever
is
implementing.
It
would
just
make
sure
that
the
you
know
that
these
would
match
the
existing
ones
to
the
largest
extent
possible
and
I.
Imagine
implementation
wise
at
least
for
an
initial
go
around.
The
idea
would
just
be
to
be.
If
you
look
at
these
things,
call
they
basically
either
hand
down
strings
or
char
stars.
B
C
I
think
I
copied
there
from
what
the
existing
API
is
were
doing
is
this
would
just
come
down
to
either
I
had
a
copy
and
paste
error,
in
which
case
we
should
fix
that
or
I
was
right
and
then
are.
We
used
a
mapping
as
closely
as
possible
to
the
existing
method
on
the
existing
type,
or
are
we
coming
up
with
something
standard
or
fixing
issues
and
the
existing
overloads
and
I
always
opted
for?
C
C
F
C
A
C
Q
C
So
gooood
is
some
of
the
same
tryparse,
try
format
and
then
two
other
methods,
a
gooood
constructor
that
takes
a
read-only
span
bite
instead
of
a
byte
array
and
a
tri
copy
that
takes
a
span
bite
Google
already
has
a
what
it's
called
just
copy
Google
it's
to
array,
it's
2
or
2
byte
array
to
buy
direct.
Those
are
this,
so
this
try
and
copy
to
with
the
instead
of
two
byte
array.
But
if
we
want
to
go
with
right
so
three
is
that
we
decided
on
like
right
destination,
try
right,
bytes
destination.
D
C
S
S
C
String
is
interesting,
so
there's
two
things
I've
suggested
here
and
then
one
set
of
things
that
I
have
in
there
and
we'll
start.
Let
me
start
with
the
last
one.
First,
there's
a
whole
set
of
operations.
I
think
we
need
unreal.
Only
spam
chart
to
make
read
only
Spanish
are
feel
like
string
dish.
You
mean
things
like
trim
and
replace
or
no
and
maybe
not
replace
but
trim.
C
That's
very
least,
and
some
of
these
methods
already
exist
on
the
read,
only
understand
extensions
type,
but
there's
some
more
I
think
you
need
I,
opened
a
separate
issue
for
that
and
I'm
sort
of
leaving
that
up
to
Christophe
to
drive.
So
what
I've?
Only
what
I've
done
here
are
just
what
I
think
we
need
to
add
to
string
itself
to
play
nicely
with
you'd.
Only
spam
I
think
there's
two
things
one
is
we
already
have
a
bunch
of
ways
of
constructing
a
string
like
from
a
char
array
or
the
char
star
in
a
length.
C
I
think
we
need
to
be
able
to
support
creating
a
string
from
a
spam.
You
could
do
that
in
a
variety
of
ways
like
we
can
have
an
extension
method
on
spam.
To
so
you
know
the
creative,
the
string
or
we
could
just
make
it
a
string
constructor
or
we
can
have
a
static
method
on
string
like
create
or
something
that
took
up
span,
but
to
me
constructor
seemed
the
most
logical
and
straightforward
approach.
C
You
know
using
unsafe
code
to
the
string
and
I
was
suggesting
me
kind
of
make
that
a
first-class
citizen
by
having
a
create
method
where
you
give
it
a
length
and
then
it
calls
back
to
you
with
a
delegate
that
allows
you
to
populate
the
body
as
a
spam
chart
India
is
connected.
What
are
they
biting
into
that
screen?
C
And
it's
sort
of
hiding,
you
know
the
danger
of
the
pin
the
string
and
then
the
right
route
approaches.
We've
always
sort
of
said
that
strings
are
immutable
and
this
at
least
kind
of
gives
a
head
nod
to
that,
because
you
don't
actually
get
the
string
back
until
you've,
already
kind
of
filled
the
memory
and
it's
up
to
the
implementation,
how
to
do
it
if
you're
actually
pinning
the
string
and
writing
to
it.
It's
obviously
breaking
immutability.
C
A
C
C
The
actual
implementation,
if
you
look
at
all
the
string
functions
that
create
strings
today,
they
all
call
this
like
fast
string,
create
thing
which
actually
allocates
the
memory
and
then
internally
we
do
what
we
tell
everyone
not
to
do,
which
is
pin
it,
get
the
charge
start
to
it
and
write
to
it.
That's
what
this
would
do.
Okay,
just
put
the
height
everything.
It's
great
I
think
it's
just
a
separate.
C
Now
you
can
also
imagine
doing
it
as
a
constructor,
the
downside
doing
is
it
as
constructors.
You
often
want
to
pass
in
the
state.
You
want
to
use
to
initialize
the
string
and
to
do
it
out
the
constructor
you
couldn't
make
the
constructor
have
generic
arguments,
so
you
either
need
to
pass
in
the
state
as
an
object
or
needs
to
be
a
separate
method.
I
think
it's
going.
C
Thank
me
for
look
more
code.
The
other
option
with
the
delegate
is
I,
don't
know
how
common
it's
gonna
be
to
pass
fans
through
delegates,
but
we
could
just
name
this
funk
and
you
know
try
and
come
up
with
one
or
more
delegates
that
are
all
in
the
funk
family
or
action
rather
I
get
to
be
stream,
create
action
that
are
all
in
the
action
family
that
could
be
reused
for
other
purposes.
C
Basically,
it
could
pre
can't
funk
and
free
can
action
types
where
one
of
the
arguments
is
Spence,
who
can
use
them
right.
So
in
this
case
you
know
you
could
have
action
that
takes
a
T
State
and
a
T,
and
it
would
be
T
State
stay
span
of
T,
chars
or
Spanish,
or
something
like
that
that
that
create
the
string
create
function
would
specify
the
generic
type
that
was
being
used
in
the
span,
but
the
starts
get
complicated.
F
C
N
N
What
that's
the
way
that
compiler
works
right
now,
they're
trying
so
Vlad's
working
on
a
way
to
detect
whether
its
fans
gets
created
before
or
after
I
not
used
across,
but
the
way
that
they
currently
work
is
because
it
really
route
speed.
As
soon
as
you
create
a
lab,
though,
if
there's
a
span
or
just.
C
N
C
C
C
I'd
also
be
fine.
Did
that
issue
aside
I'd
also
be
fine.
This
is
sort
of
a
special
function.
This
is
one
of
the
few
cases
where
I
dared
off
of
adding
overloads
and
when
to
Steve
on
his
soapbox
about
new
functionality
that
we
should
have
so
I'd
also
be
fine.
If
you
want
to
keep
this
thing
separate,
you
know
it
has
a
separate
discussion
and
yeah.
Okay,
especially.
A
N
R
N
C
Okay,
so
I'm
suggesting
four
new
overloads
on
stream.
Basically,
one
for
each
of
read:
read
async,
write
and
write.
Async
the
synchronous
methods
take
a
span.
The
asynchronous
ones
take
a
buffer
which
I
can't
remember
where
we
land
that,
if
buffer
is
still
called
buffer
or
if
it's
now
called
memory.
But
whatever
that
thing
is
sorry
say
again:
okay
and
for
the
read
async
one
of
the
historical
mistakes
I
think
we
made
was.
We
should
have
shipped
value
tasks
earlier
and
we
should
have
made
stream
read
async
return,
a
value
task
instead
of
a
task.
C
C
These
are
all
pretty
simple
to
implement
the
basically
they
all
get
implemented
in
terms
of
their
existing
abstract
variant,
and
if
we
need
to
allocate
a
byte
array
in
order
to
call
that
we
get
one
form
or
a
pool
or
something
the
work
here
is
just
going
to
be
going
in
overriding
these
on
all
of
the
stream
classes.
We
have
where
we
care
to
do
the
more
efficient
thing.
C
C
So
you
know
the
read
that
takes
a
span
will
delegate
to
the
read
that
takes
a
byte
array,
but
in
order
to
do
that,
we'll
end
up
having
to
allocate
a
byte
array
so
we'll
pull
them
from
an
array
pool
or
something
delegate,
and
then
on
you
know:
deflate
stream,
network
stream,
file
stream,
memories
stream
on
manage
memory
stream
and
so
on,
and
so
on.
Well
over
override
all
these
methods
to
do
them
more
efficiently.
C
C
The
second
is
to
override
it
on
all
of
the
streams,
basically
across
core
FX
and
core
CLR,
and
then
you
know,
it'll
that'll
propagate
upstream
as
well,
so
asp.net
will
probably
end
up
doing
the
same
thing,
and
then
there
are
lots
of
places
around
core
FX
where
we
consume
streams,
and
and
many
of
them
will
want
to
switch
to
using
some
of
these
new
orleans
in
particular,
places
where
we're
using
read
async
today,
we'll
want
to
switch
to
using
the
new
overload
every
day.
Second,
most
like
work.
E
C
For
the
synchronous
ones,
we
basically
have
no
choice
but
to
get
an
array
either
allocate
one
or
again
one
from
an
array
pool,
and
you
know
either
call
the
existing
method
and
copy
or
copy
and
call
the
existing
method,
depending
on
their
calling
you're
right
for
the
ones
that
take
for
the
asynchronous
ones.
We
can
special
case
when
the
buffer
or
the
read-only
buffer
wraps
an
array
already,
and
we
can
just
use
passed
the
underlying
array
segment,
basically
to
the
existing
methods.
But
if
it
doesn't
wrap
an
array,
then
we'll
do
the
same
thing.
C
A
That's
because
you
like,
we
use
the
mic
from
my
laptop
I,
think
and
that's
and
I
yell
usually
a
lot,
so
that
probably
also
helps
anyone
heard
was
saying
is
that
he
said
for
random
that
we
don't
want
to
override
next
bites
that
takes
pan
as
calling
the
other
one
that
takes
binary
or
perf,
and
you
know
if
we
have
do
this
here,
I
just
you
know,
advertising
the
cost
for
going
through
the
pool.
We
could
do
the
same
one
well.
C
The
problem
is
with
random
90%
of
usage
uses
the
base
random
class.
It's
not
abstract,
whereas
stream
is
abstract
they're.
The
only
people
that
will
use
the
base
implementation
on
stream
are
cases
where
the
drive
class
doesn't
override
it,
but
in
random
the
majority
cases
there
is
no
derived
class.
So
there's
there's
a
logical
difference
and
in
the
climate
types
I
see
you're
sure
just
saying
the
impact
is
much
lower
there,
and
so,
if
you've
just
do
the
right
thing,
buzzer
then
yeah.
C
A
C
So
again,
these
are
these.
Are
these
are
a
couple
of
the
other
cases
where
I've
stepped
out
of
kind
of
the
existing
overloads
and
thinking
about
what
we
need
and
sort
of
the
broader
ecosystem?
Today,
we've
got
memory
stream
that
wraps
a
byte
array.
We've
got
unmanaged
memory
stream
that
wraps
a
pointer,
a
byte
star,
basically
we're
adding
these
span,
we're
adding
sorry
these
buffer
and
read-only
buffer
types.
That
logically,
do
the
same
thing.
C
If
you
can
get
the
array
from
the
buffer,
then
you
use
memory
stream,
otherwise
use
unmanned
memory
stream,
but
it
turns
out
buffer,
doesn't
exactly
work
that
way,
and
there
are
cases
where
you
can't
get
the
array
from
the
buffer,
but
that
doesn't
mean
the
memories
pinned
and
so
buffer
and
stream
and
read-only
buffer
stream
are
sort
of
necessary.
If
you
want
to
treat
these
things
that
streams
do
we
need
public.
M
C
B
L
C
Yeah,
yes,
and
no
I
mean
so
what
I
suggested
below
was
we
consider
an
interface
like
I
has
buffer
and
buffer
stream
and
read-only
buffer
stream,
with
both
potentially
implemented,
as
might,
for
example,
memory
stream
and
unmanaged
memory
stream.
If
we
added
this
interface,
we
could
say
that
the
intended
use
cases
you
just
you
know
you'd
do
a
tight
check
if
stream
is
has
buffer
jet
the
buffer.
Basically,
and
then
you
wouldn't
matter
what
these
were
public
or
not,
they
would
still
implement
the
interface.
H
H
A
A
C
A
I
mean
this
is
the
only
problem
that
I
that
I
observe
with
the
pipelines
as
well
as
that
there
one
poem
if
you
have
to
solve
a
single
distantly,
is
that
there's
too
many
things
called
buffer
now
that
makes
it
something
that
makes
it
somewhat
unpleasant.
But
sometimes
you,
like
you,
know
it's
receiving
pipe
lines.
You
have
this
unfortunate
call
chance
a
to
buffer
the
buffer
on
input
buffer
right
you're
like
what
the
there's
too
many
buffers
involved
here.
That's
just
another
version
of
that
I
think.
Maybe
we
should
have
a
different
name
for
that.
C
A
C
Should
be
able
to
start
working
on
the
derivative
like
parts
and
format
yeah,
and
then
we
just
need
to
figure
out
a
bunch
of
the
meadow
or
at
least
the
this
was
just
the
convert
ones
done
with
that
meetings
we
could.
We
could
leave
off
convert
from
that
list,
but
my
plan
was
to
go
and
open
individual
issues
for
the
for
I.
A
Think
the
idea
was
first
of
all,
a
yeah,
it's
all
to
one,
but
to
one
is
no
more
a
little
bit
more
time
because
it
push
it
all
a
little
bit
further
in
the
future,
but
I
think
the
idea
of
two
one
as
it
releases
to
basically
have
the
public
version
of
spat,
and
you
know
usable
across
the
board.
It
doesn't
mean
you
have
to
do
all
of
them
and
you
can
still
cut
pieces
out
of
it.
They
don't
want
to
do.
A
B
A
C
He
must
point
like
that.
This
is
all
very
diable.
I.
Just
think
we
need
enough
enough
of
these
api's.
That
span
is
usable
kind
of
across
the
board,
and
there
may
be
some
warts
that
we
need
to
go
fix
in
to
two
or
whatever
it
comes
after
to
one,
but
as
much
of
this
as
we
can
get
in
the
more
useful
span
will
be.
We.
A
Say
to
one
really
not
a
quarter
to
one
right
that
standard.
That
is
the
whole
different
discussion,
because
I
mean
let's
say
we
could
pull
it
all
off
for
dotnet
core
to
one
and
let's
say
that
would
ship
next
week
that
wouldn't
mean
that
we
could
immediately
do
it
on
that
fabric
right.
So
there's
still
the
question
of
like
okay,
we
can
have
this
version
of
off
span
the
ships
put
on
that
favorite
out
of
bath.
On
top
of
what
we
already
have
the
clear.
A
A
A
F
C
C
Know
this
span
spans
Rd
in
Cortland,
but
offers
not
yeah
well.
That
battle
need
to
be
move
down
to
two
weeks
to
expose
the
types
we
can
allow.
The
implementation
can
be
done
sure
and
so
Hawk.
So
sorry
towards
the
end
of
this,
like
the
higher-level
contracts,
they
can
depend
like
we
can
make
forward
progress
on
them
as
well
cuz.
They
can
depend
on
system
dot
memory,
DLL
River.
It's
called
rather
than
system,
not
runtime,
but
for
some
of
the
core
types,
yeah
it'll
need
to
be
moved
to
system.