►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
Hello,
freunda
phil
common
on
api
review,
overflow
still
down
to
two
red
we're
holding
it
almost
done
with
red,
we'll
see
how
long
that
lasts,
but
they're
red
so
we'll
start
something
about
dynamic
interface,
castable
implementation
attribute,
which
is
almost
longer
than
my
screen.
Four
one.
Five
two
niner.
B
So
the
backend.net
five
we
introduced
the
I-dynamic
interface
castable
interface
to
enable
people
to
write
their
own
interop.
That
was
that
behaved
similarly
to
the
com.
Interop,
that's
built
into
the
wrong
time,
and
the
way
that
that
worked
was
through
a
combination
of
dynamic
interfaces
and
some
hooks
into
the
type
system
through
that
interface
as
well
as
this
attribute.
So
we
required
that
implement
that
implementation
interfaces,
which
are
the
interfaces
that
provide
an
implementation
for
a
given
type
that
doesn't
actually
directly
implement.
The
interface
needs
to
have
this
attribute
on
it.
A
A
Fair
enough,
so
really
so
this
is
just
an
analyzer
and
basically
what
the
analyzer's
doing
is.
If
you
have
inherited
members
that
are
not
visible
directly
on
your
interface
level,
then
or
no,
because
it's
not
even
that.
B
So,
and
so
baz
is
an
example
of
the
other
diagnostic
that
baz
that
you
need
to
do
two
things
with
baz
a
it
needs
to
have
a
body
and
b.
It
needs
to
be
sealed,
because
even
if
it's
not
sealed
and
it
has
a
body,
the
run
time
will
try
to
look
up
on
the
actual
type
of
the
object.
Give
me
the
implementation
of
baz
and
then
the
runtime
type
will
be
like
I
don't
implement
bar
because
it
doesn't.
B
D
Fair
enough
yeah,
the
the
analyzer,
makes
sense
to
me
honestly,
like
your
you're,
detecting
code
that
will
never
ever
work
at
runtime
and
you're
telling
them.
This
is
what
you
have
to
do.
B
C
I
can
I
can
answer
this,
no
because
this
is
only
for
a
com,
rapper
scenario
and
com.
Rappers
is
not
supported
in
vb.net,
so
doesn't
matter
okay.
That
would
be.
That
would
be.
My
argument
like
this
is
for
the
com
rapper
scenario,
unless
you're
thinking
this
is
useful.
Other
places.
A
B
A
E
B
Yeah
and
then
the
other
thing
based
on
that
was,
there
was
a
comment
down
below
from
someone
in
the
community
about
whether
or
not
we
want
the
severity
of
these
to
be
error
instead
of
warning.
I
don't
know
if
we
allow
out-of-band,
analyzers
or
even
in-box
analyzers,
that
aren't
provided
by
the
compiler
itself
to
be.
A
We
wouldn't,
I
don't
think
we
would
change
something
that
had
previously
shipped
his
warning
to
error,
and
if
this
is,
I
guess,
if
it's
on
by
default,
we
probably
want
it
to
be
warning
if
it
shipped
with
the,
inter,
I
guess,
is
the
is
the
interface
itself
new
in
six,
no.
B
A
Yeah
I
mean
if
emo
were
here,
I
would
let
him
say
what
the
rules
are,
because
he
would
know
them.
I
know
that
we
often
don't
like
adding
errors.
A
We
add
warnings
and
people
compile
with
warren
as
error,
and
then
we
shrug
and
say
then
don't
do
that
the
compiler
team
no
longer
believes
they
can
shrug
and
say
don't
do
that,
but
the
yeah.
So
I
don't
know
what
the
what
our
rules
are
for
introducing
new
errors
as
on
by
default,
but
introducing
a
new
warning
is
on
by
default.
I
I
think
we've
done
that
already.
B
H
B
B
H
Right,
I
think
that
impacts
this
decision
as
well,
though,
because
if
we're
saying
it
only
runs
in
net
six,
then
you
have
to
be
targeting
that
six
and
now
it's
like
for
a
new
error
in
net
six,
you
you've
upgraded
your
app
and
now
you're
getting
an
error.
I
think
that
falls
in
line
with
that's
okay,
but
if
your
net
five
app
and
you
just
upgrade
to
the
new
sdk
and
now
the
analyzer
runs,
and
it
gives
you
errors
and
it's
broke.
I
think
that
falls
in
the
that's,
not
okay
category.
C
C
I
think
this
was
a
mistake
that
we
didn't
have
it
right
like
it
was
just
a
missed.
We
didn't
have
time
so
we
or
we
didn't
think
about
it.
So
I
agree
with
eric,
like
maybe
we
should
just
say
this
is
only
for
six
and
error
because
it
really
is
wrong.
I
I
think
that
the
op
on
this
one
that
asked
about
the
error
had
a
good
point.
It's
literally
broken
so.
B
B
Yeah,
I
will
say
the
call
stacks
for
when
the
runtime
like
when
you,
when
you
don't
follow
either
of
these
recommendations,
and
then
you
try
to
call
something
it
gets
really
weird,
especially
the
second
one,
where
you're
trying
to
call
a
virtual
method
on
the
same
interface
that
has
a
default
implementation.
Then
it's
like
this
doesn't
implement
it.
I
can
find
no
implementation.
A
I
So,
in
sofa
internet
six
we've
been
introducing
a
new
pattern
for
json
civilization.
Where
is
this
search?
Generator
generates
type
metadata
that
the
serialization
uses
to
perform
visualization
of
types,
and
this
metadata
is
started
in
fibro
and
previously
the
generator
was
generating.
I
I
mean
the
system
textures
and
serializer
was
generating
these
things
at
runtime
on
using
reflection,
and
that
has
been
pushed
to
compile
time
with
these
benefits
of
primarily
in
this
scenario
is
about
size
where
we're
able
to
trim
out
reflection
code,
perhaps
because
we've
already
done
the
work
compile
time.
So
why
would
you
want
some
more
system
pictures
and
because
you
don't
think
that
could
also
with
the
source,
generator
we're
able
to
figure
out
what
converters
are
needed
and
to
realize
that
this
realize
the
type?
I
Because
converters
are
the
actual
mechanism
that
we
used
to
turn
jason
into
objects
and
objects
into
adjacent.
So
previously,
fiber
would
keep
all
the
converters
around,
because
the
only
information
would
have
was
the
type
and
step
could
be
anything.
But
research
generations
were
able
to
see
like
what
types
and,
therefore
what
converters-
and
we
don't
security.
I
So
the
system
network
json
apis,
are
built
on
top
of
system
collection
and
allow
users
to
turn
their
other
net
objects
and
serialize
them
somewhere
to
some
destination
like
see
over
the
wire,
and
so
the
json
content
type
is
a
type
that
we
have,
that
that
defines
some
object
that
can
be
serialized
to
json.
I
So
underneath
that
the
mechanism
would
just
force
it
for
civilizing.
That
was
just
called
jason
serializer
capacitation
to
share
some
content,
and
we
had
aps
to
create
this
json
content
type
with
tip,
took
jason's
laser
options,
and
we
would
call
this
user
with
options
that
pattern
of
passenger
synthetizer
with
options
is,
is
now
we
we
are
determining
that
that
that
we're
defining
it
as
the
like
linker
size
of
friendly
way
to
do
it
in
60,
because
for
backward
compact,
we
need
to
keep
all
of
that
code.
I
So
if
we
expose
new
apis
to
create
this
json
content
type
that
can
take
pre-generated
information
about
types.
So
this
just
synthetizer
context
and
json
type
with
four
types.
Then
the
underlying
serialization
mechanism
can
call
new
overloads
that
take
those
types
and
call
this
realization
any
way
that
we
can
get
the
benefits
of
social
animation.
I
So
here
you
can
see
that
I
said
we
can
add
a
new
json
content
of
t
type,
which
is
the
type
json
content
type
and
then
the
reason
why
it's
type
is
typed
is
we
want
to
create
an
instance
of
it
with
type
json
type
info
g
value
which
we
need
to
pass
the
serializer.
So
that's
why
we
have
the
t
value
there,
and
so
we
just
have
this
type
and
the
create
method
which
I
propose
to
go
on
the
original
json
content
type.
I
Just
because
I
mean
those
are
already
visible
to
users,
users
know
about
them,
and
it's
also
to
avoid
a
scenario
where,
for
the
for
the
overlords
of
all
the
cases
where
we
pass
the
content,
the
context
type
itself
to
the
serializer.
That's
for
cases
where
we
don't
know
what
the
type
is
so
input
type.
So
in
that
case
we,
the
the
type,
is
treated
as
object,
so
we
want
to
keep.
We
want
to
have
it
to
the
generic
type.
I
There
will
be
json
content
of
object
and
it's
better
to
put
those
create
methods
on
the
json
content
type,
which
is
not
generic,
so
that
users
can't
write
things
like
jsoncontent.int
and
because
vt
could
be
anything.
So
we
don't
want
decent
content
of
t
to
create
a
json
content
of
object.
I
So
that's
why
I
put
the
great
methods
on
the
json
content
type,
and
so
the
usage
there
just
scrolling
down
if
api
is
understandable,
will
just
be
so
in
the
in
in
the
system
like
jcpgs,
and
we
have
this
put
us
async
put
adjacent
async
and
poster
json
async,
both
of
them
serialize,
okay,
json
content
to
some
extreme
destination.
I
So
here
we
called
rather
than
calling
old
apis
that
we
told
just
all
the
reflection
code.
We
called
these
new
ps
that
take
the
json
content.
I
mean
the
adjacent
typing
for
adjacent
context,
so
you
see
that
line.
Right
return
is
where
we
create
the
context
and
because
it's
a
new
type
that
has
a
different
implementation,
the
linker
is
able
to
trim
out.
I
mean
we're
not
going
to
use
the
differentiation
content
type
that
holds
on
to
all
the
the
reflection
code
that
we
don't
that
we
don't
need
here.
I
A
I
Like
conceptually
like
one
would
want
like
one
would
think
that
that
that
would
be
the
relationship,
but
if
we
were
to
do
that,
the
base
implemented
like
so
the
way
the
serialization
works
is
there's
a
a
virtual
method
on
I
release
on
the
client
and
then
we
overwrite,
we
overwrite
that
with
the
implementation
to
call
the
serializer
with
the
options
based
code.
So
if
we
direct,
if
we
make
the
new
json
content
activate
from
that
the
link,
I
wouldn't
know
that
could
remove
the
implementation
on
the
base
type.
I
So
it
doesn't
give
us
the
benefit
to
want
of
reduced
size.
You
don't
need
to
teach
the
linker
that,
based
on
like
the
method,
base.method
wasn't
called
so
you
can
trim
out
that
code,
but
today
linker
doesn't
know
that.
So
if
we
make
it
derive
from
http
content
directly,
then
we
don't
have
the
implementation.
We
don't
want
in
the
hierarchy.
Delinquent.
I
I
A
I
People
do
use
the
json
content
of
t
type
if
they
want
to
extend
to
provide
more
information
on
the
content
like
to
say
these
are
the
header
types
for
the
for
the
content,
because
in
the
implementation
that
we
have
in
the
extension
method,
we
just
use
json
header
type,
and
so,
if
you,
if
you
want
to
do
additional
configuration,
then
you
would
be
interacting
with
the
type
directory
and
then
you
could
also
care
about
like
how
much?
I
I
I
Otherwise,
we
could
have
just
kept
the
internal
and
then
just
have
the
the
client
extension
methods
just
use
internal
types,
but
just
like
we
exposed
some
content
and
the
people
that
use
it.
I
think
those
same
people
could
care
about
the
size
of
jobs.
A
That
can't
so
I
don't
understand
why
anyone
would
ever
want
so
really
it's
the
the
json
content
of
t
not
deriving
from
json
content,
even
though
they're
both
instantiable
like
that
feels
a
little
weird.
But
if
this
is
you
only
have
like
10
customers
in
the
world,
then
we
don't
care
the
more
customers.
You
have,
the
more
we
might
care.
I
Yeah
I
mean
we
could
always
wait
to
see
if,
like
people
ask
for
it,
the
question
is,
we
already
have
the
existing
type
and
then
we
added
it
for
for
a
reason.
So
this
is
another
course
to
it.
I
mean
it's
just
the
same
type
of
with
different,
like
requirements
from
the
user
app.
So
if
you
want
to
say,
want
customer
feedback,
that's
also
like
acceptable
to.
A
And
there's
a
very
good
comment
from
chat,
which
is
we
I'll
just
read
it
verbatim?
Thank
you,
kevin
cathcart,
the
non-generic
class
has
a
private
constructor
and
the
end
is
only
created
by
factories.
So
if
we
wanted
the
inheritance
model,
we
could
move
the
reflection
implementation
to
a
new
internal
derived
type.
A
I
A
Code
off
of
the
json
content
type
into
a
new
internal
type,
return
that
from
the
create
methods
that
already
exist,
you
don't
need
to
change
the
the
declared
return
type
which
you
can't
anyway
and
then
now
you
have
the
now.
The
class
definition
looks
more
sensible
and
somebody
who
was
already,
who
already
had
a
json
content
exposed
in
their
api,
can
now
use
adjacent
content
of
t.
A
A
A
Right
so-
and
you
know,
people
who
understand
the
linker
can
correct
me
if
I'm
wrong,
but
if
the
only
thing
that
pulls
reflection,
json
content
or
whatever
you
want
to
call
it
into
the
closure
is
calling
one
of
these
existing
two
methods.
Then,
as
long
as
they
have
zero
calls,
then
all
that
code
goes
away.
D
But
to
large
part
that
doesn't
really
affect
the
api
that
leo
mean
has
brought
breakfast.
It's
mainly
shuffling
some
things
around
right.
D
D
A
A
A
A
A
A
A
All
right,
I'm
bad
at
writing,
inline
diff,
but
all
right
so
does
that
look.
I
I
A
Thanks
we'll
see
how
many
wait
what's
that
gets
from
people
when
the
email
comes
out.
D
A
D
It
at
the
very
top
of
this
a
link
to
the
api
proposal
at
the
very
top
yeah.
So,
basically,
the
scenario
is
if
you're,
transmitting
or
serializing
strings
from
machine
to
machine.
You
know:
different
operating
systems
have
different
new
line
representations
and
we
recently
added
an
api
onto
exception
that
allows
you
to
set
an
exception
stack
trace,
based
on
some
arbitrary
string,
stack,
brace
that
you
get
from
a
row
from
a
remote
machine.
D
Well,
the
stack
trace
that
you
get
from
a
remote
machine
will
be
using
the
remote
operating
systems,
new
line
conventions
which
might
not
necessarily
match
your
current
operating
new
line
conventions.
So
the
end
result
of
this
is
that
you
could
end
up
seeing
malformed
data
in
the
stack
traces.
D
That's
just
one
concrete
example:
we
have
examples
across
unit
tests
and
other
places
where
we
really
just
want
to
say
you
know
what
whatever
line
ending
this
data
happens
to
have
like.
I
just
want
to
normalize
it
to
my
operating
system's
current
one
which
again
on
windows,
would
be
here
and
line.
Feed
unix
is
just
fine,
so
yeah,
so
that
that's
the
api
normalized
line
endings.
If
you
so
string
dot,
normalized
line
endings.
If
you
pass
it
null
as
a
parameter
for
the
line
ending
parameter,
it
will
default
to
using
environment.newline.
D
You
can
pass
it
whatever
arbitrary
string
you
want
to
here
as
well.
You
could
pass
it
an
empty
string
which
would
remove
every
single
new
line
from
the
string.
You
could
pass
it
a
smiley
face
which
will
replace
every
new
line
with
a
smiley
face
and
so
on.
We
don't
put
any
restrictions
on
what
parameter
you
can
pass
in
there.
D
Additionally,
if
we're
adding
this
to
string,
we
should
probably
consider
adding
it
as
an
extension
method
hanging
off
the
grid
on
the
spanish
r,
so
that
you
can
enumerate
these
lines
in
an
allocation-free
fashion.
D
The
behavior
of
this
is
such
that
it
identifies
everything
that
the
unicode
specification
calls
out
as
a
line.
It
looks
for
carriage
return
line,
feed
carriage
return
line,
feed
paragraph
separator
line
separator
and
next
line,
and
it
replaces
all
of
them
with
whatever
you
tell
it
to
replace
it
with,
and
I
have
some
examples
showing
inputs
and
outputs
down
below.
But
that's.
D
Basically,
yeah
and
also
guaranteed
to
run
in
a
same,
oh
whatever.
D
D
It
I
I
did
consider
that
the
reason
that
I
opted
not
to
go
with
it
is
because
this
is
a
very
concrete
scenario
that
can
benefit
from
a
specialized
api
and
doing
it
doing
a
generalized.
K
D
K
L
D
Not
I
I
anticipate
we
would
update
it.
However,
I
I
want
to
say
that
unicode
has
locked
their
list
of
line
endings,
so
that
I
can
double
check
that
there
are
certain
things
in
unicode
where
they
explicitly
call
out
this.
This
will
never
ever
change
under
any
circumstance.
A
D
A
Crlf
is
the
is
the
weird
because
it's
the
reason
it
makes
you
need
string
instead
of
char.
Also,
I
don't
believe.
D
K
K
D
D
The
the
problem
is,
if
you,
if
you
naively
call
something
like
string.index
of
and
pass
in,
you
know
six
different
characters
to
it.
That
is
actually
an
o
of
n
squared
search,
not
an
o
of
n
search.
D
Because
we
cap
our
vectorization
optimizations,
I
think,
and
at
n
equals
at
searching
for
four
different
characters,
and
once
you
go
above
that,
we
fall
back
to
search
for
the
first
one.
Did
that
fail
search
for
the
second
one?
Did
that
fail
and
so
on?
Which
means
each
individual
call
to
index
of
is
n.
But
the
particular
scenario
for
using
this
api
is
that
you
want
to
split
across
new
lines,
which
means
that
you're
calling
it
potentially
n
times
over
an
n
length
string,
which
is
n
squared.
K
D
D
Is
its
own
weirdness,
because
you,
you
also
have
to
search
for
things
like
dot
dot,
slash
like
it's,
not
a
simple
search
in
the
place
and
depending
on
what
segment
you're
searching
for
you
might
need
to
replace
it
with
a
different
substring
like
I
I
didn't
I
intentionally
didn't.
In
fact
I
I
think
I
think
there
was
actually
a
comment
in
here
where
someone
had
suggested
having.
D
Maybe
it
wasn't
here,
maybe
it
was
somewhere
else,
but
some
someone
somewhere
had
suggested
having
a
similar
api
and
I'm
like
well,
we
would
have
to
the
api
that
we
create
would
have
to
be
I'm
trying
to
remember
how
to
phrase
it.
I
mean
it
was
specific
for
paths,
so
it's
not
really
relevant
for
us.
D
K
Yeah
I
get
that
this
can
be
like
better
optimized
than
a
gen
general
thing.
I
just
wasn't
so
sure
about
the
the
algorithmic
complexity,
assuming
that
the
characters
to
replace
were
effectively
constant.
D
Yeah
one
interesting
thing
about
this
is:
I
did
I
did
grapple
and
I
had
some
conversations
with
eric
offline.
Like
hey,
should
we
do
only
error,
return,
line,
feed
and
crl
as
opposed
to
searching
for
all
these
things,
because
that
matches
what
text
reader
document
does?
D
However,
tarik
did
raise
an
interesting
point
offline,
which
was
that
like
well?
If,
if
you
want
to
support
this
in
in
more
advanced
scenarios
such
as
people
using
ide
text,
editor
stuff,
like
that
like
they,
they
could
be
using
different
new
line
sequences
and
additionally,
this
isn't
really
appropriate
for
protocol
parsing
anyway,
because
your
protocol
might
dictate
specifically
only
carriage
return
or
only
line
feed
or
only
crlf,
whereas
we
will
be
searching
for
all
of
them.
L
L
D
So
as
as
a
concrete
example
of
of
where
of
where
this
will
be
inappropriate
for
protocol
parsing,
like
I'm
looking
at
the
http
one,
one
spec
right
now
and
http,
one
one
mandates
that
lines
are
terminated
specifically
with
carriage
return
line,
feed,
not
carriage
return,
not
line
feed
but
character
from
line
feed.
So
even
if
we
were
to
make
this
api
support
only
those
three,
it
would
still
be
inappropriate
for
general
purpose.
Protocol
parsing.
K
K
D
C
D
C
C
D
Everywhere,
it's
it's
general
purpose,
useful
everywhere.
In
my
opinion,
the
the
exception
stuff
is
what's
forced
in
our
hand,
right
now,
because
we
do
have
a
concrete
scenario
where
someone
has
asked.
How
do
I
handle
this
and
I
did
not.
I
did
not
want
to
make
the
exception
type
start
munging
the
incoming
data
as
a
matter
of
policy
like
I,
I
wanted
the
type
to
just
be
like
look.
D
L
L
D
We
we
could,
that
would
just
take
a
source
on
the
destination,
but
yeah
we
could.
We
could
consider
that.
D
Let
me
let
me
check
the
the
apis
that
are
already
on
memory.
Extensions.
I
A
Oh
because
it
ends
up
looking
like
source.2
upper
destination,
yes,
yeah.
D
One
interesting
thing
is
that
this
could
result
in
a
string
larger
than
what
you
pass
into
it,
which
means
we
would
have
to
pessimistically
start
doing
work
and
then
report
back
to
you,
sorry,
the
destination
buffer.
You
gave
us
wasn't
large
enough.
D
Yeah
two
upper
and
two
lower
currently
return
negative
one
if
you
give
them
a
destination,
that's
too
small,
but
it's
like
for
two
upper
and
too
lower.
We
literally
know
that
the
destination
needs
to
be
the
exact
same
size
as
the
surface
yeah,
whereas
here
we
couldn't
make
that
determination,
we
would
actually
have
to
do
this
and
then
potentially.
L
D
L
D
So
if
you,
if
you
were
using
a
cost,
you
could
just
pass
that
in
as
a
single
character,
const
string-
I'm
I'm
not
opposed
to
having
a
char
here,
but
I
anticipated
that
most
people
would
pass
in
environment
on
new
line
or
an
equivalent,
which
is
already
a
string.
L
D
I
I
saw
this
as
similar
to
string
dot,
replace
honestly
where
the
input
was
a
chart,
then
or
sorry
where
it
takes
string,
string
or
charge
r,
and
this
is
string
string,
because
this
is
a
string
but
yeah
I'm.
I
would
be
okay
with
adding
that
overload
if
it's
useful.
A
I
mean
with
with
string
that
replaced
char
char,
that's
because
it
knows
ahead
of
time
exactly
what
the
allocation
size
is
right.
It's
a
there's,
a
special
substitution
and
because
here
you
don't
and
that's
really
just
a
way
of
signaling.
I
promise
that
I'm
replacing
something
with
the
exact
same
length,
and
here
I
don't
know
that
yeah
I
mean
my
general
answer
is
less.
Is.
A
D
I
mean
to
be
to
be
perfectly
honest,
the
if
you're
doing
things
correctly
like
you
should
never
end
up
in
that
situation,
because,
presumably
you
have
html
encoded
the
data
before
you're
doing
a
line,
break
replacement
and
html
encoding.
The
data
will
also
encode
character,
returns
and
line
dates.
D
J
A
D
Whole
framework
did
because
gorgeous
says
I
am
universal.
I
can
be
used
absolutely
anywhere.
I
I
will.
I
will
encode
any
character
that
can't
be
represented
everywhere
safely,
fair
enough.
D
A
I
A
D
A
Right
well,
because
now
you're
down
to
a
single
char
that
you
can
now
do
the
char
replace
later
of
you've,
set
yourself
up
for
not
needing
to
call
this
again
multiple
times,
depending
on
your
different
replacements,
so,
okay,
the
yeah,
so
the
I'll
just
say
things
that
I
thought,
while
you're
looking
through
this
you've
covered.
Most
of
them
do
we.
A
This
is
normalizing
all
kinds
of
line
ending
to
one
kind
of
line
ending.
Is
that
what
we
want
or
do
we
want
something
that
is
like?
A
You
know,
windows
to
unix
and
unix
to
windows
and
other
named
things
like
there's
the
legacy
name
called
mac
from
you
know
years
ago,
which
is
the
carriage
return
instead
of
line
feed.
Yes,
that
max.
D
Yeah,
so
that
that
is
supported
by
this
the
reason,
the
reason
that
I
didn't
say
like
well,
we
replace
environment.newline
with
something
of
your
choosing
things
like
that
is
because
the
scenario
here
is,
I
got
the
data
from
a
source
where
I'm
not
necessarily
sure
what
os
produced
it.
So
I
need
to
pessimistically
support
any
potential
incoming
format
and
then
turn
it
into
something.
That's
native
to
my
os.
L
A
A
Already
have
this
problem
anywhere
or
in
a
bunch
of
our
like
unit
tests
of
because
at
quote
the
compiler
will
embed
the
new
line
of
the
operating
system
that
you
can
ran
the
compiler
on,
and
sometimes
we
want
that
to
be
in
the
to
make
sense
on
the
place
that
we're
running
the
tests.
But.
D
If,
if
you
scroll
down
to
the
very
bottom
of
the
issue,
I
actually
have
a
backlink
from
a
system
code
dom
test
that
ran
into
this.
So
I'm
like
hey
this
api
would
help
you.
F
So
in
particular,
I
don't
think
we
want
like
normalize
from
x
to
windows
or
anything
like
that.
I
think
it's
good,
that
it
takes
a
specific,
a
specific
string
because
there's
cases
where,
like
solution
files,
only
reliably
work
on
via
nvs,
if
they're
and
otherwise
you
end
up
with
vs
complaining
and
so
a
lot
of
editor
config
files
or
get
attributes.
Files
specifically
say
for
your
solution
file
check
out
a
crlf,
regardless
of
what
the
the
get
checkout
settings
are.
F
Otherwise,
there's
other
files
like
bash
files,
which
only
work
with
new
lines,
reliably,
never
knew
that
about
solution
files.
That
is
bizarre
yeah.
It
really
might
be
better
in
the
latest
solution
in
the
latest
versions,
but
I
remember
like
at
least
two
releases
ago.
It
was
bad
enough
that
we
we
started
adding
to
our
editor
config,
the
the
right
settings.
A
Yeah,
so
really
it
was
a
it's
more
of
a
question
of
right.
Now,
it's
it's!
Basically
a
flexible
fix
up
routine,
and
it's
do.
We
think
that
there's
value
in
doing
targeted,
search
and
replace,
but
I
guess
the
targeted
is
you
just
call
string,
not
replace
yourself
yeah.
I
only
want
to
replace
things
that
looked
like
unix
new
lines,
not
also
paragraph
separators,
or
line
separators
or
floating
carriage
returns
or
or
what
have
you.
A
Okay
yeah,
so
you
have
a
question
so
line
ending.
I
definitely
think
right
now,
with
the
parameter
name
line,
ending
that
it's
and
it's
a
little
ambiguous
if
that's
search
or
replace.
So
I
do
think
the
parameter
name
could
use.
D
D
K
D
A
All
the
time,
especially
with
complicated
things
like
I
pass,
environment.newline
the
and
then
that
makes
you
set
up
easier
for
if
you
want
to
add
the
char
one
at
the
same
time
or
not
that
like
because
it's
like
well,
where
do
we
put
the
defaults
and
what
do
we
feel
about
the
defaults
with
imbalanced
signatures
and
because,
if
we
were
gonna
have
the
char
one
I
was
gonna
suggest
we
just
add
the
zero
parameter
one
anyway.
A
L
Chart
yeah
one
one
more
question:
I'm
not
sure
if
you
already
discussed
this
or
not
yeah,
so
for
the
naming
about
normalized
line
ending,
should
it
should
we
name
it
replace
line
endings
instead,
the
word
normalizes
has
some
meaning
with
the
strings
in
general
about
like
no
normalization
details,
unicode
and
this
stuff.
So
I
want
to
avoid,
like
you
know,
we
will
think
about
it
like
it's
related
to
the
normalization
apis
or
something.
L
Yeah
one
one
last
question:
is
implementation
details
here,
so
this
we
should
take
care
about
big,
indian
and
little
indian
cases.
Right
I
mean
because
we
are
handling
crlf.
D
Stuff
yeah:
we
we
don't
actually
care
about
indiana's
here,
because
every
every
character
will
already
be
represented
in
the
machine's
native
md
in
this
format.
So
we
should
already
be
okay.
D
D
Because
the
the
idea
is
the
the
ndns
replacement
for
sorry,
the
ndns
conversion
should
take
place
at
the
time
where
you
read
this
from
the
wire
and
turn
it
into
a
string.
At
that
point,
once
the
string
is
materialized,
each
individual
element
must
be
in
the
machine's
native
representation.
D
D
Yes,
sorry,
one
second,
looking
at
the
wrong
api,
okay
memory,
extensions,
correct:
we
never
added
split
because
we
we
checked
it
in
and
then
reverted
it
before
it
shipped,
because
we
the
what
this
is
modeled
off
of,
is
the
enumerate
frames.
Api.
D
A
Yeah,
so
I
get
my
my
question
here,
which
is
a
little
bit
of
the
you
know,
you're
like
well.
This
wouldn't
be
good
for
protocol
work,
because
definitions
of
what
line
ending
you're
allowed
to
accept
is,
should
we
overload
these
enumerate
lines,
for
what
does
it
think
is
a
line
ending,
but
then,
at
that
point
it's
just
multi-split
or
single
split,
and
so
do
we
do
we
have
a
split
enumerator?
So
what
was
the
concern
with
split
enumerator
and
why
wouldn't
it
apply
here.
D
The
concern
with
split
enumerator
was
that
splitting
is
a
very
complicated
operation,
especially
once
you
start
wanting
to
apply
policy
to
how
the
splitting
takes
place.
For
example,
are
you?
Are
you
removing
empty
empty
segments?
Are
you
splitting
on
a
single
thing
versus
multiple
things
and
so
on?
If
you're
returning
a
single
split,
enumerator
type,
that
type
has
to
hold
every
single
one
of
the
options,
because
it's
a
restaurant
and
you
can't
have
like
you.
D
A
specialized
enumerator,
based
on
the
authors
that
are
passed
in
that
ends
up
making
split
very
expensive,
because
every
single
caller
has
to
pay
for
potentially
every
single
option
that
you
had
ever
passed
into.
Calcite
this,
because
it's
opinionated
does
not
suffer
that
same
problem,
because
it
does
one
thing
and
one
thing
only.
D
D
H
D
D
For
every
other
extension
method,
on
real
or
on
memory
extensions
we
have
both
read
only
spam
and
spam
overloads
fair
enough.
D
H
D
Parameter:
it's
what
you
want
to
replace
it
with?
No,
it's
called
replacement
text
yeah,
if
you,
if
you
want
to,
if
you
call
the
parameter
this
overload,
it
replaces
anything
that
it
found
with
environment
on
new
line
based
on
your
current
operating
system,
you
can
tell
it
to
replace
it
with
a
different
character
or
a
different
string.
A
D
A
A
D
A
Yeah,
it
makes
I
guess
it
makes
sense
that
they're
they're,
not
in
my
head,
they
were
both
being
they
were
both
weak
rappers
over
something
else.
That
was
doing
the
work.
But
if
they're
actually
the
thing
doing
the
work,
then
that
certainly
explains
why
they're
different
plus.
D
I
A
D
A
The
the
the
question
is:
can
can
somebody
call
the
rune
one
with
you
know
new
span,
rune
enumerator
and
then
give
it
the
the
span
to
start
running
off
this.
This
is
the
only
way
to
construct
it.
Okay,
using
this
extension
method.
Okay,
so
it
has
a
internal
or
something
constructor,
but
it's
also
a
struct,
so
it
has
a
default
constructor.
D
Yeah,
if
you,
if
you
default
it,
it's
basically
the
equivalent
of
having
done
memory,
extensions
dot,
enumerate
whatever
read-only
expanded
chart
on
empty.
It's
basically,
the
equivalent
like
move
next
will
return
false.
A
A
All
right,
oh,
I
should
like
let
people
see
what
my
notes.
D
And
then
I
can,
I
can
also
follow
up
with
with
eric
offline
and
see,
if
maybe
we
can
come
up
with
some
good
examples
where
a
charm
overlapping
makes
sense.
A
That
doesn't
seem
you
maybe
see
if
anybody
can
talk
about
this,
one
thread
pull
bound
handle,
allocate
unsafe
native
overlapped.
Four
two
five,
four
niner.
D
D
But
okay,
I
guess
I
guess
I
can
talk
to
this
one.
So
we
have.
We
have
apis
when
you're,
interacting
with
with
windows,
asynchronous
win32
methods,
they
those
methods,
tend
to
take
a
structure
called
a
an
lp
overlapped.
D
We
have
a
native
overlapped
structure
in.net,
which
is
basically
a
a
a
projection
of
the
windows
overlap
structure
in
managed
code.
The
typical
way
that
you
would
do
this
is
you
would
use
an
allocate
native
overlapped
method
in
order
to
generate
a
pointer
to
one
of
these
things.
However,
as
with
most
asynchronous
helper
apis,
they
do
things
like
capture
the
execution
contacts
which
means
that,
when
the
when
the
callback
eventually
gets
dispatched,
it
will
have
all
of
your
async
locals.
It
will
have
your
current
identity
and
so
on.
D
D
A
Fair
enough,
so
if
this
is
using
unsafe
in
the
thread
pool
way,
which
makes
sense
since
those
words
both
appear,
isn't
that
usually
used
as
a
prefix
and
not
a
so
it's
always
before
the
verb.
It's
unsafe.
A
I
hope
this
scenario
made
sense,
though.
Yes,
now
that
this
is
like,
I
see
that
that
there
is
an
allocate
native
overlapped
with
the
same
signature,
and
this
is
put
the
word
unsafe
to
mean
don't
capture
execution
context
and
now
the
I
think
the
only
thing
is.
Where
does
the
word
unsafe
go,
and
I
think
it's
generally.
A
D
Yeah,
normally
it
goes
in
front.
I
had
also
mentioned
as
part
of
this
issue
we
should
consider.
We
should
also
consider
making
a
similar
change
on
the
pre-allocated
overlap
class.
This
is
thread
tool
bound
handle
specifically
that
the
galler
talks
about
at
the
front
of
that
pre-allocated
overlap
is
a
very
similar
type,
and
I
think
it.
D
Pre-Allocated
overlap:
if
you
go
to
apis.net,
you
can
see
it
right
now.
It
has
a
constructor
which
takes
an
I
o
completion
callback
and
all
that
good
stuff.
We
can't
really
overload
a
constructor
to
say
unsafe.
So
what
I
had
proposed,
yeah
pre-allocated
overlap,
is
the
name
of
the
pipe.
D
So
what
I
had
proposed
we
do,
in
addition
here,
is
have
an
unsafe,
unsafe,
create
static,
factory
method
hanging
off
of
this.
That
basically
calls
a
constructor,
but
also
suppresses
the.
A
Instead
of
mixing
a
constructor
and
create,
wouldn't
it
make
sense
to
just
add
a
boolean
parameter
of
capture,
execution
context
or
skip
capture
execution
context,
we.
D
A
I
just
thought
never
mind
from.
K
D
Correct
so
you
could
you
could
imagine
that
the
object
is
tainted
or
poisoned
or
choose
your
adjective,
but
we
don't
want
to
stop
you
from
creating
such
an
object,
because
you
might
actually
have
valid
resources.
D
K
So,
for
instance-
and
this
is
what
I
was
noisely
typing-
the
chat-
sorry
for
not
being
muted
but
I'll
say
it
for
the
video
I
tried
using
the
safe
the
existing
version
of
this
api
and
kestrel
when
you're
first
moving
over
to
managed
sockets,
it's
a
lot
faster
than
managed
sockets.
K
Just
doing
that
you
can
get
faster
yet
by
running
your
own
thread
that
manages
its
own
iotp
loop
and
part
of
that
reason
is
because
we
no
longer
had
to
capture
the
execution
context,
so
I
do
think
there's
value
for
sure
yeah
it
can.
It
can
kind
of
propose.
D
Yeah,
this
can
kind
of
be
mimicked
today
by
using,
I
think,
execution
context
not
suppress,
suppress
flow
before
you
call
the
scene.
D
But
you're
probably
right,
maybe
but
it's
to
be
honest.
The
press
flow
is
a
little
unwieldy
and
there
are
times
where
it's
it's
really
not
good
to
call,
and
it
also
means
that,
as
you
unwind,
you
have
to
make
sure
you're
unbinding
properly,
which
means
you
have
to
consider
like
you
have
to
consider
accession
filters
and
blah
blah
while
you're
unwinding
it
it's
just
so
having
an
api
that
does
it
for
you.
D
And
as
I
commented
here
like,
I
think
it
would
be
good
to
do.
Pre-Allocated
overlap
at
the
same
time,
but
it
wasn't
part
of
the
initial
proposal.
So
if
it's
not
done,
I'm
not
gonna.
D
A
Have
strong
feelings,
it's
a
type
I've
never
even
heard
of
so
it
seems
a
little
already
off
in
the
weeds
and
I
can
get
behind
the
we
don't
do
the
bullying
anywhere
else
so
we'll
make
unsafe,
create
and
then
copy
the
constructor
signature.
A
K
A
K
K
A
It's
not
my
fault,
my
my
predecessors,
don't
know
how
to
spell.
A
D
I
am
looking
for
the
pre-allocated
overlap,
constructor
right
now,
and
I
did.
I
did
confirm
that
it
does
in
fact
capture
the
execution
context
which
is
unfortunate,
but
so
this
this
could
help
people
who
probably
should
be
nudged.
D
H
Okay,
so
with
the
trimming
effort,
we've
kind
of
ran
into
a
pattern
of
code
and
we're
trying
to
introduce
a
new
api
to
make
this
pattern
a
little
bit
more
trim
friendly.
I
guess-
and
so
the
the
example
of
the
pattern
is
you
take
in
you.
Take
in
some
object
that
you
want
to
get
the
object's
type
is
a
generic
type
and
you
want
to
call
either
a
method
or
a
property
on
it,
and
you
know
that
you
know
the
type
is
generic,
but
you
don't
know
what
the
generic
instantiation
is
going
to.
H
H
So
the
first
line
I'm
getting
task
of
open
generic
t,
I'm
getting
its
get
result
method
and
I'm
storing
that
statically
and
then,
when
I'm
running
my
code,
that's
taking
in
the
task,
I
can
call
this
new.
This
new
method
on
the
task
type
that
I
called
from
task.gettype
and
I
get
back
the
instantiated
task
of
te
method
info.
K
H
K
H
Correct,
because
if
you,
if
you
scroll
up
because
the
way
people
do
it
today,
is
they
call
object.gettype
to
get
the
actual
closed
generic
type?
The
actual
instantiation
of
what
this
thing
is,
so
this
would
actually
be
task
of
int
or
task
of
string
and
then
from
that
type
they
call
it
get
method,
some
string,
and
so,
like
you
can't
statically
verify,
which
type
get
result
is,
is
actually
going
to
come
from
right
because
you
called
object.gettype
and
it
could
be
any
any
type.
H
K
Method,
I
love
that,
like
I
feel
like
this,
should
have
already
existed.
The
name
is
really
long,
though.
H
D
In
an
ideal
world,
like
I'm,
I'm
wondering
if
we
can
just
make
if
you
have
an
open
generic
method
and
you
pass
the
a
closed
generic
instance
parameter
like.
I
wonder
if
we
could
just
make
that
work,
but
I
mean
you,
you
pass
it
to
the
invoke
method.
That
is,
but
there
might
be
good
reasons
that
we
can't
do
that
for
whatever
reason-
and
this
is
a
really
good
alternative,
I
think.
H
D
A
H
L
L
D
D
H
A
My
my
initial
reading
is,
but
the
generic
member
would
be
a
member
that
was
generic,
not
a
member
on
a
generic
like.
I
understand
that
that
is
a
different
scenario,
and
maybe
it
would
even
work,
but
you
would
actually
don't
want
to
match
generic
members.
You
want
to
match
members
off
of
a
generic
type
instantiation,
which
is
even
longer.
A
A
H
A
A
H
A
H
A
Because,
then,
because,
if
it
works
for
actual
generic
methods,
so
it
a
specified
generic
method,
which
I
guess
doesn't
make
sense.
You
wouldn't
have
that
on
a
type
info,
because
you'd
have
to
get
the
info
and
then
call
make
generic.
D
H
H
L
A
D
H
H
H
H
H
A
I
mean
that's
what
it
sounds
like
it's.
The
current,
even
with
the
get
from
generic
definition
was
going
to
do
so.
It
just
seems
it
doesn't
help.
You
understand
what
scenario
you
want
to
call
it
from,
but
the
one
on
member
info
doesn't
help
you
with
that
either.
So
it's
it's
exactly
the
same
level
of
like
yeah,
I'm
a
thing.
L
L
L
A
A
A
So
now
you
would
get
a
remember
the
version
of
the
member
instead
of
off
of
dictionary
of
comma.
You
would
get
it
off
of
dictionary.
Int,
comma
and
it'll
still
be
not
invokable,
but
you'll
get
a
thing.
It's
reflection,
it
exists.
You
could
find
it
it'd
be
the
same
as
calling
type
of
dictionary
of
int,
comma
dot
get
member
and
you
pass
it
enough
things
to
correctly
identify
the
member.
So
I
don't
think
it
needs
to
resolve
the
ambiguity
and
the
lack
of
invokability,
because
it's
it's.
This
is
very
clear
at
what
it
does.
A
L
D
J
D
Yeah,
so
that
a
lot
of
the
reflection
apis
for
things
like
get
method
will
say
well,
I
can't
find
a
method
with
that
name.
So
I'm
going
to
return
in
I
I
don't
know
if
this
is
a
special
case,
because
it's
saying
give
me
it's
saying
basically,
I
expect
this
member
to
be
on
this
type
like.
Please
give
me
the
matching
number
definition.
L
A
A
H
A
A
Never
called
try
get
value,
but
dictionary
events
to
long
did
so
only
leave
that
one
copy.
No
for
the
linker.
G
H
H
G
G
A
D
A
K
D
A
Cool
all
right,
add
public
key
methods
for
x509
certificates,
dot
public
key
48510.
This
is
me
so
on
on
x519
certificate.
2.
We
have
methods,
some
of
them
are
extension
methods
like
get
rsa
public
key.
We
also
have
this
property
hanging
off
certificate
called
public
key,
which
returns
an
instance
of
type
public
key,
which
is
a
way
to
describe
the
public
key.
But
if,
once
you
get
that
object,
you
can't
actually
get
back
to
key
material
without
writing
a
decoder
yourself.
A
It
turns
out.
We
basically
have
these
methods
as
internal
for
places
that
we
can
accept
a
public
key
and
then
work
with
it,
and
the
suggestion
is
just
make
them
public,
so
they
have
the
same
semantics
as
the
so
certificate.
Dot
get
rsa
public,
key
or
certificate.public
key
dot.
Get
rsa
public
key
will
give
a
semantically
equivalent
value.
D
Me
I'm
looking
at
the
internal
implementation
real
fast
and
it
it
looks
like
the
constructor
takes
an
asymmetric
algorithm.
So
would
you
not
just
expose
the
asymmetric
algorithm
and
have
the
caller
cast.
A
No
because
it
also,
we
can
also
create
it
from
bytes,
like
you,
can
make
a
public
key
of
asymmetric
algorithm,
but
you
can
also
just
give
it
the
this
is
the
encoded
representation.
Oh,
I
see
that
yeah.
It
takes
the
oid
and
everything
else.
Yeah.
A
F
G
K
A
F
Yeah,
so
there's
that
one
and
four
nine
three
nine
seven
they're,
basically
a
pair
but
they're,
both
basically
let's
take
what
we
already
have
on
vector
t
now
expose
it
on
the
on
the
intrinsic
vector
types.
That
way
we
can
also
write
generic
code
for
those
where,
where
it
where
it
exists,
so.
F
F
That
way,
when
you
are
targeting
both
arm
and
x86,
you
can
write
one
code
path
where
the
algorithm
is
the
same
and
only
drop
down
to
actual
hardware,
specific
intrinsics,
where,
where
you
have
those
platform,
specific
differences,
so
within
corelib,
this
would
allow
us
to
take
most
of
our
generic
code
paths
and
trim
them
down,
except
for
where
we
use
move
mask.
D
I
I
guess
apis
like
square
root,
would
fail
if,
given
a
non-floating
point,
t.
F
So
we
have
the
exact
same
behavior.
We
expose
on
vector
of
t
just
with
with
the
well-defined
vector
sizes.
D
Because
my
only
concern
would
be
what
policy
we're
putting
on
these
types
that
aren't
necessarily
intrinsic
policy.
H
A
F
F
F
Specifically,
the
commented
out
ones
are
ones
that
we
expose
as
static
methods
on
the
fixed
size
types,
because
it's
more
performant
and
we
should
never
have
done
them.
As
instance,
methods
on
vector
of
t
in
the
first.
F
D
I
mean
honestly,
this
makes
sense
to
me
in
large
part
like
I,
there
are
some
things
that
stand
out
to
me
strange
like.
Why
is
square
root
renamed?
F
F
For
these
cases,
we
prefer
the
consistent
naming
with
math,
etc.
D
And
tuples
returning
lower
before
upper
makes.
A
A
A
You're
right,
it's
it's
it's
numerix
shrug.
Does
anybody
have
anything
other
than
trug.
D
I
like
vector
64,
is
hardware
accelerated.
Will
that
return
false
on
x86.
F
Yes,
it
will
be
vector,
64
will
be
false.
On
x86
and
vector
256
will
be
false
on
arm
vector.
128
will
be
true
on
both
vector
256.
In
particular,
you
can
emulate
as
hardware
accelerated
but
that's
out
of
scope,
and
that
would
end
up
being
mostly
an
implementation
detail,
because
it's
not
hardware
accelerated
in
the
scenario
in
the
way
you
might
think
it
is
so
it
would.
It
was
strictly
return.
False.
D
So
that's
kind
of
interesting
because
normally
on
the
isas
is
hardware,
accelerated
means
this
isa
is
supported,
whereas
here
you're
saying
like
does
the
hardware
even
understand
this
as
a
native
data
type.
F
Can't
accelerate
a
vector
64
on
on
x86,
for
example,.
D
I
wonder
if
that
would
be.
Can
I
wonder
if
having
all
of
these
as
supported
apis
would
be
confusing,
though,
given
given
the
target
audience?
Maybe
that
would
just
be
a
dock
issue.
F
Yeah,
I
think
I
think
it
just
mirrors
exactly
what
we
do
for
vector
of
t,
and
so
I
think
it
will
be
understandable
to
people
in
the
same.
D
F
No,
I
don't
think
we
would.
I
we.
We
could
hardware
accelerate
it
like
that,
but
I
think
just
like
with
vector
256.
If
you
were
to
even
if
you
were
to
implement
in
terms
of
two
128-bit
ops,
you
would
not
say
it's
accelerated,
because
it's
it's.
It's
not
accelerated
in
the
fashion
that
we
typically
say
vector
of
t
is
accelerated
or
by.
F
Yeah,
so
those
ones
should
never
the
the
ones
that
return
long.
An
inch
should
never
have
been
defined.
In
the
first
place,
they
they
hurt
algorithmic
throughput
and
no
one
actually
uses
them.
Okay,
if
you,
if
you're
taking
in
double
and
float,
you
should
be
returning
double
and
flow.
A
F
Yeah
and
then
the
one
that
the
one
that
levi
brought
up
the
other
issue
52017
it's
basically
this
issue,
it's
an
extension
to
this
issue
issue,
which
is
support
native
int
and
unsigned
native
event.
It
exposes
like
12
new
methods.
F
We
already
do
that
on
vector
2
nowadays,
right,
yep
and
we'd
like
to
expose
that
for
for
the
general
types
as
well.
Now
that
one,
I
don't
mind
so
much
if
we
wait
until
next
review
period
to
go
over
just
because
there
are
two
linked
issues
with
it,
which
is
extending
x86
in
the
arm
sub
name
spaces
to
also
support
native
in.
F
Nope
I
can
make
forward
progress
with
just
this
then,
the
native
in
support
I
want
in
before
I
want
in
4.9
if
we
can,
but
it's
not
top-down
work.
So
it's
not
blocking.
D
Yeah
it
would,
since
we
did
the
work
for
vector
t
already
like
I.
I
would
personally
like
to
see
it
expanded
here,
so
I
I
I
will
help
push
for
that.
D
D
J
A
D
F
Yeah
in
particular,
this
will
unblock
that
change,
where
we've
got
a
couple
community
people
from
the
community
that
are
really
interested
in
changing
good
to
like
use,
vector,
128,
compare
it
we'll
just
be
able
to
use
operator
equals
now
and
then
likewise,
it
will
allow
us
to
normalize
a
bunch
of
our
own
logic
to
be
much
simpler.
Rather
than
having
like
two
to
four
completely
disparate
code
paths.
We
can
just
have
one
with
a
couple
branches
in
the
in
in
the
middle.
D
Yeah,
and
in
particular
I
know
that,
throughout
the
text
processing
logic
we
have
ssc2
and
arm
64
codepads,
and
the
only
thing
that
they
need
to
do
differently
is
how
they
read
the.
I
F
D
Yeah,
I
would
be,
I
would
be
willing
to
start
rewriting
some
of
our
internal
stuff
in
terms
of
these
apis.
Once
they
go
in
to
you
know,
make
our
own
logic
easier
and
kick
the
tires.
Yep.
A
All
right
so
there's
a
question
in
chad
about
some
creative
t
that
takes
a
t
array,
for
that
has
an
overload
for
the
number
of
elements
to
take.
Does
it
make
sense
to
have
an
overload
with
an
offset,
and
I
think
that
the
answer
is,
if
that's
not
something
we
already
had
on
vector,
then
it's
a
new
api
proposal.
So
it's
not
related
to
this
issue.
A
So
all
right
there
you
go
chat,
it's
already
it's
already
there.
I
missed
a
block
of
commented
things.
Oh
no,
I'm
back
up
at
your
yeah
you're
thinking.
A
Yep,
well
really
it's
just
so
the
the
email,
assuming
I
remember
to
hit
the
button
that
the
email
yeah
is
a
little
cleaner.
So
all
right,
as
my
very
oddly
sized
themes
window,
currently
shows
where
we've
lost
quorum
and
we're
over
time.
So
we
will
see
everyone
who
cares
to
join
us
again
at
tuesday
10
a.m.
I
assume
I
didn't
actually
look
at
my
calendar
have
a
good
weekend.
D
Yeah,
I
see
there's
only
one
review
scheduled
for
next
week.
We
we
might
need
to.
We
might
need
to
place
another
one.
There
is
also
a
four
day
weekend
coming
up
next
week
and
so
yeah.
F
D
F
J
A
All
right
in
chat
is
there
a
public
schedule
for
these
streams,
no
tuesday
at
10
a.m?
A
Redmond
time
is
the
only
one
that's
expected
in
a
given
week,
but
we've
been
trying
to
play
catch
up,
so
we've
been
throwing
some
in
ad
hoc,
which
is
why
I've
been
announcing
at
the
end
of
each
meeting
when
the
next
one
is
but
well
I'll,
leave
that
for
emo
if
he
wants
to
find
a
way
to
make
that
public,
especially
because
he's
not
here,
so
he
can't
say
no
all
right.