►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
Insert
witty
catchphrase
here
welcome
to
another
overflow
session
of
api
review,
where
we
still
have
a
whole
lot
of
red
emo
thinks
today
we
might
get
to
non-red
items.
I
think
emo's
an
optimist
yeah
all
right.
So,
despite
having
an
order
here,
we've
already
had
some
need
to
skip,
so
we
will
start
with
five
one.
Four,
eight
seven
add
dynamically
accessed
member
types,
dot
interfaces
enum
value:
vtech.
Are
you
with
us.
B
The
trimming
tools
do
remove
interfaces
if
they
don't
see
the
use
and
so
that
api
needs
to
be
marked
as
problematic
and
for
all
the
other
ones.
We
added
a
new
value
into
this
place,
which
basically
tells
the
trimming
tool
hey.
I
need
you
to
keep
all
the
methods
because
somebody's
asking
for
all
the
methods
we.
B
There
is
a
value
which
already
works,
which
is
the
all
value
which
will
include
all
interfaces
already,
but
it's
in
a
lot
of
cases.
It's
an
overkill
because
it
preserves
the
entire
type
and
like
recursively,
preserves
interfaces
and
st
types
and
like
all
bunch
of
stuff,
and
so
it
would
be
way
better
to
have
a
more
precise
annotation
interfaces
right.
A
B
D
C
B
B
A
B
D
B
Similar
binding
like
for
it
and
reflection
because
interfaces
are
not
considered
members
the
to
get
interfaces.
Api
is
basically
like
orthogonal
thing
to
all
the
other
ones
and
that's
why
we
missed
it
as
well.
D
A
Okay,
so
I
just
yeah,
if
it's
not
that's
that
it's
keeping
the
interfaces
and
that
I
kept
interfaces
always
kept
or
preserved
for
the
type
declarations
it
feels
like
it
to
me.
It
feels
like
it
would
probably
be
useful
if
it
was
more
clear
that
what
it's
keeping
is
it's
not
the
interface
implementations.
A
I
guess,
but
I
don't
have
super
strong
feelings.
Just
I
assume
this
meant
don't
erase
the
interface
type
declaration
itself,
not
don't
erase
the
fact
that
a
type
implemented,
the
interface.
D
B
Currently,
we
don't
trim
attributes.
I
I
see.
Okay,
like
we
tried,
like
the
code
base,
actually
has
a
notion
of
trimming
attributes,
but
it's
very
problematic
mainly
because
most
of
the
patterns
which
use
the
attributes
ask
for
database
by
name,
and
so
it
has
this
problem.
Just
like
the
interface
is
here,
but
it's
bigger,
because
it's
well
in
a
lot
of
places,
it's
basically
impossible
to
guess
what
the
type
is.
B
A
Yep
yeah,
all
that
I
was
jotting
down,
was
that
we
talked
about
the
name
and
couldn't
come
up
with
a
better
one.
E
F
D
Yeah,
so
basically
we
have
this
feature
for
a
while.
Now,
since
I
think
don't
record
three,
I
believe
another
reference
times
in
c
sharp
right
way.
You
can
put
question
marks
on
reference
types
to
indicate
that
some
things
can
be
now.
D
Of
course,
the
implication
is
also
when
you
know
any
maneuverability,
and
you
omit
the
question
mark
that
no
marks
listings
is
non-nullable.
So
basically,
you
have
three
states
of
reference
types.
Basically,
the
old
state
which
is
unknown
or
oblivious,
where
we
don't
know
whether
it's
not
null
or
no,
then
we
have
non-null,
and
then
there
is,
you
know,
maybe
now
right
and
so
the
at
compile
time
it's
all
exposed
there
wasn't
a
compiler
apis,
actually
expose
that
information.
D
So
if
you're
inside
of
a
method
body,
you
can
ask
you
know
at
this
particular
point:
do
you
know
whether
this
expression
is
nullable
or
not,
but
we
don't
really
have
the
corresponding
thing
in
reflection
right
and
so
the
scenario
that
we
talked
about
was
nbc
or
ef,
where
you
want
to,
for
example,
have
an
entity-
and
you
say:
hey:
I
have
a
customer,
the
customer,
you
know,
has
you
know,
first
name
last
name
middle
name
and
when
I
then
create
the
table
out
of
this
customer
object,
I
would
like
to
somehow
convey
to
the
system
that
middle
name,
for
example,
can
be
ineligible
right
and
the
the
way
it
used
to
be
done.
D
Is
you
put
some
attribute
on
this
on
this
property
that
say?
Oh,
this
could
be
null
and
then
the
ef
you
know
tool
that
generates
the
table.
Declaration
basically
does
that,
but
now
with
reference
types,
it
would
make
a
lot
more
sense
for
the
developer,
to
just
say,
hey
in
my
c-sharp
code.
The
way
I
indicate
whether
the
property
is
another
bullet,
but
putting
a
question
mark
behind
it.
So
it
would
make
sense
for
ef
to
actually
you
know,
handle
that
as
well.
D
Unfortunately,
that
would
not
mean
that
the
whoever
writes
the
code
for
ef
that
does
that
they
have
to
somehow
crack
open.
The
metadata
understand
the
attribute
encoding
that
the
compiler
chose
and
and
determine
whether
this
property
is
valuable
or
not.
That
is
not
as
simple
as
you
might
think
because
of
the
way
they
actually
are
encoded,
and
so
the
proposal
here
is
to
give
a
first-class
inflection
api
that
allows
people
to
ask
that
question.
D
Had
was
baked
into
the
reflection
apis
themselves,
so
there
were
virtual
methods
on
property
and
from
others
that
would
give
you
the
nullability
state
and
people
didn't
like
that,
and
the
other
thing
that
people
didn't
like
was
it
would
only
give
you
access
to
the
top
level
information.
It
wouldn't
be
able
to
tell
you,
for
example,
if
you
have
a
binomial
of
string
question
mark
that
the
element
type
there
is
another
ball,
and
so
the
design
that
I
know
sketch
here
basically
gives
us.
First
of
all,
it's
devoid
from
the
reflection
apis.
D
You
just
have
a
you
know,
new
top-level
concept,
where
you
can
use
it
to
actually
ask
valuability
information,
but
it
will
also
work
for
top
level
as
well
as
any
other
nested
generics
right.
So,
for
example,
nullability
info
gives
you
basically
the
state
which
is
you
know.
I
know
not
now
maybe
now,
but
you
can
also
now
say.
D
Well,
you
know
if
you
have
an
innumerable
of
string
question
mark,
for
example,
the
generic
type
arguments
now
would
be,
for
example,
string
question
mark
in
this
case
right,
so
you
can
actually
get
the
the
nested
annotations
as
well
and
as
we
discussed
this
with
jan
one
of
the
concerns
was
well.
We
probably
want
to
do
some
caching
here,
because
the
way
the
attributes
work
is
that
there
is
this
vulnerable
context
that
the
compiler
applies
at
the
type
level
or
member
level
to
indicate
defaults
to
to
basically
make
it.
D
You
know
more
compact,
and
so
we
want
to
avoid
repetitive
walks.
The
you
know,
through
the
reflection
apis,
to
find
out
what
the
context
is,
but
as
soon
as
you
add
caching,
now
you
have
this
problem
of
like
okay.
How
long
is
the
cache
valid?
Is
it
across
all
processes,
or
you
know,
across
all
threads
or
whatever?
D
And
so
the
easiest
way
to
do
it
was
to
say
well,
we
have
another
context,
object
that
the
user
creates
and
that's
basically,
the
level
at
which
the
caching
is
happening,
and
when
you
then
ask
this
context,
object
and
that
thing
can
cache.
D
We
can
decide
to
make
it
thread,
save
we
can
decide
to
not
make
it
threat
safe.
You
know,
probably
we
should
start
with
not
making
it
threaten
as
a
as
a
starting
point
and
then
just
say:
yep
you,
you
know,
this
is
the
thing
that
does
the
caching
and
when
you
drop
the
contacts
on
the
floor,
you
know
you
know
the
cash
also
disappears,
and
so
that's
kind
of
the
the
proposal.
F
I
have
a
high-level
question
email
if
now
is
a
good
time
yeah,
so
I
there's
a
slippery
slope
when
it
comes
to
nullability
with
all
of
the
other
nullability
attributes.
You
know.
F
D
Yes,
so
like
what
I
build
in
the
prototype
is
kind
of,
I
only
use
my
little
context.
Malleable
attribute
themselves,
so
all
the
other
custom
ones
that
we
have
the
expectation
as
a
caller
would
have
to
look
at
the
custom
attributes
themselves
and
make
decisions
based
on
that
because,
as
you
said,
the
policy
gets
way
more
nuanced
now
right.
So
the
api
really
doesn't
have
a
way
to
automatically
somehow
convey
that
yeah.
When
you
return
this,
it
may
be
null
when
you
take
it.
It's
not
or
something
like
that.
D
So
there's
a
lot
of
nuance
where
you
just
have
to
understand
the
attribute
in
order
to
understand
what
what
what
the
flow
is
right-
and
so
I
think,
that's
probably
acceptable,
because
I
think
most
of
the
time,
these
things
are
more
important
when
you
actually
think
about
code
flow.
I
don't
think
they're
necessarily
important
when
you
think
about
it
from
a
from
a
model
perspective
right,
because
I
think
even
methods
are
probably
not
the
most
interesting
thing
that
the
callers
would
like
to
care
about.
D
D
F
Yeah
I
mean
the
problem
there
when
it
comes
to
something
like
a
property.
Is
you
can
have
a
property,
that's
annotated
as
nullable,
but
you
know
either
the
setter
or
the
getter
could
have
an
allow
null
or
disallow
no
on
it,
and
vice
versa,
property
that
is
non-nullable,
but.
D
I
mean
we
could
I
mean
we
can
probably
make
that
possible
by
just
giving
you
basically
in
and
out
as
separate
values,
and
then
you
could
do
some
smart
parsing,
but,
as
you
said,
the
problem
is
that
gets
very
quickly,
very
slippery
and
also
very
complicated
now,
because
it
doesn't
really
work.
For
I
mean
I
can
kind
of
see
those
works
of
properties
in
fields.
It
gets
a
bit
more
nuanced.
When
we
talk
about
method
parameters
now,.
F
F
G
Go
ahead,
yeah
I
I
was
going
to
say,
I
think
the
primary
scenario
for
this
is
for
things
like
nbc
model,
binding,
for
instance,
where
they
they
want
to
see
if
a
property
is
explicitly
marked
as
non-nullable
and
to
disallow
binding
null
to
it.
If
are
you
suggesting
that
that
basic
scenario
can't
really
take
place
properly
without
additional
work
in
the
caller,
above
and
beyond
what
this
api
is
providing?
G
F
So
I
can,
I
can
have
a
property
and
we
have
plenty
of
these.
That
say
you
know,
guarantee
they
won't
return
null
but
allow
null
to
be
set,
or
vice
versa,
allow
null
to
be
returned
but
throw
if
you
try
and
set
them
to
know
and
that's
modeled
as
the.
If
you
know,
if
it's,
if
it's
it
will
never
return
null,
but
it
allows
null.
Then
it's.
F
F
Return
type
annotated
with
an
allow
null
attribute
or
if
it
can
return
null,
but
it
will
throw
if
you
try
in
sentinel.
Typically
that's
modeled
as
a
nullable
return
type
with
a
disallowed
null
attribute,
and
so
that
does
impact
those
kinds
of
binding
scenarios,
and
we
definitely
have
examples
of
both
of
those
throughout
the
framework.
F
Now
you
could
argue
that
some
of
those
are
legacy,
but
at
least
the
like,
you
know,
be
permissive
in
what
you
accept
and
you
know,
concise
and
what
you
return.
There
are
a
lot
of
properties
that
make
sense
where
someone's
going
to
normalize
a
null
coming
in
to
say
an
empty
string
and
then
we'll
guarantee
that
they
never
return
null
because
they're
always
going
to
return
an
empty
stream.
F
D
So,
are
you
asking
whether
you
can
inspect
the
generic
constraints
on
a
generic
parameter?
So
can
you
basically
ask
the
generic
parameter
or
are
you
saying
the
genetic.
F
A
Because
I
mean
we,
I
think
that,
with
what's
on
the
screen,
we
could
solve
the
current
property
potential
pit
of
failure
by
taking
state
and
expanding
it
to
read
state
and
write,
state
or
get
and
set
or
whatever
so
then
properties
can
express.
You
know
they
can
express
their
mismatch
behavior
for
a
field.
It
would
always
be
the
same.
F
F
For
example,
if
you
had
a
field
that
you
allowed
to
be
defaulted
to
null
because
it
was
part
of
say
a
struct,
but
you
didn't
want
to
allow
anyone
to
set
it
to
know,
then
you
could
have
it
be
a
you
know
a
either
a
non-nullable
with
a
kind
of
maybe
null
attribute
on
it
or
a
nullable
type.
With
a
this.
A
Loner,
I
guess
that's
just
the
state
where
the
null
ability
is
lying
right.
The
you
said
this
is
an
this
is
a
non-null
string,
but
it's
a
struct
so
yeah
it's
null
and
that
you're
just
promising
that
before
any
of
your
callers
get
around
to
caring.
That
you'll
have
said
it.
F
Yeah
sorry,
my
did
something
strange
for
a
minute,
but
I
think,
based
on
the
last
three
words
you
said,
I
think
you're,
probably
right.
Okay,.
A
A
And
I
mean
I
guess
we
could,
for
those
this
api
could
say:
hey
technically
you're
a
struct.
This
technically
could
be
null,
so
the
read
state
is
maybe
null,
but
also
the
compiler
won't
care.
So
maybe
you
shouldn't
either
but
yeah
so
going
back
to
not
know.
When
and
friends,
I
showed
that
I'd
already
started,
taking
a
note
on
that
of,
depending
on
what
the
purpose
of
this
is
like.
A
If
it's
to
help
you
know
your
your
api
or
apisof.net
signature
printing
should
not
know
when,
and
other
things
be
a
fourth
nullable
state
of
I
I
joked
it's
complicated
like.
Is
it
worth
expressing
that
that
there's
some
conditional
or
state
driven
or
something
nullability,
which
is
I
mean
we
can
certainly
say
it's,
maybe
null,
because
there
are
cases
where
null
could
happen,
but
I
feel
that
you're
trying
to
say
maybe
null
is.
This
is
known
to
like
that.
D
Well,
I
think
I
would
I
would
scope
the
api
to
return
you,
the
the
the
information
of
the
type
right,
regardless
of
conditional
right,
because
the
thing
is
you
know
if
you
look
up
alone
now,
maybe
now
there
are
still
static
statements
about
you
know:
it's
just
the
direction
right.
Data
flowing
versus
data
flow
out
that
you
can
model
independently
right,
and
so
I
think,
handling
that
makes
sense.
D
But
then,
when
it
comes
to
well,
if
this
method
returns
true,
then
this
parameter
cannot
be
null
or
whatever
right,
or
this
out
cannot
be
now
or
something
that
gets.
I
think
I
would
ignore
those
and
just
say
yeah
those
you
if
you
care
about
those
you
have
to
crack
the
metadata
yourself,
but
I
don't
think
it
would
be
good
to
model
this
as
it's
complicated,
because
even
in
the
the
even
in
decades,
there's
still
a
static
declaration
of
what
that
data
type
is
and
it
either.
D
Or
it's
not
nullable
right,
it
just
means
oh
yeah,
in
certain
conditions,
when
it's
true
or
false,
then
we
may
know
additional
information,
but
like
that,
this
kind
of
you
know
if
you
were
a
higher
layer
on
top
of
that
that
you
now
have
to
understand,
but
that
goes
basically
to
flow
analysis.
I
don't
think
anybody
does
flow
necessary
with
reflection,
like
I
think,
literally
just
the
static
definition
of
the
of
the
property
or
the
or
the
method
where
you
care
about
what
it
actually
accepts.
D
A
A
Conditional
state
driven
something
of
that
that
if
you
want
the
simple
answer
null
can
happen,
and
but
that,
based
on
some
other
knowledge
that
we're
not
encoding
in
this
api,
that
there
are
times
that
you
could
maybe
treat
it
as
not
null.
A
H
It's
all
the
concepts
that
play
into
flow
analysis
so
like,
if
f
sharp,
were
to
want
to
take
their
null
ability
stuff
and
hook
into
c
sharp
scalability
stuff.
Could
they
actually
use
this
api
to
successfully?
Do
that
and
the
answer
right
now
is
no,
because
all
of
the
other
attributes
in
system
diagnostics,
code,
analysis
or
whatever
it
is
that
the
c-sharp
compiler
takes
into
consideration,
aren't
exposed
here.
D
Well,
I
mean
they
are
exposed
right
as
in
like
you,
you,
you
just
ask
for
the
custom
attributes
right.
It's
just
like.
We
don't
pre-parse
them
for
you,
but
like
you
can
you
can
you
can
you
can
combine
these
two
things,
but
you
can
say
I
look
at
my
ability
info
and
then
I
also
check
the
customer
attributes
to
see
whether
there's
more
information
on
those
things
right.
A
Yeah
I
mean,
I
think,
that'll
be
true,
no
matter
like
the
only
solution
to
that
is
be
rosalin
because
right,
it's
that
you
would
need
to
ex
or
you
come
up
with
a
100,
abstract
flow
model.
That
looks
almost
exactly
like
what
everyone's
flow
model
looks
like,
but
uses
bcl
types
instead
of
their
application
types
like
yeah.
That's
why
I
wasn't
going
so
far
as
to
say
that
this
should
expose
that
or
even
necessarily
say
here
all
the
attributes
that
I
think
we're
driving
into
it,
though
it
could
just
to
say.
A
D
Yeah,
so
to
me
the
takeaway
is
like
I
will
look
at
the
generic
constraints
and
I
will
look
at
the.
D
The
yeah,
basically
the
input
and
output
separation
right
for
properties,
so
we
can,
at
this
model
the
valuable
field
with
this
alone
null
or
an
unknowable
field
within
a
low.
Now,
because
those
are
pretty
common,
but
I
feel
like
yeah,
I
would.
I
would
limit
it
to
effectively
data
rather
than
control
flow,
because
the
thing
is,
I
think,
once
you
do,
control
flow.
D
Like
I
mean
this,
api
is
not
meant
for
compiler
writers,
but
if
you
implement
a
compiler
like
the
problem,
is
I
don't
think
that
we
can
give
you
the
information
in
such
a
way
that
you
know
it's
actually
useful
for
you
as
a
compiler
writer,
because
control
flow
analysis
is
fundamentally
difficult
right,
and
so,
whatever
you
do
today
in
your
compiler,
the
attributes
are
the
least
of
your
concerns.
I
think
it's
a
this
is
really
more
for
people
that
want
to
inspect.
H
Right,
but
I
I
think,
there's
a
clear
bit
missing
here,
which
is
there's
not
even
a
way
to
go
and
get
the
associated
attributes,
there's
no
way
to
go
and
get
to
to
say
I've
got
the
nullability
information
here.
Also
give
me
all
the
related
null
ability
annotations,
like
maybe
null
win
false,
which
is
going
to
be
on
almost
every
try
api
or
any
of
those
attributes.
You
have
to
know
about
them
separately.
D
D
I
would
probably
not
filter
them.
I
would
probably
just
give
you
the
entire
set
of
custom
attributes,
no
matter
whether
by
the
tunnel,
ability,
information
or
not,
because
that's
easier
and
less
work
and
chances
are
whoever
for
each
is
over.
That
will
have
to
specialize
them
anyway,
so
it
doesn't
really
seem
to
be
a
problem.
A
Yeah,
maybe
null
directly
extends
attribute,
not
null
directly
extends
attribute.
We
didn't
build
a
hierarchy.
K
D
D
Yeah
I
mean,
I
think,
the
the
our
impression
was
the
name.
Space
is
relatively
small
and
there's
a
very
small
number
of
them.
I
mean,
if
we
really
wanted
to,
we
could
just
you
know,
filter
down
to
things
in
the
analysis
and
the
coordinates
namespace,
but
that
seems
not
super
useful.
I
would
just
give
all
custom
attributes
and
say:
if
you
want
to
process
them,
go
ahead.
A
F
I
don't
think,
there's
a
whole
lot
of
value
in
exposing
like
a
generic
set
of
you
or
just
all
the
attributes
from
the
property
or
whatever.
On
this
thing,
if
you
want
those,
you
just
go
back
to
the
property
info
and
say
attributes
yeah
you
have
to
you
have
to
know
which
one
to
look
for
to
interpret
it
like
you
can't
just
say.
Oh,
this
has
a
member
not
null,
or
this
has
not
known
when
you
have
to
know
each
one
and
what
what
it
means
so
you're
going
to
have
to
go.
D
Yeah,
I
think
that's
probably
true,
I
think
the
I
mean,
if
you
think
about
it
realistically,
this
api
is
basically
handling
the
nullable
attribute
and
another
context
attribute
handling
right.
That's
really
what
it
does
today
and
we
should
probably
extend
that
at
least
for
the
for
the
simple
in
and
out
cases
so
that
people
can
ask.
You
know
poco
related
questions,
and
I
think
I
would
leave
it
at
that
and
then
circle
back
of
our
friends
in
ef
and
and
and
hp
net
and
make
sure
that
that's
sufficient
for
them.
L
I
think
that
will
be
just
make
it
more
complicated.
I
think
that
steve
hector
also
had
the
proposal
counting
all
in
out
values
and
just
making
this
bigger
and
very
complicated.
D
D
D
F
I
think
we're
just
we're
just
talking
about
allow
null
disallow.
No,
maybe
no,
I
should
probably
even
just
allow
null
and
disallow.
No,
the
other
ones
are
not
slow,
so
I
mean,
but,
and
you
kind
of
you
kind
of
need
those,
because
if
this
is
really
about
binding,
what
you're
really
asking
is?
Can
I
can
I
set
this
to
null?
Or
might
I
get
a
null
back
and
the
disallowed
null
and
allow
null
are
just
as
important
as
statically
as
the
annotation
is
in
that
one.
F
You
have
something
like
strong
box,
for
example,
where
you
know
you
can
construct
the
you
can
construct
a
strong
box
of
t
with
no
parameters,
at
which
point,
if
t
is
a
reference
type
like
it,
it's
going
to
be
null,
but
we
don't
want
to
allow
someone
to
set
that
thing
to
null
not
nullable.
So
right.
J
A
Yeah
so
generic
type
arguments
right
how
about
I
read
only
lists
so
that
we
don't
have
to
either
clone
it
or
have
one
mutable
number
on
your
type.
D
Yeah,
so
that's
yeah.
I
thought
about
that
too.
So,
the
so
first
of
all
the
yeah
I
mean
we
can
we
can
do
that.
I
mean
the
way
I
saw
is
just
it's
just
a
data
object.
So
if
you
mutate
it
you
own
it.
So
it's
on
you,
like
the
small
smart's
built
into
it,
and
it's
kind
of
mirroring
what
the
protection
apis
are
doing
right
because
they
almost
always
give
you
back
a
raw
race,
but
I
have
yeah,
we
can
make
it.
I
mean
if
you
make
it.
A
No,
but
I
mean
the
the
thing
that
can
be
returned
back,
is
you
know,
list
dot
as
read
only
which
does
prevent
rights
going
through
that
way?
You
only
have
to
build
the
list
once
when
you
populate
the
like
this,
so
to
go
back
to
the
notion
of
caching
right,
it's
if
we
have.
If
this
is
the
only
mutable
member,
then
it's
the
only
thing
that
can
be
poisoned
in
the
cash
and
if
we
get
rid
of
this,
then
it's
much
safer
to
cash.
D
Yeah
so
that
yeah
it
depends
on
what
we
want
to
cash
so
like
it
talked
about
yesterday,
but
we
probably
wouldn't
cash.
We
probably
wouldn't
cash,
the
nullability
infos
themselves.
What
we
would
cache
is
just
the
deniable
context,
so
we
don't
have
to
walk
the
hierarchy
every
single
time
you
ask
for
a
member,
but
the
yeah.
I
guess
that's
fair.
If
you
wanted
to
catch
some
ability
influence,
then
they
better
be
immutable
yeah.
So.
D
A
E
A
A
Property
yeah
that
that's
my
two
things
is:
if
we're
returning
a
distinct
one,
each
time
it
should
be
a
method,
and
if
we
want
to
return
it
as
a
property,
it
should
be
immutable
because
the
rest
of
the
type's
immutable.
M
M
A
B
M
D
D
D
D
M
D
M
A
D
D
No,
they
use
not
annotated,
annotated,
and
I
forgot
like
just
go
all
the
way
to
the
bottom.
Like
there's
a
discussion
with
jared,
they
use
the
the
g,
lots
lots
of
more
common
sense.
Yesterday,
yeah
yeah
they
use
none,
not
annotated
and
annotated,
so
none
meaning,
oblivious,
not
annotated,
meaning,
not
null
and
annotated,
meaning.
D
Maybe
now-
and
so
I
said,
I
don't
find
this
wording
particularly
descriptive,
because
you
kind
of
have
to
translate
in
your
mat
in
your
head
what
that
actually
means
in
terms
of
valuable
state
and
jerry
basically
said
like
yeah
from
a
compiler
author's
standpoint.
It
makes
perfect
sense,
but
he's
not
married
to
that
either
in
terms
of
naming.
So
that's
why
I
suggested
unknown
malleable
and
and
then
not
nullable,
and
maybe
now,
because
that
seems
to
be
what
people
probably
understand
more.
I
I
like
that
as
well.
I.
F
D
Yeah,
that's
kind
of
my
problem.
I
mean
the
other
nomenclature
they
have
in
the
docs,
where
they
also
talk
about
oblivious
versus
unknown.
That's
more
the
flow
state
thing
which,
for
most
people,
doesn't
really
matter.
It's
more
the
you
know
what
does
the
compiler
think
of
this
type?
It
doesn't
really
talk
about
what
the
consequences
are
right.
D
A
D
B
D
What
assignments
it
allows
yeah?
So
that's
why
I
went
with
these
things.
I
assume
everybody's
okay
with
the
naming
for
the
for
the
inner
members.
A
Yeah,
okay,
so
it
sounds
like
you're
taking
that
you
don't
want
to
drive
this
too
approved
that
you
just
want
to
take
the
notes
and
and
think
about
things
now.
D
A
I
F
I
F
The
feature
is
basically
there's.
There's
differences
between
what
well
tell
me
what
we
should
we
should.
We
should
wait
for
alexa
to
be
here
and
we'll
discuss.
A
I
mean,
I
guess
I
think
david
cared
about
the
create
scope
thing
right,
or
does
he
just
yeah?
He.
A
A
D
And
looks
like
the.
D
J
N
D
N
Right
so
like
yeah,
so
let's
that's
what
I
figured
like.
So
the
simple
problem
right
is
that
you
can
have
scope
services
that
are
isink
disposable
right
and
if
the
scope
isn't
iasync
disposable,
you
end
up
with
sync
over
async.
So
why
not
make
the
scope
iasync
disposable?
So
at
least
you
have
a
non-blocking.
A
A
D
H
A
H
N
N
O
N
Is
I'm
pretty
sure
what
we
do,
but
I
think.
O
D
N
Right
and
like
this
is
like
the
the
service
scope
is
more
typically
used
by
like
application
code
right
then
implemented.
So
it's
one
of
those
things
where,
if
it's
not
on
the
interface
you
have
to
know
like
asp.net
would
know,
but.
D
Right,
I
mean
I
mean
we've
done
the
same
thing
in
memph,
though,
like
I
mean
it's
assuming,
if
you
have
enough
infrastructure
that
generally
wires
the
stuff
up
like
like
in
math,
nothing
extends
I
dispose
of.
It
was
just
that
if
your
meth
party
happens
to
implement
eye
disposable
than
we
will
call
it,
and
that
seems
like
not
a
bad
pattern
right,
considering
that
most
things
don't
have
to
be
disposed.
N
A
Yeah
I
mean,
I
think,
that
what
david
has
here-
apologies
to
anybody
who
else
contributed
his
names
on
it
is
like
this
is
the
way
that
we
handle,
like
he
basically
made
a
union
right
and
then
nicely
handled
the
dealing
with
it
for
you,
so
it
this
is.
N
D
Yeah,
okay,
yeah.
The
one
problem
with
this
is
basically
if
the
runtime
can't
decide
which
default
implementation
to
use
you're
screwed
and
that's
basically,
when
you
have
diamonds
right
because
then
you
can
end
up
with
more
than
one
candidate.
Then
it's
like
oopsie,
which
one
you
want
to
call
and
that's
basically
like.
If
your
goal
is
to
minimize
breaking
changes.
D
Well,
don't
add
things
that
might
result
in
breaking
changes,
but
I
think
what
david
is
proposing
makes
sense,
but
I
guess
the
corollary
of
that
is
that
we
would
tell
people
don't
do
create
service
scope,
call
create
async
service
scope,
no
right.
N
A
D
N
The
create
scope
method
comes,
that
is
an
extension
method
because
it
pulls
out
like
the
I
service
scope
factory
and
calls
create
scope.
N
N
D
A
D
A
D
N
I
mean
that's:
what
happens
today?
You're
suggesting
like
throwing
is
an
alternative
well
doing
nothing.
A
F
F
A
A
D
Cool
yeah,
and
we
should
just
make
sure
that
the
yeah,
okay,
so
service
provider
service
extension
is
the
correct
time.
A
That,
at
least,
is
the
name
of
a
type
that
exists.
It,
in
fact,
has
a
create
scope,
method.
D
N
D
N
Yeah,
so
we
we
basically
want
to
be
able
to
cancel
sig
terms.
The
same
way
we
can
cancel
like
a
control,
c
event
on
windows
and
basically
say
don't
exit
the
process.
So
currently,
what
asp.net
does
is
we
block
and
process
exit?
So
you
know
we
can
unload
our
host.
Basically,
we
can
just
finish
unwinding
disposing
our
servers
that
kind
of
stuff
before
the
sig
term
is
actually
like
handled
by
the
runtime.
The
process
exits
right,
but
a
sig
term,
despite
the
name
right
like
the
process,
doesn't
have
to
exit.
N
You
can
ignore
it,
not
not
with
the
current
apis
and
that's
kind
of
the
problem
right.
So
we
want
it
to
be
more
like
a
signal
like
cancel
key
press
where
you
can
do
something
where
you
can
say
yeah,
we
got
you
like
we'll
handle
the
termination
of
the
process
ourselves
like
that's
the
plan
for
asp.net
right,
like
the
host
likes,
that
program
main
will
unwind
it
will
exit.
We
just
don't
want
to
have
to
like
have
this.
N
You
know
blocking
callback,
halt
everything
I'm
here,
yeah
wait
is
he
on
here?
Are
both
the
answer.
M
N
Wonderful,
so
this,
if
you
start
off
as
a
request,
basically
just
fix
sig
term
handling,
so
some
background
sick
term
is
there.
There
are
a
bunch
of
signals
on
on
non-windows
platforms
that
you
can
use
to
handle
arbitrary
things.
Some
have
meaning
so
like
sigin
is
like
control
c,
and
some
people
map
things
to
like
shut
down
and
other
arbitrary
signals.
We
don't
have
an
api
to
handle
signals
generically
in.net.
We
have
another
package
called:
what's
it
called.
N
That
one
yeah
exactly
yeah
that
can
be
used
to
implement
some
of
this
stuff.
N
This
was
inspired
by
the
fact
that
several
orchestrators,
like
kubernetes
and
docker
and
systemd,
use
different
signals
to
basically
trigger
shut
down
or
mean
different
things,
so
the
original
intent
was
could
we
handle
you,
know
sig
term
and
second
and
control
c
in
kind
of
the
same
way,
so
we
don't
have
to
kind
of
write,
different
code
and
and
and
have
different
features
based
on
how
dot
net
map
goes
to
the
current
apis.
N
So,
for
example,
background
the
way
you
handle
control
c
and
second
today
and
say
quit
I
think
on.net,
is
you
use
console.cancel
keypress
signals,
I
believe,
can
be
cancelled
by
by
setting
by
setting
e.cancel
in
the
in
the
handler
to
true,
which
means
that
we
basically
are
telling.net
cancel
whatever
your
cancel,
the
default
handler
in
the
runtime
and
instead
just
just
let
me
handle
it
myself.
N
Today.Net
maps
stick
term
to
process
exit
the
issue
with
that
is.
If
you
want
to
use
sick
term,
which
is
used
by
kubernetes
and
docker
to
start
a
great
school
shutdown,
you
have
to
block
the
process
exit
callback
until
your
code
is
done
running
and
it
turns
out.
This
leads
to
a
ton
of
deadlocks,
as
you
could
imagine
right.
If
you
block
process
exit
and
someone
calls
process.exit,
I'm
sorry
in
environment.exit.
It'll
hang
right
in
some
strange
way.
N
If,
if
you
want
to
have
your
code
in
main
unwind
and
run
to
completion,
you
have
to
kind
of
block
the
the
exit
callback
until
your
code
fully
unwinds
people
get
really
confused
when
controls,
he
does
one
thing
and
turn
to
something
else.
So
the
intent
here
was
that
we
would
add
an
api
to
let
us
both
to
handle
both
of
those
in
the
same
way
for
these
scenarios
and
also
avoid
the
the
having
to
synchronize
between
the
exit
events
and
the
main
process.
D
N
So
it
started
off
not
not
being
that,
but
then
jan
kind
of
encouraged
us
encouraged
to
make
it
more
generic,
because
we
had
a
bunch
of
these
issues
hanging
around
and
I
looked
at
other
platforms
like
and
they
basically
when
this
is
sorry
doughnut
is
the
only
platform
that
has
the
windows
specific.
Like
viewpoint
all
the
other
platforms
kind
of
map,
these
signals
back
back
into
windows,
signals
or
windows.
M
The
windows
fall
back,
you
know
or
deep
tapping.
It's
just.
You
know
kind
of
best
effort
to
not
make
this
api
completely
useless
on
windows
yeah.
You
know
I
can
completely
imagine
you
know
that
you
can
make
this
api
be
a
unix
specific.
It
would
throw
platform
now
supported
exception
on
windows.
That
would
be
completely
valid.
You
know,
approach
to
it,
just
you
know,
doesn't
seem
as
useful
yeah.
M
You
know.
One
problem
with
signals
is
that
on
windows,
you
can
actually
deal
with
the
subscribing
to
see
to
the
you
know
to
the
windows
signal.
Like
events
using
b
invokes,
and
so
you
can
kind
of
work
around
it
yourself.
M
If
you
want
to
without
writing
unmanaged
code
with
signals,
you
cannot
actually
write
signal
handlers
in
manage
code
so
basically
like
if
you,
if
you
are
not
happy
about
what
the
platform
does
for
signal
handling
by
default,
you
have
to
write,
you
know
some
animated
shims
and
you
know
set
a
bunch
of
groove
that
that's
basically
what
was
in
the
monopod
6
package
right
right.
So
what
this
api
is
about
is
providing.
You
know
manage
wrapper
for
signal
handling.
That's
part
of
the
core
platform.
N
Yeah,
okay,
all
right
so
in
in
in
the
usage
for
extensions
hosting
it'll,
probably
have
one
callback
for
for
different
signals.
But
there
were
a
couple
of
other
people
who
requested
you
know
more
advanced
scenarios
for
their
applications.
F
N
Yes,
sorry
yeah,
that's
right!
Yeah!
One
thing
I
am
worried
about
are
signals
that
can't
be
cancelled
this
this
edoc
canceled
in
the
callback
for
the
handler,
like
there's
no
way
to
know.
If
that
will
work
or
not
like,
I
believe,
if
we
map,
for
example,
control
shutdown
event
to
like
some
like
sick
term,
for
example
like
on
windows,
you
can't
cancel
that
that
is
like
the
end
of
the
world.
N
A
A
A
N
A
So
I
mean
what's
interesting
because
I
pulled
up
the
man
page
for
signal
just
to
remind
myself
how
they
work,
unix
or
posix
signals
can't
be
cancelled.
If
you
have
a
handler,
then
your
handler
is
the
only
thing
that
runs
you
there's
no.
F
Well,
yes,
what
we
do
for
like
console
today
is
we
intercept
the
signal
and
then
we
don't
forward
it
along,
so
we
we
eat
it
and
as
far
as
the
os
is
concerned,
it's
been
handled,
it's
done
right
and
then,
if
we
want
to,
if
cancel
is
true,
we
end
up
removing
our
signal,
hander
and
reissuing.
The
signal
right.
F
C
A
M
A
Way
is,
or
this
way
looks
like
the
way
we
did
event
stuff
of.
If
you
end
up
going
through
multiple
callbacks
yeah,
we
can't
handle
returns
so
have
a
mutable
cancel
but
yeah.
We
could
certainly
make
it
funk
of
basically
just
funko
signal
to
bull,
but
then
I
feel
like
we
have
a
harder
time
describing
what
the
bull
is,
but
maybe
not.
N
I
have
so
far
like
how
many
do
we
add
to
this
enum.
Do
we
add
all
of
them?
Do
we
add,
like
only
a
few,
that
we
think
are
super
important,
then
the
other
one
is,
I,
I
think,
control
shutdown
event.
You
can't
cancel
in
windows.
A
A
N
A
F
A
M
A
A
Based
on
things
that
I
remember
from
you
know,
working
with
the
yawns
of
our
complicated,
open,
ssl
shutdown,
ad
exit
handler
problem
on
ubuntu.
That
just
means
you
need
to
be
a
background
like
you
need
to
move
something
to
a
background
thread
to
handle
this
event
and
then
call
exit
and
that's
how
the
system
works.
A
N
You
have
a
callback,
that's
that
is
process
exit
in
in
main
right
in
a
console,
app,
typically
you're,
going
to
block
main
right
because
you're
you're
waiting
for
a
signal
from
somewhere
else
to
tell
you
to
shut
down.
So
you
send
controls.
You
send
a
control,
control,
shutdown
event
to
your
process.
It
triggers
the
callback,
your
main
isn't
running.
Your
main
is
blocked
in
an
event
right
and
you
you
basically
want
to
trigger
from
the
shutdown
handler
to
resume
main
to
completion.
N
A
Fair
enough
I
mean,
I
guess,
a
reasonable
semi-reasonable
thing
while
designing
things
in
my
head
is
you
can
only
if,
if
they
have
async
main
that,
maybe
there's
a
way
to
grab
that
task
and
then
just
wait
on
that
in
the
callback
handler
for
shutdown
event,
and
if
they
did
synchronous
main
then
the
process
dies.
N
Like
the
and
the
only
reason
this
comes
up
is
because
people
have
followed
about
a
thousand
bugs,
probably
ten,
but
a
thousand
in
my
mind
thousand
bucks.
It
feels
like
a
thousand
bugs
where
they
basically
wrote
code
that
works
fine
on
on
linux
and
and
we'll
flush
logs
and
we'll
run
to
the
end
of
the
main,
but
then
on
windows.
N
It
ends
halfway
through
the
main
running,
because
we
we
block
until
you
call
dispose
and
their
function
didn't
run,
didn't
call
something
that
that
was
there,
because
it
is
quit
midway.
N
M
N
M
C
And
there
was
also
some
discussion
about
like
adding
more
non-can
like
non
process,
exiting
signals
where
there
are
signals
that,
for
example,
are
issued.
When
I
don't
know,
windows,
3
size
or
whatever,
and
then
when
we
are
already
doing
some
signals,
then
maybe
it
would
make
sense
to
do
like
all
or
majority
of
the
async
signals
like,
because
the
processing
would
be
basically
the
same.
F
Yeah,
I
think
at
that
point
that
sounds
from
a
linux
perspective.
That
sounds,
like
goodness,
for
a
windows
perspective.
I
feel
at
that
point
we're
not
going
to
have
clean
mappings
for
a
bunch
of
those
some
of
them.
We
will
a
bunch,
we
won't,
and
so
we
probably
would
need
some
sort
of
can
handle
api
where
online
on
signal
context
or
on
like
a
static.
M
F
D
D
D
I
kind
of
like
the
idea
of
having
a
platform
like
cross-platform
from
day
one
because
it
seems
like
you,
don't
want
to
write
different
code
based
on
operating
system
right
for
the
for
the
general
case
and
if,
if,
if
the
general
event
like
like,
if
most
signals
can
be
mapped
to
something
saying
across
operating
systems,
I
think
a
crossover
from
api
makes
sense,
and
then
we
can
still
add
linux,
specific
signal,
handlers
and
just
said
sorry,
you
can't
do
that
on
windows.
That
seems
fine
right.
You
just
have
an
api
that
can
grow.
Then.
N
D
Yeah
I
mean
that
kind
of
depends
on
how
we
want
to
do
this.
I
feel,
like
you,
probably
given,
given
how
linux
signals
work,
which
is
kind
of
this
open-ended
like
numeric.
I
give
you
something
and
then
there's
some
behavior
thing
like
you
probably
want
that
as
the
key
api.
Otherwise,
this
will
be
hard
to
evolve
right.
D
M
M
N
C
Okay,
it's
not
the
case
for
the
for
the
ones
that
that
are
not
process
exiting
seems
like
the
sick,
tt
in
six
cto
and
sick
win
change
are
all
having
different
numbers
on
weird
platforms.
A
Yeah,
it
looks
like
I
mean
it
probably
comes
back
to
this,
one
of
which
standard
did
a
standard,
define
it
or
did.
A
It
but
but
yes,
I
thought
that
this
one
looked
more
interesting
to.
A
I
mean
the
quick
things
that
I
have.
Are
you
know
if
we're
trying
to
emulate
the
posix
signal
api
that
we
probably
want
to
call
the
signal
posix
signal,
basically
just
because
signal's
a
super
generic
name
and
generally
we
don't
use
interrupt
names
in
public
api,
which
means
we
would
then
name
these
the
you
know,
words
hang
up,
interrupt,
quit,
terminate,
etc.
M
H
N
D
If
you
just
want
to
have
I
mean
at
that
point
I
mean
another
option
is
to
just
put
this
in
its
own
name
space
and
making
it
is
it's
its
own
thing
right,
but
I
mean
it
depends
on
how
you
know.
I
guess
how
much
we
care
to
make
this.
You
know
net
like
scenario
rather
than
just
an
interval
component.
Sorry.
N
C
F
Yeah,
if
we're
talking
about
the
enum
values
themselves,
I
think
these
are
the
right
names.
I
mean
you
basically
have
three
options.
You
can
use
the
unix
or
the
posix
names.
You
can
use
the
windows
names
or
you
can
come
up
with
some
dot
net
name
in
this
particular
case,
coming
up
with
a
dot
net
name,
while
it
might
read
better
you're
not
going
to
find
any
documentation
from
the
underlying
os
about
what
that
means.
F
The
windows
name
most
of
these
aren't
going
to
have
a
direct
windows
mapping
we're
going
to
do
some
kind
of
emulation
for
the
for
these,
like
yes,
there
is
for
some
of
them,
but
not
for
all,
and
the
linux
one
is
very
clear,
like
it
maps
to
or
the
unit
the
posix
one
it
maps
to
very
clear
documentation
about
what
this
is
being
sent
for,
and
I
think
it's
the
most
searchable
thing.
We
could
use
fair
enough.
The.
A
Other
thing,
because
when
tanner
mentioned
interrupt
services
we
use
names.
The
first
thing
I
thought
of
was
win
api.
So
the
existing
calling
convention
thing
we
pascal
cased
these
things
again,
I'm
not
saying
we
have
to
do
it,
I'm
bringing
it
up
that
we
could
do
big
s
little.
I
little
g
big
h,
little.
U
little
p,
that's
probably
the
worst
of
all
worlds,
but
you
know
I'm
just
making
sure
that
we
consider
it
so.
N
Two
questions
I
have
so
I
do
think
it
is
feasible
to
to
build
a
higher
level
api
that
is
more
targeted
for
shutdown.
On
top
of
this
little
api,
the
host
will
do
it
for
you
on
your
behalf,
so
you
have
to
worry
about
that
but
like
if
you
want
to
write,
if
we
want
to
explore
something
else,
we
could
expose
it
on
top
of
this
api.
K
N
N
N
N
A
I
think
this
nun
handler
is
that
it's
always
cancelled.
Oh
deep,
I
think.
A
C
How
we
handle
the
signal
in
the
low
like
in
the
native
part
of
the
runtime,
so
basically,
when
we
register
a
signal
hunter,
the
none
means
that
we
completely
ignored
the
previous
handler.
So
we
don't
attempt
to
call
it
after
our
handler.
Even
if
we
didn't
cancel
it,
then
then
the
the
second
is
chaining,
which
would
mean
that
after
we
finish
and
we
didn't
like
cancel,
then
we
would
call
the
default
handler
and
the
the
two
remaining
are.
Oh,
the
the
wrister
when
disposed.
C
I
I
it
was
actually
based
on
some
some
of
the
implantation
detail.
I
I
don't
think
this
one
was
needed
like
like
restoring
the
original
handler
when,
when
the
signal
registration,
which
is
somehow
disposable
suggestion
was,
was
disposed,
I
we
don't
have
it
in
the
new.
C
You
know
in
the
original
design-
and
I
don't
see
a
big
like
reason
for
this,
and
there
is
a
restore
when
this
sorry,
a
signal
when
disposed
is
basically
that
we
we
r,
we
would
refire
the
signal
once
we
once
that
signal.
Registration
thing
will
go
disposed
so
so
for
the
original,
and
there
are
some
some
issues
with
this,
because
the
signal
handling
is
async.
C
So,
basically,
in
the
signal
handler,
you
cannot
run
any
any
managed
code
because
of
like
a
re-entrant
possible
problems
with
the
internet,
re
intention
of
like
say
a
location
or
a
file
io
or
whatever
in
the
c
library.
And
so
so
you
can
basically
just
like
a
signal.
C
Some
other
thread
that
will
later
launch
the
actual
handler.
So
we
don't
have
a
way
to
to
right
away
like
do
anything
with
the
original
handler.
The
only
way
that
we
have
is
to
like
fire
the
same
signal
again
later
and
somehow
then
let
it
be
handled
by
the
original
handler,
but
like
the
the
yeah,
we
cannot
like
return
from
our
handler
and
then
call
call
them
right.
M
Sounds
good
to
me
yeah,
I
think
the
cancer
true
false
is
the
right
right
choice.
Yeah,
there's
like
the
one
scenario
I
can
see
is
that
when
people
want
to
handle
just
that,
when
people
want
the
original
signal
to
be
forwarded
immediately
to
the
you
know
to
the
next
one
in
the
chain,
but
they
want
to
attach
some
action
to
it
right
right.
M
B
C
Yeah,
the
the
recommendation
of
like
chaining
signals
is
usually
just
like
do
your
stuff
and
then
and
pass
it
to
the
the
original
handler.
But
it's
true
that,
if,
if
your
stuff
is
just
just
some
like
trigger
setting
some
some
event
and
then
returning,
then
then
you're
right
that
this
would
be
something
that
we
could
also
like.
That
could
make
sense.
I
D
D
M
M
B
C
Not
these
ones
that
that
require
like
immediate
handling
like
yeah,
like
like.
M
A
Mean
we
can't
really
do
that
because
some
of,
unless
all
of
the
good
ones
are
the
universal
numbers,
because
once
we
have
a
mapping,
then
it's
possible
that
they
were
trying
to
register
sig
potato
and
we
reinterpreted
it
as
sig
onion.
C
M
C
It
would
be
better
like
for
the
like
implementation
in
the
poll
how
we
handle
stuff
it's.
I
would
prefer
like
really
keeping
a
selection
that
we
would.
I
would
always
register
the
handler
like
on
the
on
the
power
level
and
then
then
do
whatever
like.
When
the
manage
code
asks
for
registration,
it
would
be
just
like
calling
it
or
signaling
something
or
not,
but
we
would
always
keep
it
registered.
Probably.
M
M
C
F
C
A
system
native
yeah:
that's
that's,
actually
why
I
suggested
not
to
even
like
support
handling
these
6gb
and
sig
bus
and
the
ones
that
we
handle
there.
We
can
remove
the
handling
of
sick
term
completely
after
this
change.
From
from
the
like
the
course
you
are
pal,
like
I
guess.
F
I'd
be
inclined
to
just
to
keep
this
to
the
set
that
we
know
how
to
handle
and
throw
for
anything.
We
don't
understand.
N
Are
a
few
more
that
that
this
person
asks
for
that?
I
don't
know
if
we
that
are
harmless,
maybe.
C
C
C
M
And
just
just
an
idea
we
can
have,
the
enum
can
have
like
negative
values,
and
you
know
those
we
will
map
and
those
will
be
the
good
ones
and
if
somebody,
you
know,
passes
positive
value
cast
to
it.
You
know
cast
to
the
email
and
basically
says
yep.
You
know,
you
know
what
you
are
doing
just
pass
it
through.
A
Say
anything
that
is
at
least
the
non-universal
one
like,
I
think,
sig
child.
If
we
wanted
to
expose
that
as
since
it's
not
universal,
we
should
use
something.
That's
not
the
right
answer
on
any
of
the
platforms.
Yeah
like
a
negative
number,
this
value,
it's
the
obvious
choice
for
that.
N
I,
like
that,
do
we
try
to
map
the
windows
values
as
well,
or
do
we
just
let
those
like
we?
We
do
our
our
mapping
and
you
can't
really
pass
in
the
low-level
signals
for,
like
other
things,.
N
I
think
the
question
is:
do
we
want
an
abstraction
other
than
the
host,
at
least
for
shutdown
signals
and
like
there's
that
proposal
you
made
for
environment,
wait
for
shutdown,
async
or
something.
N
Yeah
but
like
that
feels
useful,
if
you
don't
want
to
use
the
host
yeah
okay,
so
let's
punt
watch
it
it's
fine!
You
cannot
handle
the
the
event
on
windows
that
we
don't
support.
That's
fine!
I
I,
I
think,
there's
only
one.
We
don't
support
right
now.
N
N
C
I
think
wind
size
change
and
the
tt
entity
out
makes
sense
to
me
that
sick
child
definitely
sounds
like
something
useful.
N
The
mappings
to
win
to
window
signals
do
we
document
those
as
part
of
it.
We
should
write
just
like
say
the
same
ones.
There
are
those
fine.
M
F
Sense
to
me
I
thought
this
was
something
like
for
something
like
window
resize.
That
feels
like
a
someone's
gonna
wonder
why
they're
not
getting
callbacks.
A
Unless
we
make
a
fire
sure,
like
I
mean
that
means,
we
need
a
way
to
tell
either
we
need
to
hook
it
here,
for,
I
guess,
doesn't
matter
if
you're,
winforms
or
wpf,
it's
probably
the
same
event,
gets
raised
through
windows
events.
So
we
could.
We
could.
M
A
All
right
so
I
said
it
in
the
beginning
and
I
don't
think
anybody
acknowledge
one
way
or
the
other.
Should
we
rename
signal
to
posix
signal.
N
N
A
Well,
there's
a
registry
key!
That's
existed
since,
like
in
t4
that
you
can
turn
it
on
which
is
be
positively
compliant,
and
then
you
get
to
watch
as
processes
crash,
left
and
right
because
file
paths
become
case,
sensitive
right
and
that's
funny.
But
it
has
nothing
to
do
with
this,
because
this
will
work
without
that
red
flag.
A
Yeah
I
mean
like
the
fact
that
we're
using
you
know
non-standard
naming.
That
is
just
the
name
of
the
posix
signal
is
why
I
think
posix
signal
is
the
name
for
this.
A
N
D
So
it's
posix
signal,
pauses,
posix,
signal
context
and
then.
D
D
C
A
All
right,
but
the
property
on
posix
signal
context.
I
think
we're
fine
with
that.
Just
being
signal.
Yeah
yeah
of.
L
N
M
J
G
It
should
have
a
constructor
that
that
takes
the
signal
as
a
parameter
too.
That
way
you
can
test
it.
M
G
You
get
a
robot
that
controls
these
on
the
keyboard.
While
the
test
is
running.
N
A
N
A
A
N
A
A
A
I
think
yawn
wanted
positive
value
pass
through
of
like
fine,
we'll
call
the
registration
handler
for
you
and
if
you
kill
us,
you
kill
us
okay
and
if
you're
on,
if
you're
not
on
x86-
and
you
didn't
look
up
this
map,
then
good
luck
and
I'm
I'm
willing
to
hold
my
nose
and
turn
around
while
that
goes
through,
I'm
not
willing
to
write
that
down.
A
Actually,
it
means
there's
a
public
constructor.
We
probably
want
this
non-constructable.
A
No,
no
because
it
was
previously
a
struct
it
was,
it
was
previously
a
struct,
which
means
it
has
a
constructor
that
you
can't
stop.
But
now.
M
M
A
F
I
do
have
a
question:
maybe
this
is
implementation
detail,
but
behaviorally
do
we
imagine
wanting
this
to
have
a
finalizer
or
you
have
to
you
better
call
dispose,
or
else
it's
just
you
know,
for
the
lifetime
of
the
process.
I.
A
N
M
A
The
yeah,
that's
a
good
point,
john.
I
was
going
to
say
it
previously.
If
there
the
disposed
behavior,
it
has
assumes
everyone
does
things
in
a
pure
stack
manner,
but
if,
if
you
know,
I
register
second
and
then
yawn
register
segant
and
then
I
unregister
now
it's
back
to
the
default
handler,
because
that
was
my
parent
context.
F
M
F
M
F
A
Right,
so,
okay,
so
it's
not!
Each
call
to
this
is
calling
signal
from
the
os's
api.
It's,
oh,
we
don't
have
a
handler
for
that.
Yet,
let's
wire
up
now
right
the
hand,
let's
go
register
the
handler
for
segend
three
things
called
in
they're
just
queued:
they
come
out,
we
dq
or
yeah.
We
we
pull
them
out
of
the
whatever
structure,
we're
using
to
represent
them
and.
A
A
Okay,
so
we
don't
have
stack,
we
don't
have
register
and
unregistered,
not
in
a
stack
manner.
Problems.
Okay
and
yeah-
I
mean
yeah.
There
is
the
question
of
does
registering
even
need
to
exist,
but
it's
probably
nice.
F
D
F
F
D
D
I
think
we
just
document
what
the
behavior
of
these
individual
flags
are,
because
I
mean
they're
already
very
specialized.
You
know
where
you
have
to
say
well,
if
you're
running
on
ubuntu
1604,
then
you
get
that
behavior,
but
if
you're
running
on
red
hat
7.8,
you
get
that
behavior
right.
So
it
might
be
nuanced
anyway.
D
Yeah,
the
other
thing
I
wanted
to
say
earlier,
like
we
should
not
have
a
constructor
if
there's
a
massive
side
effect
like
I
mean,
given
that
the
constructor
would
put
this
thing
in
some
registration
queue,
it
seems
weird
that
the
constructor
would
do
that
like
to
me.
Constructors
are
kind
of
you
know
semi-pure
in
the
sense
they
give
you
a
new
instance
and
that's
all
they
do.
They
should
not
do
some
crazy
things
where
newing
up
an
object
magically
makes
it
appear
in
some
queue,
so
timers.
A
Right,
I
I
agree
with
your
your
starting
point
but
yeah
I
like
playing
devil's
advocate.
J
J
M
G
A
A
Yep
so
see
you
on,
I
was
double
checking
that
wasn't
the
one
that
got
rescheduled
so
yeah
tuesday
10
a.m.
Pacific
time.
D
That
would
be
my
suggestion.
I
mean
I
mean
in
general,
like
I
want
to
do
things
in
somewhat
of
a
you
know,
priority
order,
but,
like
we
don't
know
the
priority
right,
the
feature
owners
are
the
ones
that
have
more
thing
into
that,
but
we
given
given
where
we
are
given
how
many
issues
we
have.
We
should
be
somewhat
selective
of
what
we
do
so
because
we
can't
get
it
everything.
H
D
Alrighty
then
have
a
good
weekend.
Everyone.