►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
Alrighty,
so
it
is
morning
again
and
we
are
looking
at
the
backlog
again
and
yeah.
We
have
not
a
lot
of
people
right
now
here,
but
we
have
enough
people
here
to
make
some
progress
and
we
started
with
some
things
that
get
they
will
get
tanner
very
excited.
Maybe.
B
C
Even
if
it's
community
pr.
B
Right,
there's
there's
just
we
we've
basically
locked
down
on
that
and
the
these
given
that,
given
that
there
there's
trivial
workarounds
for
them-
and
this
is
more
just
completing
the
api
surface-
they
wouldn't
be
qualifiers
for
5.0.
They
wouldn't
meet
the
bar.
B
Yep
they
just
provide
parity
with
the
existing
single
to
in
32
bits
and
double
two
and
32
bits,
and
then
the
reverse
in
32
bits
to
single
and
in
64
bits
double.
D
B
B
C
A
C
Why
would
we
add
half
if
we
don't
have
float?
Oh,
we
do.
We
do
it's
single
it's
under
s
instead
of
f
and
the
alphabet's
hard.
A
A
I
guess
they
didn't
take
the
api
reviews
too
seriously
when
they
did
it
into
all
one.
Oh
actually,
yeah,
never
mind
yeah.
It
is
what
it
is.
E
A
Actually,
there
was
a.
I
was
working
hard
on
that
one.
I
think
somebody
actually
pointed
me
to
a
public
download
and
I
I
went
through
significant
trouble
because
it
was
before
we
had
a
thing
called
references.
Someone
said
to
actually
physically
extract
the
thing,
and
then
it
wasn't
quite
a
journey,
but
like
I
was
like,
I
really
want
to
see
the
1.0
there.
A
Did
you
guys
know
that
at
some
point
we
had
daytime.parse
and
you
could
throw
in
the
string
brad's
wedding
and
it
would
actually
return
the
wedding
date
for
brad
abrams,
nice
yeah?
You
can
only
do
things
like
that.
A
Consider
adding
half
support
to
the
binary
primitives
class.
I
guess
that's
the
same
story
here.
A
B
So,
basically,
just
providing
parity
with
what
we've
got
for
single
and
double,
but
for
half
and
eric
currently
has
internal
equivalence
for
seabor.
It
would
basically
just
be
making
those
public
gotcha.
E
I
also
left
a
comment
near
the
bottom
of
this
issue,
saying
we
should
add
these
to
binary
reader
and
binarywriter
as
well.
A
Yeah
I
was
able
to
answer
like.
Are
there
any
like?
Should
we
batch
them
up?
Maybe?
But
I
guess
that's
hard
right,
because
it's
all
over
the
place
but
yeah
it
seems
like
when
it
comes
to
primitives,
there's,
probably
a
few
areas
that
we
need
to
look
at.
C
Yeah
I
mean
binary
primitives
the
things
on
it,
don't
follow
our
our
span
guidance,
but
making
the
new
things
look
like
the
other
things
on
that
same
type
is
probably
better
like
it
doesn't.
The
read:
half
little
indian
doesn't
tell
you
how
much
it
wrote
it's
up
to
you
to
know
that
half
is
two
bytes.
Thank
you.
B
The
issue
with
half
is
that
the
language
doesn't
consider
it
a
primitive.
Yet
so
you
have,
you
can
only
get
the
size
in
an
unsafe
context.
C
Well,
you
can
do
marshall.sizeof,
which
is
safe,
but
you
can't
use
the
the
size
of
keyword
and
let
that
be
a
const.
B
But
but
marshall
size
of
will
also
not
be
a
jit
time
constant
and
is
quite
a
bit
slower
than
unsaved
size
of
which
is
just
size
of,
but
without
needing
the
unsafe
keyword
right.
A
Yeah
I
mean
honestly
for
primitives,
I
don't
care
people
card-coded
to
two.
I
mean
like
these
things
will
never
change.
I
mean
if
the
code
is
correct.
It
will
be
correct
forever.
So
it's
fine.
If
the
code
is
not
correct.
Well,
then
they
will
find
out
quickly
that
what
they
wrote
is
not
really
legal.
Indeed,.
C
I
mean
we,
we
sort
of
in
the
in
the
book
in
the
explanation
it
sort
of
hand.
Wavely
justifies
that
we
were
comfortable
doing
it,
because
you
could
use
the
size
of
keyword
on
these
types
and
we
can't
for
half.
But.
C
C
B
Well,
it's
an
il
instruction
size
of
okay,
which
the
jit
will
treat
as
a
const,
but
would
she.
B
G
E
Because
it's
so
binary
reader
binary
writer
are
basically
a
way
to
do.
Serialization
of
sorts
of
primitives
you're
writing
primitives,
like
int
string
whatever
to
a
stream
or
reading
those
primitives
from
a
stream.
Binary
primitives
just
works
over
a
span
instead
of
a
stream,
but
it's
the
same
concept.
A
E
A
And
remind
me:
how
do
we
implement
the
virtual
by
default.
B
Well
and
half
can
also
be
implemented
as
using
the
u-short
implementation
and
then
reinterpret
casting
to
half.
E
Yep,
I
don't
think
we
would
actually
implement
it
that
way,
because
I
think
we'd
want
our
implementation
to
be
consistent
with
everything
else,
but
yeah.
That
would
be
a
valid
implementation.
A
E
I
mean
there.
I
guess
there's
always
stuff
like
we
implemented
half
dot
parse
right.
So
that's
that's
already.
There
utf-8
parser,
utf-8
writer,
maybe
but
they're
kind.
B
B
E
B
The
parse
methods
are
public
on
half,
but
we
don't
have
the
utf-8
equivalents
public.
Yet.
A
B
C
Just
hot
water
in
a
pillow
pad
sorry,
that's
a
trademark,
hot
water
and
a
scouring
pad.
A
A
Well,
I
actually
clipped
that
off
because
that
looks
ugly
yeah
kevin
is
saying:
there's
also
everything
on
system
convert.
B
C
Thing
yeah
convertible
doesn't
have
it's
just
from
type
and
two
types
so.
B
A
B
A
B
B
A
A
B
B
E
A
Yeah,
I
guess
yeah
what
happens
on
the
other
ones.
I
mean
it's
the
same
behavior
right.
If
I
call
two
day
time
and
I
pass
in
a
byte,
we
probably
throw
the
exception
as
well
right.
There
is
no
query
mechanism,
I
mean
so
that
still
would
work
right.
C
E
Yeah
the
the
other
thing
about
I
convertible,
is
if
we,
if
we
implement,
that,
we're
also
going
to
want
to
make
sure
that
things
like
data
set
data
table,
can
support
it,
sending
it
up
to
and
down
from
sql,
we
want
to
make
sure
xml
serializer
can
support
it,
and
so
on
like
were
it
was
any
of
that
tested
with
this
type.
H
B
A
C
Yeah
I
mean
we'd,
probably
you
can.
A
You
just
yeah
yeah
costs
are
not
fair
enough,
but
like.
E
Yeah
so,
but
by
the
way,
tanner
is
I,
I
know
we're
kind
of
getting
off
track
here,
but
is
is
serializing
this
an
instance
of
system
half
through
something
like
xml
serializer,
which
is
still
a
supported.
Serializer
like
is
that
an
interesting
scenario
that
people
might
want
to
do.
B
B
Of
the
term
like,
yes,
you
can
serialize
it,
and
you
may
want
to
serialize
it
because
you
may
want
to
store
it
in
xml
or
json
or
csv,
etc.
Just
because
that's
a
you
generally
want
to
serialize
primitive
values
like
this.
Okay.
C
Yeah,
if
I
feel
like
xml
serializer
uses
duct
typing
of,
if
you
have
a
two
string
and
a
parse,
then
you
just
work
because
it's
a
code
generator.
D
A
A
A
E
C
A
Yeah,
I
think
there
was
an
issue
with
linux,
in
particular
where
you
I
think
about
the
behavior,
is,
I
think
so
I
mean
so.
The
problem
goes
like
this
right
like
if
we
say
it's
a
no-op,
then
basically
setting
it
to
false
would
be
fine.
Setting
it
to
true
would
be
problematic,
in
which
case
maybe
we
should
not
have
the
attribute.
Maybe
we
should
just
have
an
analyzer
that
says:
well,
if
you
set
it
to
false,
it's
fine,
that's
still
cross-platform.
A
A
C
A
C
Sort
of
on
linux,
you
inherit
all
the
handles
and
then
because
you
call
fork
first
and
then
then,
when
you
call
exec
ve,
it
closes
all
open,
handles
and
dumps
all
your
executable
pages
and
then
starts
over.
So
I
I
don't
think
we
have
any
option
that
lets
it
pass
through.
C
The
exec
ve
is
very
complicated,
so
presumably
one
can
say
that
they
want
to
just
change
what
the
entry
point
is
and
start
running
from
the
entry
point
without
closing
any
handles.
But
what
in
the
world
state?
Would
your
process
be
in
so
so
I
don't
know
if
it
is,
if
it's
possible
to
do
or
not,
but
I
think
the
problem
with
having
this
thing
and
having
the
default
say
true,
is
that
it's
not
true
on
linux.
C
So
we
need
the
default
to
be
os
specific,
which
is
weird
because
we
would
want
if
we
could
make
it
work
on
linux.
We
don't
want
to
change
the
behavior
well,
but
that
is
kind
of
like.
C
No
I'm
saying,
but
if,
if
on
linux,
we
have
it
return,
return
true
by
default
and
the
setter
throws
it's
actually
lying
because
you're,
not
really,
you
can't
witness
the
handles
being
inherited.
E
E
Talking
about
sockets
that
was
already
changed
in
3-0
to
be
consistent
across
both
linux
and
windows.
C
Well,
it's
whether
or
not
the
handles
are
inherited
by
default
is
already
different,
and
I'm
saying
we
should
not
have
it
default
to
true.
We
should
have
it
default
to
the
correct
thing
for
the
platform
and
if
we're
not
comfortable
having
a
default
to
the
correct
thing
for
the
platform,
then
we
should
not
add
it.
C
A
C
C
C
Right
and
and
on
the
one
hand,
that
is
bad
because
you're
using
it
as
a
trulian
but
the
but
the
null
behavior
is,
I
don't
have
an
opinion,
and
so
it
is
it.
It
also
makes
sense
with
nullable
it's
not
just
being
a
quick
three-state
value.
C
B
If
someone
said
it
too
right,
but
we
might
also
need
to
do
more
investigation
and
stuff,
and
there
may
be
platforms
in
the
future
that
don't
support
it.
So
I
think
the
nullable's
right,
but
we
may
want
to
do
some
initial
investigation
for
before
this
is
implemented,
to
determine
the
right
behavior
on
unix.
B
It
just
covers
the
whatever
the
default
for
the
platform
is,
with
you
being
able
to
query
it.
A
B
A
E
This
isn't
I
o.
This
is
diagnostics
process
right.
A
Oh
sorry,
yeah
I
mean
I'd,
agree,
that's
io,
but
you
just
put
it
in
the
wrong
space.
What
is
that
one
time
see
here.
E
We're
we're
all
racing
to
find
it
adam
sitnik
and
eric
t.
A
B
A
B
Over
yeah
methods
do
cover
properties
and
structs;
they
just
apply
to
the
individual
or
properties
and
events.
It
just
applies
to
the
individual,
get
set
add
remove
rather
than
the
entire
thing.
If
we've
got
it
for
class
instruct,
I
would
think
property
and
event
event
would
be
fine
as
well
as
would
interface,
considering
we've
got
dimms
now.
B
A
D
B
Also
like
assembly
and
module,
but
those
are
probably
why
why
why
are
you
hiding
everything
from
your
assembly
from
the
stack
trace.
A
B
Class
and
struct
at
least
make
sense
because
that
covers,
for
example,
all
your
throw
helpers.
E
B
Okay
delegate
might
actually
make
sense
if
you
wanted
to
hide
the
invoke
method.
C
C
Yep,
I
I
guess,
but
that
seems
super
marginal.
E
C
A
B
A
It
is
kind
of
not
the
same
as
an
abstract
cluster,
because
if
you
are
applying
to
the
abstract
class,
it's
very
clear
that
it
applies
to
all
members
of
that
particular
type
with
interfaces.
You
could
argue
that
it
would
apply
to
all
interface
implementations
on
other
types
as
well,
which
wouldn't
be
the
case.
It
would
only
apply
to
the
dims
you
defined
on
the
type
which
is
not
the
same
thing.
C
C
A
All
right,
then,
so
one
thing
I
wanted
to
check
is
so
system
diagnostics.
What's
in
there
system
diagnostics,
do
we
have
anything
else
with
stack
traces
today?
I
don't
think
so.
Right,
where's,
our
like
stuff
with
like
hiding
from
unit
testing
and
is
that
in
is
that
in
system
diagnostics,
somewhere
else.
A
There
is
this
thing
of,
like
you,
know,
debugger
step
through,
there's,
don't
show
it,
you
know,
don't
use
it
when
you,
when
you
compute
code
coverage
where
these
attributes.
C
Step
through
is
in
system
diagnostics,
but
I
think
the
two
most
telling
things
are
one.
This
is
an
internal
type
that
someone
just
wants
to
change
internal
to
public
and
two,
the
stack
trace
class
that
says
that
lets
you
just
build
a
stack
trace
to
here.
Without
you
know,
throwing
an
exception
is
also
in
system
diagnostics.
A
E
A
A
E
C
As
an
attribute,
you
should
prescribe
the
implementation
of
the.
D
A
A
C
C
C
B
A
C
B
A
B
So
the
ieee
spec
defines
a
hexadecimal
format,
the
primary
benefit
of
which
is
that
the
value
parsed
is
always
exactly
representable,
so
you
don't
have
issues
like.
Oh,
I
typed
0.1
and
I
actually
got
0.1
lots
of
zeros
five.
Five.
Five,
the
hexadecimal
representation,
is
always
an
exact
representation
of
the
float
it's
defined
by
the
spec.
It's
supported
by
many
other
languages,
including
c
c
plus
plus,
I
believe,
russ
supports
it.
B
E
B
E
C
B
So
so
four,
so
so,
the
the
hex
format
for
float
is
slightly
different
from
integer
hex
format,
in
that
it
can
also
have
decimal
points
and
exponents.
E
B
C
E
C
Yeah,
so
int
would
see
this
as
a
allow
hex
specifier.
So
it's
going
to
be
in
hex
mode
it
it
I'll
either
throw
because
you
passed
a
lot
of
decimal
point
or
it
won't
and
then
it'll
do
the
other
things
that
it
would
do.
B
A
E
C
D
A
C
A
C
Like
I
don't
know
who
who
would
have
been
a
pm
and
one
oh
guthrie,.
B
Then
you
actually
get
the
literal
g100
back,
you
don't
where
you
might
want
to,
for
example,
have
100
digits
of
precision
which
is
valid
for
float
and
double,
which
there's
actually
a
separate
proposal
for
that.
E
A
You
check
for
single
as
well
while
you
edit.
C
Fair
enough,
then
otherwise
it
would
just
be
taking
things
that
are
throwing
and
making
them
not
throw
which.
C
G
C
Well,
I
wouldn't
expect
most
people
would
care
that,
assuming
that
the
x
specifier
printed
an
x,
which
is
what
I
had
expected,
I
assume
most
people
wouldn't
test
that
most
people
wouldn't
care,
but
the
one
person
who
cares
would
be
upset
that
we
didn't
document
the
breaking
change.
B
So
I
I
guess
one
remaining
question
is
given
that
allow
hexbus
fire
today
explicitly
calls
out
a
string
that
is
parsed
with
cannot
be
prefixed
with
0x
should
maybe
we
also
add
another
thing
called
allow
hex
prefix.
A
B
Well,
you
could
also
foresee
that
pars,
for
example,
doesn't
require
the
zero
x
for
the
float
literal,
because
it's
able
to
differentiate
based
on
the
fact
you
explicitly
passed
in
allow
hex
number.
E
F
C
Yeah
I
mean
like
we
could
add,
allow
hex,
prefix
and
then
plumb
that
through
everything
or
we
just
change
a
sentence
and
documentation.
A
I
mean
the
question
really
comes
down
to
the
other
side,
which
is
if
we,
if
we
don't
do
it
now,
I
don't
think
we
get
to
do
it
later,
because
if
we,
if
we
add
in
a
low
hex
prefix
later,
you
really
want
hex
flow
to
probably
have
that
value
set.
But
you
don't
want
to
change
the
definition
of
what
hex
float
is
today,
so
it
really,
I
think
it
comes
down
to
whether
we
ever
want
to
do
this.
B
I
think
having
the
allowance
of
a
hex
prefix
would
be
general
goodness,
as
it
would
also
allow
you
to
parse
a
hex
string,
an
integer
hex
string
without
requiring
you
to
first
check
for
zero
x
and
then
split
two.
E
H
B
Well,
we
could
say,
for
if
we
have
it,
we
could
say
for
float
if
it's
hex
number,
if
it's
hex
float
yeah,
then
because
allow
hex
specifier
is
really
just.
I
am
a
hex
number.
You
must
interpret
me
as
a
hex
number
yeah.
B
C
Right
but
the
the
other
allows
so
allow
exponent.
Well,
okay,
maybe
not
that
one
allow
currency
symbol,
allow
parentheses
allow
leading
sign.
These
are
all
things
that
are
allow
in
that
they're
not
required
right,
but
the
hex
specifier
one.
It
says
it's
allow
hex
specifier,
but
it
doesn't
allow
a
specifier
at
all
which
would
be
the
0x
prefix.
It
says
this
is
hex
right,
so
it
was
named
poorly.
C
E
E
B
It's
not
sniffing
at
all
the
the
allow
hex
specifier
means.
This
must
be
a
hex
number
which
then
you
just
have
either
I
allow
the
prefix
or
I
don't,
in
which
case
you
allow
3edp
minus
1,
or
you
require
0x
3edp
minus
one,
there's
no
sniffing
or
guessing
or
any
or
anything
else.
It's
allow
hex
specifier
means
this
must
be
a
hex
number
and
allow
hex.
Prefix
means
right.
C
B
A
C
Because
we
don't
have
the
the
thing
that
I'll
terribly
call
400
so
like
that's
where
the
next
flag
is
available.
But.
C
Sure
yeah
so
so.
A
B
E
C
So
yeah
I'm
just
like,
I
think
that
you
know
allow
hex
specifier
wasn't
allowed
and
we
all
agree
that
it's
not
an
allow.
It
was,
and
it's
terribly
named.
So
I'm
saying
if
if
we
think
that
the
behavior
that
we
are
going
to
do
for
int
is
the
hex
prefix
means
it's.
If
you
sped
the
flag,
then
it
must
be
part
of
the
string,
then
we
shouldn't
call
it
allow
and
if
it's
allowed,
if
it's
actually
optional,
then
we
should
call
it.
B
C
A
C
E
Some
better
standard
yeah,
so
so
concrete
example,
json2
comes
around
and
and
the
json2
spec
mandates
that
zero
x
is
present
on
hexadecimal
floats
and
the
naive
implementation
is
to
call
o
float.parse
hex
number
whatever
or
hex
float
like.
Does
that
now?
E
B
E
C
B
C
C
A
G
B
B
A
I
would,
I
would
say,
like
it
needs
to
be
reasonable
to
say:
hex.
Lord
is
a
completely
new
bit
by
default.
It
basically
just
says:
yes,
you
need
to
have
the
valid
ieee
standard
which
may
or
may
not
include
trailing
white
space
or
leading
white
space.
Assuming
it
doesn't.
Well,
then
the
user
would
just
say
hex
float
or
a
low
leading
wide
or
allow
trading
right
and
if
they
don't
specify
them
by
default,
it's
whatever
the
ite
standard
says.
A
B
C
Yeah
I
mean
we
can.
We
can
certainly
do
both
an
exact
thing
and
a
friendly
thing
and
we
could
add
the
a
flag.
So
a
new
bit.
That
is,
you,
know,
hex
or
you
know
I
triple
e
754
hex
float
and
then
we
add
hex
float
so
obviously
the
first
one
needs
a
better
name
then,
which
is
allow
leading
and
trailing
white
space
and
the
other
format
specifier.
B
C
A
B
Basically,
everything
here
that
isn't
hex
specifier.
A
So
then,
I
come
back
to
the
thing
that
tana
originally
said
like
do.
We
then
care
that
it's
exactly
spec
compliance,
because
it
seems
like
these
things
are
not
like
this
right.
These
things
are
here's
a
bunch
of
strings
that
use
a
bunch
of
configuration
that
allows
us
to
parse
the
the
spect
format,
but
we
will
parse
more
than
that
right,
because
we
also
a
low
white
space.
A
C
C
C
G
E
I
I
would
be
okay
with,
I
think,
tanner's
proposal
just
now,
if
you,
if
you
are
in
a
flag
that
says
oh
by
the
way,
this
is
optional
on
the
way
that
that
flag
would
be
interpreted
by
int
is
the
prefix
is
optional
and
the
way
that
it
would
be
interpreted
by
float
is
the
same.
The
prefix
is
optional,
yeah.
B
H
C
E
E
E
C
A
C
C
Because
yeah,
ideally,
it
would
just
need
to
call
through
the
is
it
going
to
force
the
allow
hex
specifier,
making
sure
that
we
have
like.
Essentially,
it
needs
a
spec,
because
it's
changing
very
deep
down
plumbing
and
not
just
an
api
proposal,
because
what
we
were
getting
bogged
down
on
was
details
yeah
not
shape,
so
it
needs
a
spec.
E
E
C
C
I
think
that
this
one
is
well
defined
enough,
as
it
will
support
the
the
strict
interpretation
of
ieee
754
2019
hex
format,.
B
It
has
to
do
with
float,
parsing
and
formatting
still,
which
one
is
it
30657
300
this
one
here.
B
So
for
this
proposal,
basically
today
the
format
specifier
limits
itself
to
a
precision
of
99.
B
for
float
and
double
the
exact
underlying
representable
value
can
be
more
than
99,
for
example,
with
float.
It
is
a
hundred
and
twelve
or
113,
and
for
double
it's
767
or
eight,
and
that's
the
number
of
significant
digits
in
the
longest
representable
or
in
the
in
the
exact
representation
of
the
underlying
value.
B
The
proposal
is
to
essentially
take
a
breaking
change
here
and
allow
us
to
now
specify
precisions
to
either
take
the
breaking
change
and
allow
us
to
specify
format
specifiers
with
a
precision
greater
than
99,
or
expose
new
overload.
That
explicitly
takes
the
precision,
along
with
a
care
format.
A
B
E
C
A
B
No
because
double
is
768
seven
and
if
we
ever
add
quad,
that's
eleven
thousand
digits.
B
Care
struct-
that's
not
al,
so
it
fits
exactly
in
in
one
int
is
likely
the
reason
sure.
F
C
Yeah
and
we
currently
cap
it
a
hundred,
so
why
would
we
need
to
go
any
bigger
yeah?
I
mean
I.
I
think
that
we
should
just
on
the
safe
side
flag.
This
is
a
breaking
change
and
really
that's
more
so
that
people,
if
they
start
straddling
the
this
the
I
mean
so
let's
do
lts
to
lts
the
three
one
to
six
thing.
It's
like
what
we're
really
letting
you
know
is
g100
won't
work
if
you
go
backwards,
yeah
and
so
breaking
change
that
won't
throw
on
an
old
thing.
It'll
just
produce
nonsense.
B
C
Right
21
was
in
air
quotes,
and
so
we
would
presumably
do
the
same
thing
for
like
so
we
wouldn't
need
the
new
api
for
half
because
it
doesn't
really
make
sense.
But
if
we
bump
the
parser
to,
however
many
digits,
we
want
to
bump
it
to.
We
would
do
that
with
a.
C
C
But
I
guess
it's
how
we
do
the
custom
formats
anyway,
I'll
just
say
what
I
was
going
to
say
and
we'll
see
if
anybody
thinks
it's
breaking,
if
you
had
a
format
that
you
expected
the
g10
to
print
followed
by
like
a
zero,
and
if
the
change
that
we
do
to
the
interpreter
now
picks
up
the
extra
trailing
information
and
doesn't
do
what
it
used
to
do.
So
if
it's,
if
we
never
have
a
format
that
that
would
have
been
misinterpreted,
that
produced
actually
rendering
the
number,
then
then
that's
fine.
B
Yeah-
and
I
don't
think
that's
the
case
as
if,
if
it's
over
99,
then
we
count
it
as
a
custom.
C
B
B
If
I
do
it
with,
basically
I'm
trying
it
with
various
combinations-
and
it
seems
like
only.
C
Fun
times,
yeah
so
definitely
warrants
a
breaking
change
label,
but
I
think
that
we
should
just
take
the
change
to
the
parser.
B
No,
you
likely
wouldn't
write
production
code.
This
is
you.
You
generally
use
this
when
you're
debugging
or
doing
other
diagnostic
work
to
determine
why?
What
the
ex?
What
the
actual
rounding
error
in
your
floating
point
code
is,
for
example,
why
does
0.1
plus
0.2
return?
Something
does
not
equal
0.3.
A
If
we
go
down
the
okay,
let's
just
change
the
format
specifier
then
you
know
I
mean
I
haven't
looked
recently
into
the
implementation,
but,
like
I
could
imagine
a
world
where
plumbing
this
thing
through
is
hard
for
things
like
you
know
the
christophe
type,
where
we
can
only
express
up
to
a
bite-sized
number
right
and
then
is
it
really
worth
it
if
basically,
it's
just
for
temporary
stuff
that
germany
just
wants
to
quickly
print
to
the
console,
because
yeah
in
that
case,
calling
to
string
with,
like
you
know,
precision
of
like
500
seems
reasonable
right.
A
Like
to
me,
the
format
string
really
is
valuable,
because
if
you,
if
you
localize
you
can
you
can
externalize
it
it's
in
it's
in
a
centralized
spot
where
having
a
separate
overload
is
a
pain
in
the
ass
now
right.
But
if
it's
literally
just
for
debugging
purposes,
then
I
think
it
overload
is
totally
reasonable
for
that.
B
C
B
C
The
number
1.1
and
if
I
print
it
with
g100,
it
writes
the
number
g10
or
writes
g101
and
so
g107
is
then
g117
is
the
string
it
prints
and
every
other
string.
I
try
now.
It
just
changes
the
zero
in
the
middle
to
a
one.
C
B
C
C
Yes,
the
zero.
It
picks
up
as
printed
with
the
like
print,
the
zero
fill
so
21.1,
g407
print,
says
g4
and
then
21
and
then
seven
because
it
saw
it
as
a
pre
custom,
prefix
of
g4
and
a
custom
suffix
of
seven
with
the
format
specifier
of
zero.
C
C
C
B
Yeah
par
parse
will
already
consider
up
to
the
maximum
number
of
digits,
plus
a
rounding
digit
such
that
it
works
as
if
to
infinite
precision.
B
Part
parsing
works
as
if
to
infinite
precision,
which,
in
practice
is
it
has
to
consider
up
to
769
digits,
which
is
the
longest
possible
format,
string
plus,
plus
a
rounding
digit,
plus
the
null
termination
character.
B
Yeah,
no,
our
parsing
is
already
doing
that.
That
was
part
of
the
3.0
work
that
where
I
broke
bang
and
other
things.
C
But
he
broke
them
in
the
right
way
yeah.
So
I
think
this
is
all
we
need
and
we're
okay
with
it,
because
it's
for
complicated
debugging
and
not
mainline
scenarios.
A
D
E
A
C
This
okay,
so
if
this
was
any
type
other
than
ross
char,
I
would
say
it
really
needs
to
indicate
how
much
data
it
read.
I
don't
know
how
we
feel
about
that.
E
C
A
C
B
G
G
C
That
you
should
use
be
able
to
use
this
try
parse
as
read
the
stuff
from
the
beginning
and
then
tell
me
what's
after
it
then
right.
It
consumes
the
whole
thing,
I'm
looking
at
the
implementation.
Okay.
So
if
it's
consumed
the
whole
thing,
then
it
is
reporting
how
much
was
consumed
to
the
person
which
is
length.
A
C
A
E
Yeah
there
there
might
be
some
white
space
handling
here,
I'm
I'm
having
a
little
bit
of
difficulty
following
the
code,
but
it
looks
like
it
consumes
everything.
C
Okay,
I
mean
the
string
when
already
was
doing
something,
and
this
is
going
to
do
the
same
thing
as
the
string
one
and
so
yeah.
So
it's
it's
fine,
I'm
just
keeping
the
general
notion
in
people's
heads
of
when
we're,
especially
if
we
support
partial
reading,
then
we
should
be
reporting
what
the
partial
read
was.
E
A
E
A
A
H
H
E
Oh
and
why
why
they
weren't
added
in
the
first
place,
yeah,
because
if
say
that,
I'm
say
that
I'm
inside
of
a
the
jason
serializer,
for
instance,
I
am
generic
over
t,
and
maybe
I
know
that
my
t
is
a
struct,
because
I
need
a
different
implementation
for
struct
versus
class.
But
I
myself
am
not
constrained
to
enum
the
only
way.
The
only
reason
I
even
know
it's
an
enum
is
because
typeoft.enum
returned.
True.
C
Why
didn't
the
language
have
them?
My
understanding
is
the
runtime
said
they
weren't
going
to
be
able
to
deliver
on
the
enum
constraint
feature
before
the
2o
release,
so
the
language
team
took
it
out
of
the
2o
language.
Then
the
runtime
team
delivered
on
it
and
then
the
language
team
took
10
years
to
add
support
for
it,
and
then
now
we
have
the
10
years
of
delta
in
the
middle,
where
you're
in
the
state
that
leave
I
mentioned.
E
A
No,
I
mean
like
yeah.
I
was
curious.
Why
we
didn't
I
mean
originally,
I
thought
from
mads
that
they
just
didn't.
Add
it
to
the
language
because
they
didn't
feel
like
it
was
super
use
super
useful
and
I
thought
that's
kind
of
the
problem,
because
then
I
mean
don't
do
it
for
10
years
now
you
have
the
viral
problem.
They
can.
You
cannot
realistically
add
it
without
breaking
everybody
right.
E
E
A
E
A
C
Interesting
because
because
the
runtime
got
it,
they
added
support
for
it
in
the
il
like
the
bit.
Was
there
and
you
could
you
could
make
the
complex
you
could
make
it
where
the
runtime
understood
it.
The
language
had
some
behavior
in
that
state.
You
just
couldn't
declare
new
methods
that
that
had
that
behavior.
A
C
E
A
A
Seen
this
type
before
well,
it's
fairly
recent!
It's
we
added
it
to
speed
up.
I
think
predominantly
ms
build
it's
basically
a
faster
enumeration
api
with.
D
A
C
Basically
yeah,
but
it's
a
delegate
that
returns
an
answer,
usually
because
events
aside
from
the
occasional
state
where
they
have
like
a
cancel
property
on
their
event,
events
are
usually
like,
hey
fyi
and
I'm
there's
nothing
you
can
do
that
will
make
me
do
anything
different
now.
A
A
A
Realistically,
the
caller
only
ever
needs
to
subscribe
and
unsubscribe,
and
I
mean
setting
a
delegate
is
meaningless
because
realistically
all
delegates
and
net
are
multicast
anyway.
So
the
argument
that
you
could
have
multiple
subscribers
still
exist
right
because
anybody
could
still
subscribe
with
plus
equals.
A
I
would
just
argue
that
in
this
case
we
already
went
down
the
the
pattern
of
you
know:
nested
nested
type
for
the
predicate
sorry
nested
type
for
the
for
the
delegate
for
whatever
reason
and
properties
right.
So
I
would
keep
doing
this.
But
as
a
general
argument,
I
I
would
probably
have
said
we
should
have
probably
made
it
an
event.
C
Right
well
again,
I
can
understand
the
current
ones,
because
they're
asking
it's
letting
you
know:
hey
the
given
the
state
of
whatever
this
file
system
entry
is
answer,
the
true
false
question
of
whatever
find
means
and.
C
I'm
giving
you
a
thing,
and
I
need
you
to
provide
me
the
answer,
but
the
I'm
done
now.
There's
no
answer,
so
it
really
seems
much
more
like
a
broadcast
notification.
Therefore
it
should
be
an
event
now,
if
you
think
it's
weird,
that
we
have
two
setable
delegate
properties
in
one
event,
then
sure,
but
it
doesn't
seem
too
weird
to
me.
A
Yeah,
I
would
not
mix
it.
I
mean
to
me,
like,
I
think,
yeah.
I
think
we
should
bother
with
this
larger
discussion
on
events
at
some
point,
because
we
talked
about
this
before
how
events
don't
really
work
in
our
world
anymore.
But
I
think
this
is
more
to
do
with
the
fact
how
delegates
are
designed
internet
like
multicast,
doesn't
make
sense
when
you
want
to
get
answers
anyway.
E
E
C
D
E
C
G
A
A
A
A
C
They
gave
to
the
should
recurse
yeah,
like
essentially
should
recurse
is
your
begin
directory,
and
now
they
want
an
end
directory
and
you
would
just
leave
that
saved
as
a
local
that,
yes,
so
it's
gonna
consume
slightly
more
stack.
Who
cares.
C
Right
so
so,
if
you're
walking,
c
colon,
backslash
users
yep
and
it
sees
public
and
it
calls
should
recurse
and
gives
you
the
durant
for
public
yep
and
now
you
know
if
you
return
true,
all
your
entries
are
now
inside
users,
public
and
what
they
want
to
know
is
before
they
get.
The
next
call
to
should
recurse,
because
they
could
have
popped
a
directory
now
they're
looking
at
files
in
that
directory,
I
don't
know
the
order
that
it
walks
things,
I'm
just
asserting.
C
They
want
to
know
hey,
I'm
done
now
with
users
public
and
I'm
going
like
I'm
popping
back
up
to
users
and
and
then
then
they'll
get
the
next
should
recurse
into
users,
emo
and
and
then
they
want
the
I'm
done
with
emo
and
because
we
all
want
to
be
done
with
emo.
But.
F
Now
we
love
you,
I
feel
I
feel
the
love
through
the
to
the
stream.
C
So
this
is,
this
is
really
they
already
have
like.
The
should.
Recurse
functionally
is
a
on
on
enumerating
directory,
and
they
now
want
on
enumerated
directory.
A
B
C
E
Gives
you
the
entry
for
the
directory?
I
don't
know
what
continue
on
error
predicate
would
take
like.
I
don't
know
what
that
error
code
refers
to.
A
A
E
E
C
Each
result
is
only
an
h
result
when
it's
sch
exception
or
win32
exception.
Otherwise,
it's
whatever
number
somebody
felt
like
putting
here
or.
C
G
C
C
C
A
E
E
C
Right
but
because
yeah,
the
the
container,
presumably
your
your
on
error
is
going
to
fire.
If
you,
if
you've,
registered
everything
and
should
recurse
said
it
got
called,
you
returned
true,
because
you
already
stated
the
directory
and
now
it
calls
the
whatever
the
enumerate
for
that
node
is,
and
it
gets
back
an
error,
and
now
it's
like
hey,
I'm
in
users,
public
and
and
I
got
error
access
denied.
What
should
I
do?
C
Ideally,
it
would
tell
you
what
thing
it
was
trying
to
do,
including
the
empty
span
for
I
was
or
not,
for
I
was
trying
to
like
access
the
directory
list,
but
yeah,
because
this
would
be
the
thing
of
like
explorer
popping
the
dialogue
of
hey,
I'm
trying
to
copy
this
file
now
and
I
got
an
access
denied.
Do
you
want
me
to
abort
or
skip
this
file
or
try
again
yeah
it
just
can't
express,
try
again.
C
C
E
C
C
G
C
G
G
A
G
C
Because
this,
because
yeah
I
mean
false,
presumably
would
then
mean
that
the
thing
throws
it
which,
at
which
point
it
would
gain
the
call
stack,
but
it
meant
that
every
time
you
get
a
little
error
where
it
went
through
all
of
this
work
to
be
reducing
the
amount
of
data
allocation,
it
does
every
time
it
sees
an
error.
It
creates
the
exception
to
ask
you:
should
I
throw
this
and
so
giving
it
from
the?
E
A
C
C
A
E
No,
so
we
would
give
you
a
ref
error
entry
and
the
ref
error
and
the
error
entry
struct
contains
references
back
to
the
file
system,
entry,
the
child.
It
was
trying
to
enumerate
and
the
error
code
and
in
the
future.
If
we
want
to
more
properties,
it
becomes
our
context,
object.
A
C
C
G
C
Yeah,
it
might
be
carlos
and
eric
t.
E
Yeah
and
jeremy
is
still
jeremy.
K
is
still
giving
feedback
as
owner
emeritus.
E
G
C
That's
that's
my
understanding
and
it's
the
same
as
everybody
who
has
a
catch.
I
o
exception
and
then
looks
at
the
h
result
code
because
I
I
know
that
there
was
an
attempt,
like
we
do
a
little
bit
of
mapping
of
now
like
there's
an
air,
no
for
no
memory
and
we
turn
that
into
a
out
of
memory
exception.
There's
a
air
no
for
access
denied
and
we
turn
that
into
an
access
denied
exception,
while
still
setting
whatever
the
data
and
then
every
other.
C
E
C
No,
I
think,
creating
the
the
context
struct
so
that
we
don't
need
to
change
the
signature.
The
delegate,
I
think
that's
I
mean
that's
basically,
the
event
pattern
already
right
is
use
a
use,
a
custom
type,
because
you
can't
change
the.
E
C
A
So
with
the
eight
issues
today,
so
that's
good
we're
over
time.
Now
I
suggest
we
ended
and
then
next
week
we
may
even
do
more.