►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
All
right,
hello,
everyone,
so
today
we
only
have
a
few
ones,
because
next
week
we
handle
this
utilization
one
and
then
we
are
done
with
the
backlog
unless
new
issues
will
pop
in.
A
So
I
think
this
one
we
discussed
briefly
last
time
and
the
conclusion
was
basically
this
is
a
new
engine.
We
need
to
pick
a
name.
I
think
these
are
the
comments
that
we
left
last
time
steven
you
have
anything
to
add
to
this
suggestion.
B
B
Yeah
there
I
think
we'd
spell
it
with
a
capital
b,
but
other
than
that.
I
think
that's
reasonable.
C
B
B
We
can
certainly
change
our
mind
with
our.net
seven
ships
and
based
on
where
things
you
know,
land
in
terms
of
size,
but
the
rest
of
there
are
a
bunch
of
options
today
they
all
configure
how
regex
behaves.
This
is
one
more
such
option.
Specializing
this
one
via
a
factory
on
its
own
doesn't
seem
like
a
good
idea
to
me.
So
we'd
have
to
have
a
really
good
reason.
I
think,
to
kind
of
do
something
different.
C
B
B
If
it's
a
special
factory
method,
we
have
to
come
up
with
some
other
approach.
For
that.
A
A
B
B
Because
we
want
some
flexibility,
you
know
we
don't
want
to
describe
the
implementation
details,
but
I
think
so
I
was
trying
to
basically
say
well
you're
you're
more
limited
in
in
what
you
can
use
with
this.
Therefore,
it's
constrained,
but
not
a
great
suggestion
either.
So
I
like
non-backtracking
just
because
it
it
gives
us
some
flexibility.
It
says
what
you
know,
what
we
actually
wanted
to,
what
you're
trying
to
avoid.
Basically.
B
Well,
so
I
responded
to
that
later
in
the
thread.
I'm
I'm
not
100,
convinced
of
that.
Yet
it
there
are
certain
scenarios
where
the
answer
to
your
question
is
absolutely
100.
Yes,
if
you
are
exposing
your
regex
on
the
you
know,
on
the
wire
to
untrusted
input
and
you've
written
a
pattern
that
is
susceptible
to
you
know
dos
attacks
or
redos
attacks.
Then
yes,
like
absolutely,
we
want
you
to
use
the
new
mode,
but
if,
but
otherwise
it
ends
up,
you
know,
you're,
you
can't
use
the
full
regex
syntax.
B
There
are
certain
constructs
that
are
disallowed,
so
you're,
inherently
constrained
for
better
or
worse
in
you
know
what
you're
allowed
to
do,
and
so
at
that
point
it
just
comes
down
to
do.
You
need
the
extra
functionality
and
if
no,
then
it's
purely
a
performance
consideration,
there
will
definitely
be
patterns
with
a
new
is
faster,
the
more
backtracking
there
might
be
like
if
you
have
a
giant
alternation.
You
know
your
regex
is
alternation
between
a
hundred
different
options.
B
Then
the
new
mode
is
almost
certainly
going
to
do
better,
but
there
will
also
be
patterns
where
it
will
likely
do
worse,
and
so
at
that
point
it
will
probably
come
down
to
if
you
care
about
that
level
of
optimization,
trying,
both
and
seeing,
I
think,
a
general
stance
of
like
you
know
if
you
can
live
with
this
option,
start
with
it
and
then
go
from
there
would
be
okay,
but
I
I'm
hesitant
right
now
to
say
yes,
we
would
if
we
could
go
back
in
time.
This
would
be
the
default.
B
B
What
about
pcre?
They
would
work
with
pcre.
B
Basically,
anything
that
has
back
references,
anything
that
has
look-aheads
look
behinds
and
a
few
other
things
in
that
category,
where
you
have
to
kind
of
go
back
in
the
input
and
basically
leads
to
backtracking,
essentially
wouldn't
wouldn't
work.
B
A
B
A
B
A
D
Yeah,
this
is
a
proposal
that
alan
was
vouching
for
so
for
the
new
apis
for
random
access.
A
D
Yeah,
yes,
yes,
true,
but
kansic,
I
think,
is
special
because
we
only
support
physical
files
and
not
pipes
or
that
kind
of
sort
of
files.
So
those
files
are
not
seekable
and
hence
it
will
throw
in
certain
method.
A
A
B
The
answer
to
all
the
questions,
but
I
think
I
think
right
now
adam's
proposing
exposing
something
that's
already
there.
It's
just
internal
and
he's
currently
delay
computing.
It
I
don't
know
what
it
would
look
like
to
delay
compute
reading
and
writing.
It's
probably
possible.
I
just
I
don't
think
it
exists
right
now.
B
I
think
he
had
something
very
specific
in
mind
for
can
seek
why
he
wanted
it
to
be
exposed,
specifically
the
ability
to
call
random
access.getlength
without
without
it
throwing
the
alternative
would
be,
I
think
maybe,
instead
of
exposing
can
seek,
would
be
just
exposing
a
tri-get
length
or
something
like
that.
C
B
Path
so
the
the
file
that
you're
opening
you
know
if
I
open
something
from
proc
fs,
for
example,
it's
not
seekable,
but
it's
just
a
file
path.
B
E
B
F
B
C
A
B
File
descriptor
for
but
by
name,
but
it's
not
actually
on
disk,
it's
not
takable
gotcha
yeah.
I
buy
eric's
argument
as
well.
I
I
don't
know
that
there's
significant
value
in
can
reading
can
write.
I
also
think
there's
the
alternative
we
could
consider.
I
don't
have
a
strong
opinion
that
to
avoid
that
discussion
instead
of
exposing
it
can't
seek,
we
have
a
try
get
length.
B
C
C
B
B
That
would
be
a
breaking
change
from
net
six.
Well,
I
guess
it
wouldn't
right
now
that
would
throw
an
exception
and
we'd
be
making.
A
I
mean
to
eric's
earlier
point
like
the
the
way
I
see
it
is
it's
not
so
much
replicating
all
of
stream,
but
it's
more
to
determine
you.
You
gave
me
a
handle.
Can
I
actually
use
that
handle
right?
I
mean
things
like
buffer
size
and
other
things
are
probably
not
the
higher
order
bit
there.
It's
more
like
well,
is
the
thing
readable
or
writable
or
seekable,
or
kind
of
the
the
cornerstones
of
the
scenario
you
want
to
fail
early
for
those.
D
There's
the
there
is
a
get
length
method
in
the
random
access
static
study
class.
So
you
can.
You
can
also
determine
if
something
you
think
about
by
checking
the
return
value.
E
So
that
that
gets
stated
every
time-
and
I
don't
agree-
there
are
many
instances
where
you
can
have
something
that
is
variable
sized
and
therefore
seekable
to
an
index
without
having
a
definite
length.
So
while
you
often
can
it's
not
guaranteed
that
length
being
non-existent
means
that
you
can't
seek.
B
Sorry,
there's
too
many
negatives
in
that
statement
for
me
to
parse.
Can
you
give
me
a
concrete
example.
E
There's,
for
example,
you
can
have
you,
can
you
can
create
streams
potentially
only
via
the
os
apis?
I
I
don't
remember,
but
you
can
create
a
stream
that
that
is
seekable
but
does
not
have
a
node
length.
E
B
B
E
B
Okay,
what
do
you,
what
is
it
you're
pushing
back
on.
B
E
B
Not
talking
about
you're
saying
not
because
of
any
practical
concerns,
you're
saying
just
philosophically
you
don't
like
that
idea.
B
Sure,
but
we
wouldn't
say
that
we
would
say
rather
than
get
length
throwing
when
it
couldn't
get
the
length
it
would
return
negative
one.
B
B
E
B
E
E
Yeah
and
I'd
have
to
go
and
read
the
posix
spec
and
find
out
the
the
case
where,
where
it
is
possible-
and
then
you
know
share
all
of
that,
but
I
I
don't
remember
off
the
top
of
my
head.
Where
and
under
what
setup
that
can
happen,
I'm
only
fairly
positive
that
there
is
a
scenario
under
which
it
can.
F
F
B
B
To
the
scenario
where
you
pass
file
offsets,
but
it'd
be
really
nice.
If
you
could
use
these
read
and
write
methods
with
a
pipe
or
something
like
that,
where
passing
in
an
office
that
doesn't
really
make
sense,
so
I
think
for
dot.
Net
seven
adam
has
an
open
issue
to
remove
that
constraint,
which
is
fairly
artificial
and
you
could
pass
in
a
file
offset
of
negative
one
or
something
and
it'll
just
you
know,
write
to
the
current
position.
B
If
there
is
a
current
position,
at
which
point
such
an
is
valid,
doesn't
actually
jive
with
that.
Well,
because
you
can
still,
you
know,
you
could
still
read
and
write
with
it,
but
you
couldn't
get
its
length,
so
I
think
it
would
end
up.
We,
I
think,
we'd
want
something
more
specific
for
you
know
if
we
wanted
to
flip
it
on
its
head,
like
you
were
saying,
have
a
random
access,
dot
can
get
length
or
random
access
dot
can
seek
or
something
that
took
the
file
handle.
C
G
A
C
B
A
fine
name
given
the
the
the
overloads
we've
currently
provided.
I
think,
if
we
were
to
add
new
overlays
that
did
not
take
an
offset,
it
would
start
being
a
very
poor
name,
but
maybe
there's
a
middle
ground.
We
can
thread
where
you
know
we
allow
either
we
just
suck
it
up
and
say
you
know:
okay,
it
was
a
wasn't
the
best
name
choice
or
we,
you
know,
allow
a
negative
one
or
something
for
the
file
offset.
B
I
mean
if
we
could
tentatively
approve
something
if
you
like,
but
this
was
yeah.
He
just
opened
this
yesterday,
so
getting
more
insight
into
his
thoughts
and
maybe
tanner
could
research
the
condition
that
he
was
thinking
of
as
well.
A
B
No,
I
don't
think
we
should
negative
one,
I'm
fine
with
what
he's
proposed
as
a
tentative
thing,
but
there
were
a
bunch
of
questions
raised.
You
know,
eric's
suggestion
about
moving
it
to
random
access
as
a
static
sure,
so.
C
B
Oh
yeah,
okay,
so
this
one's
interesting,
I
will
channel
the
poster
here.
So
in
dot-net
six
we
redid
string
interpolation
to
have
a
builder
model
and
the
compiler
targets
a
particular
builder
or
called
a
handler,
and
so
when
you,
you
can
write
custom
ones,
but
for
just
string
target
typed
string,
interpolation,
you
know,
dollar
sign,
quote
blah
blah
blah
assigned
to
a
string
or
passed
to
a
string
property.
B
It's
basically
the
values
string
builder
type
that
we
have
internally
but
geared
towards
being
used
for
string
interpolation,
and
you
know
it
exposes
append
literal
append
formatted
that
takes
a
t,
etc.
And
then
it
exposes
a
two
string
and
clear
method
which
the
compiler
emits
a
call
to
actually
produce
the
final
string.
B
The
api
surface
area
is
is
what
the
compiler
needs
and
only
what
the
compiler
needs.
We
did
not
design
it
for
direct
use.
It's
in
compiler
services
and
in
fact
you
know-
we've
been
hesitant
in
the
past
to
expose
value,
string,
builder
or
or
anything
like
it,
because
it's
a
you
know
a
struct
that
wraps
an
array
pool
array
and
when
you
dispose
it,
it
returns
it
to
the
pool
and
so
on
so
now
default,
interpolated
string
handler
isn't
actually
disposable.
B
It
returns
the
array
to
the
pool
to
the
pool
in
to
string
and
clear,
but
it
would
have
a
similar
issue
if
you
pass
this
by
value,
call
to
string
and
clear
in
one
frame
and
then
in
the
calling
frame,
you
call
to
string
and
clear
again
we
end
up
double
returning
an
array.
B
B
We
basically
call
effectively
text
dot
two
string
to
get
the
slice
of
the
internal
buffer.
That's
been
used
and
return
it
as
a
string.
The
the
poster
is
asking
that
we
make
that
public
and
then
also
that
we
make
a
clear
method
public
to
string
and
clear,
also
calls
a
clear
helper
with
the
goal
of
using
the
system.
B
Runtime
compiler
services-
api,
not
just
for
streaming
interp
interpolation
by
you,
know
being
targeted
by
the
compiler,
but
directly
by
as
a
as
an
arbitrary
string
like
builder,
that
arbitrary
code
could
use
and
not
necessarily
wanting
to
turn
it
into
a
system.string
but
being
able
to
get
the
span
from
it.
B
So
it
could
use
the
built
up
text
in
some
other
for
some
other
purpose
like
passing
it
out
to
you,
know
up
through
a
p
invoke
or
something
so
that's
the
proposal
is
adding,
is
making
default,
interpolated
string
handler
something
that
was
intended
purely
for
compiler
consumption
to
something
that
we
actually
add
apis
for
because
we
expect
developers
to
call
them
directly.
B
I
have
very
mixed
feelings
about
this.
On
the
one
hand,
these
are
super
small,
simple
apis
on
the
other.
It's
taking
something
that
we
put
in
compiler
services
and
recommending
and
adding
apis
purely
so
that
people
can
use
it
manually.
A
A
B
B
A
A
B
A
E
I
guess
I
mean
it's
really
no
different
than
if
like
say,
reflection
emit
actually
supported
all
language
features
or
sorry,
link,
expression
supported
all
language
features,
and
someone
wanted
to
use
link
expressions
to
support
this.
A
B
A
B
A
fine
request
we
use,
we
use
value,
string
builders,
you
know
as
spam,
which
is
what
text
is
and
what
text
should
be
named
if
we
were
to
actually
approve
this
right.
We
use
that
all
the
time
internally.
So
it's
a
you
know,
it's
you
build
up
something,
and
then
you
do
something
with
the
data.
You
don't
actually
want
to
convert
it
to
a
string
right,
but
it
that
that
goes
against
the
grain.
For
what
the
default
interpolated
string
handler
is
right.
It's
it's
there
for
roslyn's
string,
interpolation,
creating
strings.
F
B
You
don't
pass
it
by
ref
and
you
call
to
string
and
clear
or
you
call
you
know,
text
after
it's
been
cleared
in
a
different
frame.
So
it's
not.
Actually
it's
already
been
returned,
but
they're
still
using
it.
Maybe
that's
what
you
just
said:
yeah.
A
I
mean
in
a
sense,
you're
already
halfway
pregnant
right,
because
you
already
have
the
type
public
where
we
just
burdened
to
the
compiler
services
right,
but
somebody
found
it
and
now
they're
asking
for
apis
on
it.
But
it
seems
I
don't
know
like
if
we
don't
expose
the
apis
and
they
basically
copy
and
paste
the
type
and
build
you
know
run
their
own.
Then
not
sure
that
that's
necessarily
better,
because
I
think
the
fundamental
problem
of
the
type
is
that
it's
a
effectively
a
struct
based
builder
right
and
that's
kind.
D
E
And
I
I
don't
have
a
particular
weigh-in
on
whether
or
not
this
should
be
approved,
because
I
don't
really
have
my
own
use
case
for
it,
but
at
least
from
the
perspective
of
users
could
do
something
wrong
with
it.
There's
lots
of
things
users
can
do
wrong
with
all
of
the
struct
and
other
types
under
system.
E
Runtime
system
runtime
is
a
special
namespace,
and
if
you
use
it,
you
should
know
what
you're
doing,
and
so
to
that
extent,
if
someone
uses
default,
interpolated
string
handler
for
their
own
purpose,
whether
it's
roslyn
or
f-sharp,
wants
to
add
it
or
one
of
the
plethora
of
you
know.
Community-Provided.Net
languages
wants
to
use
it.
E
We
should
make
sure
that
it
fits
their
use
case
and
needs
it
shouldn't
just
fit
roslyn,
and
it
may
be
that
you
know
they're
just
holding
it
wrong
and
they
don't
need
clear
and
text
for
that
use
case,
and
we
really
only
want
it
to
be
used
in
the
way
that
rosslyn's
using
it.
But
I
I
don't
think
we
should
look
at
this
just
from
the
perspective
of
they're,
not
rosalind,
so
they
shouldn't
use
it,
which
is
kind
of
how
it
it's
coming
across.
To
me.
B
It's
not
they're,
not
rosalind,
they
shouldn't
use
it.
It's
this
exists
to
support
the
c-sharp
language
in
string
interpolation,
that's
its
entire
purpose
in
life.
B
A
A
You
know
in
the
spirit
of
the
feature,
I
would
say
right,
like
I'd,
be
way
more
concerned,
the
person
writing
this
is
kind
of.
Like
a
you
know,
a
creative
hacker.
I
think
they
have
like
some
convoluted
unsafe
code
and
then
they
want
to
have
these
apis,
that
that
would
be
different
from
you
know
the
way
they
presented
it
here
is
kind
of
like
yeah,
we
generate
code
and
you
know,
becomes
implementation
needs
of
the
generated
code,
but
it
would
make
the
code
more
efficient
right.
A
That
seems
kind
of
like
why
we
did
it
also
as
a
video
stream
builder,
because
we
said
well,
the
you
know,
the
perf
gains
are
substantial
and
we
don't
exert
able
to
hand
write
this.
So
that's
why
we
were
okay
with
that
and
that
seems
kind
of
what
this
person
is
doing
here
as
well.
So
assuming
they
get
the
generator
right
well,
then,
it
seems
like
a
fine
use
of
the
feature.
A
E
And
I
definitely
think
we
shouldn't
do
anything
that
hinders
c-sharp's
ability
to
use
the
api
or
version
the
api
moving
forward,
but
also,
I
I
think,
when
we
expose
types
like
this,
if
they
are
really
c
sharp
specific,
we
should
probably
put
them
under
something
like
compiler
services
c
sharp
to
imply
that
they're
only
meant
for
interrupt
and
compat
with
c
sharp.
B
A
A
Yeah-
and
I
mean
in
general,
though,
like
I,
I
think
the
way
we
did
you
know
do
things
in
compiler
services.
We
we
do
things
for
language
features,
but
we
usually
design
them
as
building
blocks
such
that
if
another
language
like
vb
or
f-sharp,
wants
to
use
or
wants
to
do
something
similar,
that
they
have
the
same
building
block
and
then
have
to
re-implement
it
from
scratch
right.
So
we
so
to
me,
it's
not
necessarily
a
contradiction
to
say
it's
specific
for
the
c-sharp
feature
without
making
it
too
sharp
specific.
A
C
B
Developers
to
go
and
use
this
manually
now
for
saying
that
we
will
continue
to
dissuade
that,
but
we're
adding
it
so
that
a
different
language
can
use
it.
I
I
don't
have
you
know
the
strong
objections
to
that
where
I'm
concerned
is
we're
we're
on
a
slippery
slope
here
with
exposing
array
pool
behind
strucks.
A
A
Yeah
I
share
that
concern.
I
mean
to
me.
This
is
why
I
said
like
the
saving
grace
here,
in
my
opinion,
is
that
this
is
another
generator,
so
it
doesn't
seem
as
bad
like
again.
If
anybody
asks
for
usability
features
on
this
type,
then
you
know
the
answer,
for
that
would
always
be
no,
because
it's
not
meant
to
be
usable
right.
It's
meant
to
be
emitted
effectively
right.
I.
C
E
That
exactly,
I
think,
the
big
difference
is
that
value
string
builder
would
have
likely
been
in
system.
It
would
have
been
a
counterpart
to
string
builder
and
it
would
have
been
something
that
developers
would
want
to
use
directly.
It
wouldn't
be
something
restricted
to
source
generators
or
compilers,
whereas
here
it's
in
compiler
services
and
the
use
case,
isn't.
Oh,
I'm
writing
my
own
handwritten
code.
It's
I'm
writing
a
generator
that
can
benefit
off
of
this
and
therefore
the
generator
will
handle
things
being
correct.
E
Right,
but
there
are
cases
where,
like
it's
in
compiler
services,
it's
clearly
not
meant
to
be
used
manually,
just
like
most
of
unsafe.
Most
users
shouldn't
be
writing.
You
know
system
runtime,
compiler
services
unsafe
unless
they're
doing
very
specific
compiler
level,
optimizations
and
tweaks
for
perf
and
because
they
know
what
they're
doing.
E
I
I
don't
think
we
can
forever
say,
like
c
sharp
doesn't
have
ownership
semantics,
so
we
can't
ever
expose
some
value
string
builder
for
advanced
users,
because
if
we
permanently
hold
that
bar
we're
going
to
always
have
stuff
that
only
we
have,
the
interested
parties
are
going
to
copy
that
out,
not
get
bug,
fixes
improvements
or
necessarily
properly
understand
the
use
case
for
it
and
how
to
hold
it
correctly,
whereas
if
we
do
ship
it
but
put
it
under
the
relevant
runtime
area,
we
can
at
least
provide
docs
of
hey.
E
A
I
mean
yes
and
no
right.
I
think,
on
the
one
hand,
side,
I
don't
think
it's
a
contradiction
to
say
we
would
never
ship
the
type,
because
people
can
copy
and
paste
our
implementation,
because
in
a
sense
that
is
already
the
necessary
speed
bump,
you
had
to
actually
go
to
a
repo
find
the
code.
You
know
copy
paste
the
relevant
pieces
out
of
it
right
and
that
that's
a
very
different
thing
from
saying.
Oh,
I
stumbled
over
this
neat
looking
api
in
the
system
name
space.
I
call
it
and
I
immediately
hang
myself
right.
E
A
A
A
But
I
mean
to
me
there
is
radio
and
adding
building
blocks
with
the
platform,
even
if
they
are
unsafe.
But
you
know
if
it's
four
lines
of
code
and
the
primary
reason
we
added
is
usability.
Then
I
would
say:
maybe
that's
not
actually
that
good,
because
now
you're
effectively
making
something
usable
that
arguably
shouldn't
be
usable
versus,
oh
yeah,
we
make
something
into
the
platform
because
it's
you
know
a
thousand
lines
of
really
tricky
code
to
get
right
then.
E
Right
and
I
I
completely
agree-
we
shouldn't
just
expose
every
little
helper,
but
I'm
specifically,
referring
to
cases
like
you
know,
unsafe
exists
because
it's
incredibly
hard
to
get
not
only
writing
the
the
il
correctly
in
a
way
that
the
runtime
can
understand
it
and
do
the
right
thing,
but
also
shipping,
an
il
proj
explait
is
nigh
impossible
for
the
average
user.
A
Yeah-
and
I
think
we
generally
include
that
in
the
conversations
that
we
had
on
this
thing
so
just
to
circle
it
back
on
the
on
this
particular
thing,
should
we
then
not
expose
an
api
or
should
we
expose
the
api
like?
I
am
at
this
point
kind
of
of
the
opinion
that
it's
two
apis.
We
already
have
them.
They
seem
within
this
bit
of
the
feature.
I'd
be
okay
with
proving
it
steven
seems
to
be
on
the
fence.
I
don't
think
one
way
or
the
other.
A
I
don't
think
we
set
precedence
here,
so
I
I
can
go
either
way
and
then
say:
well,
let's
reserve
the
api
for
case
of
more
people.
Ask
for
it.
I
think
that's
a
reasonable
bar.
We
can
expose
it
and
say
yep
we're
okay,
with
these
two
things,
because
they're
just
you
know
minor
kind
of
tweaks
of
what
we
already
have,
and
this
type
is
already
sufficiently
buried
and
has
a
sufficiently
ugly
name
that
we
don't
expect.
The
vast
majority
of
people
to
just
you
know
willingly
use
the
type.
E
What
one
thing
I
want
to
say
is
to
me:
it
sounded
like
steven's
biggest
pushback.
Was
you
know,
aside
from
whether
or
not
we
should
expose
these
apis?
It
was
if
we
did.
There
was
a
question
of
kind
of
leaking
internal
implementation
detail
and
not
allowing
us
to
move
it
forward
in
the
future,
and
if
that's
the
pushback,
then
I
think
it's
fine
to
say
no
with
that
regard,
but
maybe
to
take
a
look,
you
know
separately
of.
B
I
think
that
so
I
it's
I
it's
a
small
part
of
my
concern.
It's
part
of
the
concern,
but
it's
you
know
we
have
designed.
We
designed
this
for
the
specific
scenario
of
creating
strings
and
to
emo's.
You
know
point
earlier
if,
if
we
decided
that
for
a
certain
case,
it
was
better
for
us
to,
you
know,
keep
renting
additional
buffers
from
the
pool,
storing
them
in
a
linked
list
rather
than
copying.
B
You
know
renting
a
new
buffer
twice
as
big
copying
it
over
and
like
that
improved
the
performance
for
the
typical
two-string
case
like
we
would
happily
do
that
to
improve
interpolated
strings
because
that's
exactly
what
this
type
is
for,
and
I
think
we
would
do
that
and
sacrifice
the
text,
property
or
the
as
span
or
something
if,
if
we
add
as
span-
and
it
prevents
us
from
doing
that,
optimization
that's
unfortunate
now,
I
don't
know
that
it's
actually
an
optimization,
it
probably
has
pros
and
cons,
and
it
probably
for
the
most.
B
So
if
we
were
really
concerned
about
that,
we
could
do
try
to
try
get
text
or
try
as
fan
or
as
fan
could
throw
or
you
know
whatever.
I
don't
know
that
it's
a
real
concern,
but
I
do
I
do
struggle
with
adding
functionality
to
types
that
goes
against
you.
That's
not
on
the
main
path
for
what
those
types
were
created
for.
B
If,
if
the
functionality,
if,
if
the
implementation
we
have
today
were
to
remain
for
the
next
decade-
which
it
probably
will
you
know,
barring
minor
tweaks
here
and
there-
and
if
we
really
felt
comfortable
saying
that
you
shouldn't
use
this
type
manually,
but
you
know
if
you're
a
source
generator
compiler
writer
like
yeah,
go
ahead
and
for
your
needs.
There
are
actually
these
additional
apis
that
roslyn
doesn't
use,
but
maybe
you'll
find
useful
for
your
scenarios
like
I'm.
I
don't
have
strong
pushback
to
that.
B
Where
I
start
to
get
concerned
is
either
we
do
expect
to
evolve
the
implementation
or
and
or
we
start
promoting
this
in
either
our
posts
or
other
people's
posts.
Hey
you
want
a
cheaper
string
builder
go
use,
this
interpolated
string
handler
thing
and
oh
by
the
way,
visual
studio
will
add
the
name
space
for
you
automatically,
so
don't
worry
about
where
it's
defined
and
look
at
all
these
fun
things
you
can
do
with
it.
That's
where
I
start
getting.
E
Would
you
lead
more
towards
yes
if
it
was
just
clear
and
a
copy
two
span
method
that
way
it
avoids
the
leaking
of
the
of
the
backing
buffer.
E
My
my
assumption,
and
maybe
sergio
you
can
comment
if
it
matches
or
not,
is
that
the
main
reason
to
avoid
the
tostring
is
specifically
to
avoid
the
allocation
here
when
you
have
downstream
apis.
That
will
continue
taking
a
span,
in
which
case
the
copying,
while
not
as
cheap
as
directly
getting
the
span,
would
alleviate.
Most
of
that
concern.
E
Else
right,
which
could
be
your
own
array
pool
entry
or
a
stack
allocated
buffer.
B
E
E
It
avoids
the
issue
of
of
leaking
the
backing
array
pool
implementation.
So
there's
no
concern
with
being
reliant
on
having
a
single
contiguous
array
to
to
return
a
span.
B
Yes,
it
does,
it
does
address
that
part
of
the
concern,
but
it
also
makes
it
more
expensive
to
access
the
data,
and
if
I
was
using
this
because
sergio
said
quote,
it's
perfect,
my
guess
is:
it
would
no
longer
be
perfect
at
that
point
and
for
whatever
his
high
performance
needs,
are
he'd
rather
go
right
with
that.
E
In
this
case,
based
on
the
comments,
it's
because
it's
generating
shader
code,
it's
basically
transpiling
shader
code
and
filling
in
format,
holes
in
it
so
that
it
can
be
compiled
with
the
directx
compiler,
which
will
take
an
in-memory
buffer.
So
you
can
avoid
the
allocation
and
just
pin
and
pass
that.
A
A
B
B
For
example,
we
we
do
checks
for
things
like
cust,
I
custom
formatter,
which
presumably
he
doesn't
need
to
pay
for.
A
Yep
and
then
I
think
we
can
call
it
a
day,
I'm
always
happy
when
we
make
decisions
all
right.
So
then,
unless
somebody
has
something
else
that
shows
up,
I
think
this
was
it
for
today.
No,
that
seems
to
be
it
yeah.
I
said
you,
please
feel
free
to
comment
more
and
give
us
more
insight
into
your
scenario.
We're
also
happy
to
host
you
on
the
stream,
if
in
case
you
want
to
chime
in
in
person.
A
Just
let
us
know
in
the
comments
sergio.
B
Also,
to
answer
your
last
question
there-
sarah,
yes,
this
is
ice
band
formatible
check
is
resolved,
but
the
there
is
an
I
custom
formatter,
that's
about
the
I
format
provider,
not
about
the
about
the
t.
A
E
Like
uwp
related
thing,
if
I
remember
right,
but
I
I
don't
remember
the
specifics.
A
Either
way
cool
stuff
all
right,
then
this
is
it
and
then
I
see
all
of
you
next
week
when
we
talk
about
civilization,.