►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
All
right
so
today
we
have
two
blocking
issues.
I
removed
the
rest
from
the
agenda
because
I
think
the
json
will
probably
keep
us
busy
for
the
rest
of
the
meeting,
because
it's
a
fairly
large
api
surface,
but
we
will
start
with
the
networking
one
that
literally
just
came
in
like
half
an
hour
ago.
B
Yeah
sure
so
we
use
uri
to
represent
urls
in
nets.
For
example,
http
client
will
only
let
you
make
http
requests
through
it
and
your
I
may
do
a
bunch
of
different
transformations
on
the
us
string.
You
give
it
right,
it
will
validate
it,
it
might
escape
some
characters,
unescape
some
it
will
remove
dot
segments
and
so
on.
B
So
it
plus
various
little
things
that
may
change
the
exact
string
you
gave
it,
and
so,
if
you
try
to
use
it
with
hb
client,
there
are
cases
where
you
might
not
be
able
to
send
exactly
the
string
you
wanted
to
send
for
the
path
in
querying.
B
In
this
case,
we
had
a
few
asks
to
disable,
either
the
removal
of
dot
segments
or
the
one
behavior,
which
is
that
we
unescape
unobserved
characters
all
right.
If
you
have
escaped
the
character,
a
we'll
just
give
it
back
to
you
as
a
letter,
since
it
doesn't
have
to
be
escaped,
which
is
problematic
in
these
cases
right
where
services
depend
on
an
exact
representation
in
the
back
end.
B
Now
urine.net
does
this
based
on
rfc
recommendations,
but
they're,
not
musts,
so
we
can
be
more
relaxed
here
in
what
exactly
we
do
so
we're
proposing
of
adding
an
api
to
uri,
which
is
the
url
creation
options
where
you
can
specify
different
behaviors
of
the
uri,
exactly
what
you
want
it
to
do,
and
then
apis
to
take
that
struct
into
the
uri
constructor
and
the
try
create
helper
now
in
the
proposal
here.
B
We're
not
quite
sure
what
to
call.
It
is
one
of
the
main
concerns
so
for
disabling
the
validation
parsing
and,
like
canonicalization
of
the
patent
query
cycle.
Part
of
the
uri.
B
B
For
example,
I
added
here
the
allow
implicit
file
paths,
which
is
another
thing
that
many
users
have
hit
in
the
past,
in
that
uri
will
support
file
paths
as
valid
your
eyes,
even
if
they're
not
file,
colon,
slash
and
so
on,
so
that
support
is
based
also
on
the
underlying
operating
system.
So
it's
different
on
unix
versus
windows
and
you
might
run
into
confusing
behavior
such
as
doing
slash.
B
So
using
this
flag
would
allow
you
to
disable
all
implicit
file
pad
support.
So
if
you
wanted
to
be
explicit,
you
still
had
the
option
to
do
it,
but
if
you
knew
that
what
you're
passing
in
is
in
our
relative,
uris
or
absolute
ones,
then
you
don't
care
about
files,
then
you
can
just
toggle
it
off.
A
B
Security,
wise,
the
properties,
might
not
return
the
value
in
the
format
you
would
expect
it
to
if
the
flag
was
not
set
as
well.
You
may
have
assumptions
about
exactly
which
thing
is
escapers,
so
on
one
thing
that
this
can
cause
is
it
can
corrupt
http
requests?
For
example,
if
you
give
us
a
raw
space
character
and
tell
us
that
this
is
raw,
then
we
won't
escape
it
for
you,
and
this
wouldn't
work
in
hdb
right.
It
would
break
the
request,
for
example,.
C
E
D
That
seems
that
seems
okay,
though,
from
the
point
of
view
that
this
api
is
clearly
marked
as,
like.
You
trust
this
input,
I'm
as
much
as
you
know,
we
try
to
make
things
safe
and
foolproof.
You
know
if
we
expose
an
api,
that's
clearly
marked
as
hey
you'd,
better
know
what
you're
doing
before
you
called
us.
Well,
you
know
you,
you
have
taken
the
gun
into
your
hands,
how
you
use
it
is
up
to
you
right.
A
Yeah,
I
guess
my
question
is
so
it
makes
sense
when
you
control
the
uri
right.
So
but
let's
say
I
am
a
spin
net
on
the
server
side.
How
do
I
retrieve
the
slash
full,
a
equals
percent
42,
for
example,
I
mean
that
almost
seems
like
you
want
some
sort
of
global
flag.
That
would
turn
that
off
which
that
seems
pretty
bad.
A
D
F
G
B
B
We
just
won't,
do
it
after
the
authority
of
the
uri.
So
if
we
just
call
it
disable,
then
it
might
be
obvious
that
which
part
it
applies
to.
B
E
And
does
it
really
need
to
be
immutable
like
if
I
have
one
uri
creation
options
and
I
want
to
clone
it
and
change?
One
thing.
A
A
Yeah
because
it
also
seems
like
if
object,
creation
is
really
a
concern
you
can
dribble.
You
know
just
store
a
global
reference
to
these
right
because
they
are
like
fundamentally
invariant
to
the
actual
url
right.
It's
just
how
many
different
options
do
you
need
right
and
that's
a
finite
set,
usually.
B
Yeah,
I
personally
don't
see
a
reason
why
it
couldn't
be
a
class.
It
was
mainly
a
struct
just
because
it
can
be,
for
example,
if
you're
creating
it
in
line
right.
You
wouldn't
want
to
allocate
accidentally,
but
if
it
is
a
class.
A
Well
sure,
but
I
mean
I
I
thought
that
isn't
the
init
somehow
marked
with
a
I
thought,
the
return
type
of
the
setter,
like
the
void
return
type,
I
think,
is
marked
with
a
mod
break.
That
basically
means
you
can't
call
it
unless
you
know
what
it
means,
but
I
could
be
wrong.
Why.
I
E
E
A
G
And
for
what
it's
worth
emo,
it
does
look
like
and
it
gets
a
mud
wreck,
not
a
mod.
A
J
A
A
I
Why
I
think
it
largely
depends
on
why
we're
creating
this
thing
in
the
first
place,
if
the
goal
here
is
just
to
create
to
avoid
having
to
create
more
constructors,
but
in
reality
all
we're
really
doing
is
adding
constructors
that
take
a
whole
bunch
of
additional
things.
That's
that's
the
entire
purpose
of
this
right
just
to
pass
in
additional
things.
Without
adding
new
constructions
in
the
future,
then
having
a
struct
seems
fine
to
me.
J
And
if
there's
no
performance
consideration
here,
then
maybe
it
doesn't
matter.
I'm
just
trying
to
elaborate
that
you
know.
While
we
do
have
the
rules
to
help
avoid
certain
failure
cases
there's
also,
I
think,
other
cases
like
passing
in
an
options
type
to
a
constructor,
where
it's
really
hard
to
get
that
wrong
users
likely
aren't
going
to
be
taking
it
in
themselves,
they'll
be
creating
it
on
the
stack
right
before
calling
uri,
in
which
case
it's
very
cheap.
It's
very
free,
there's,
no
allocation
overhead,
etc.
I
Yeah
to
me
this
feels
like
it's,
it's
a
value
tuple
and
that
has
get
setters
right.
It's
just
a
little
bag
of
state
you're
passing
around
and
if
you
did
do
something
like
put
it
onto
you
know
onto
have
a
property
that
returns
from
a
class.
The
compiler
will
warn
you
if
you
try
and
set
fields
on
that
thing,
return
from
the
property-
I
don't
know
it
just.
It
doesn't
even
feel
like
the
scenario
you're
gonna.
The
99.999
percent
use
case
is
yours:
it's
gonna
be
new
uri,
blah,
comma
new
options,
settings
and
things.
J
I
G
Our
auto
props
gets
on
strucks
are
marked
with
only
implicitly.
G
B
These
would
not
be
auto
properties.
These
are
internally
managing
internal
flags
that
correspond
to
uri
flags
that
they're
used
internally.
I
I
F
C
A
A
G
H
There's
one
issue
about
existing
api
semantics
that
I
want
to
bring
up
here.
If
you
can
scroll
up
to
the
proposal.
H
The
last
line
well
the
first
line
above
api
usage.
It
says
the
get
components.
Api
will
ignore
the
uri
for
format
argument.
You
write
format
you
the
way
this
works
is
you
can
call
git
components
and
you
can
you
can
specify
what
kind
of
escaping
you
want
to
have.
So,
if
you
call
get
components
with
unescaped,
you'll
get
just
the
unescaped
uri
value.
If
you
call
it
with,
I
forget
what
the
exact
values
are.
There's
like
three
values,
but
it
will
do
different
kind
of
they're
right
here.
H
Uri
escaped
and
save
and
escape
will
do
different
kinds
of
escaping
of
the
values
of
the
in
the
uri,
specifically
in
the
path.
In
the
query,
these
arguments
don't
really
make
any
sense
for
a
raw
path
and
query
uri,
because
there's
already
stuff
that
we
haven't
canonicalized
within
the
uri.
So
the
question
is:
what
should
we
do
when
you
call
git
components
on
one
of
these
raw
uris
and
pass
in
these
values?
H
If
you
pass
an
unescaped,
you
probably
that's
you're,
basically
saying
you
know,
don't
change
anything
from
the
original
value,
so
that
seems
like
a
reasonable
thing
to
do.
But
if
you
pass
in
one
of
the
other
values,
you're
asking
for
at
least
some
kind
of
escaping
in
the
uri
in
the
resulting
in
the
string
that
you
get
back
from
get
components,
and
so
the
question
is:
should
we
should
we
just
ignore
those
values?
Should
we
throw
which,
which
seems
better
and
or.
G
K
A
Oh,
I
apparently
am
stuck
at
reading,
never
mind,
then.
Okay,.
A
B
For
the
get
components,
though,
we
just
mentioned
that
the
unescaped
may
also
do
some
transformation,
so
in
reality,
if
you
pass
this
flag
bra,
none
of
these
really
make
sense,
or
all
of
them
may
give
you
back
something
else
than
what
you
might
expect.
So
even
an
escaped
wouldn't
be
any
better
than
the
others.
K
A
A
Which
is
fine,
I
mean
another
option.
Is
that
I'm
not
sure
this
components
give
you
something
that
you
otherwise
wouldn't
get,
because
then
you
could
also
imagine
adding
an
enum
value
or
you
could
just
say
uri
format,
raw
right
and
then
say.
That's
the
only
thing
you
can
call
this
api
for
when
you
construct
the
uri
with
dangers,
use
raw
path
and
query.
E
B
H
G
G
That's
true,
as
long
as
we.
B
A
F
To
get
the
default
absolute,
you
are
kind
behavior,
you're,
suggesting
that
there
would
be
like
some
private
field
that
the
setter
would
set.
So
you
know
whether
your
kind
has
like
actually
been
modified,
or
if
it's
been
explicitly
set
to
relative
or
absolute.
I
just
wanted
to
know
what
the
mechanism
was.
I
We
can
shift
the
values,
so
we
don't
have
to
we,
we
can
have
it
store,
just
uri
kind
as
an
integer,
and
that
you
know
an
into
zero
doesn't
mean
you
are
I
kind
of
zero.
It
means
you
are,
I
kind
plus
one
or
whatever,
like
we
do
the
mapping
from
the
integer
value.
However,
we
want
to
the
uri
kind,
such.
A
Yeah,
I
mean
your
explanation
made
sense
to
me.
I
mean
I
originally
like
at
the
same
everything
to
jeremy,
but
then
yeah.
If,
if
you
only
do
it
for
part
of
the
uri,
it
makes
sense
to
me
to
explain
which
part
it
applies
to
and
path
inquiry
seems
to
be
the
canonical
way
how
it's
called
in
your
eyes.
So
it
seems
fine
to
me.
H
I
I
D
Yeah
we
we
discussed
earlier
the
possibility
of
like
injecting
new
lines
and
doing
request
line
and
header
splitting,
for
instance,.
K
E
A
C
Yeah
sorry,
I
was
saying:
can
you
scroll
down
to
my
last
comment
here.
C
Very
scroll
up
just
had
some
discussion
with
community,
but
that's
not
related
to
down
this
one
here,
so
I
just
had
the
like
smaller
div,
and
this
is
just
a
couple
of
additions
to
the
the
methods
that
the
first
generated
code
for
json
will
call
so.
C
First
off
we
have
this
serialized
method,
which
contains
like
serialized
logic
using
the
writer
directly.
So
we
had
a
couple
open
questions
about
this
before,
namely
you
know.
Is
this
a
method
that
users
should
call
directly
and
do
we
need
to
provide
some
guidance
around
when
it
can
be
known
and
like
what
are
the
expected
semantics?
C
So
I
had
we
had
an
opportunity
to
think
about
this
a
bit
more,
so
I
proposed
to
consider
this
as
apis
that
the
search
generator
calls
directly,
which
is
why
it
needs
to
be
public
and
the
source
generator
implementation
knows
like
we
need
to
be
null
or
not,
based
on
the
features
that
are
supported
for
like
fastback
civilization,
so
it's
still
public,
meaning
that
users
can
call
it.
But
we
should
provide
documentation,
saying
that
they
should
pass
an
actual
adjacent
typing
for
t
to
series
directly
for
correct
semantics.
C
Around
exception
handling
around
json
paths
around
writer
flushing,
and
then
this
should
be
considered
like
lower
like
level
api
for
the
social
intercode
code
called
directly.
So
the
entry
point
of
all
of
this
would
be
the
serializer,
and
you
know
if
you
absolutely
know
what
you're
doing
around
like
what
features
are
supported
or
not.
You
could
call
it
directly,
but
anybody
that
would
call
this
should
should
do
no
check
for
sure,
because
you
know
it's
knowledgeable
and
yeah.
C
It
just
requires
some
understanding
of
you
know
what
what
is
supported
in
first
part
versus
not
so
some
so
for
consistency
with
the
rest
of
the
serialized,
like
methods
that
we
have
on
the
types
that
are
used
by
the
switch
generator.
A
proposed
name
name
this
to
serialize
handler.
So
that's
similar.
We
have
another
type,
called
json
object
of
t
and
json
collection
of
t.
So
those
are
just
like
you
know,
funks
that
contain
logic
to
serialize
objects
and
collections,
and
things
like
that.
So
that's
the
first
thing
then
moving.
C
I
mean:
are
there
any
questions
right
now
about
that?
One
before
I
move
on
to
the
second
class
here.
C
Cool
and
then
just
want
to
add
a
few
more
converters
that
the
social
network
can
call
to
handle
the
nodes
types.
So
that's
the
stuff
we
shipped
in
system,
textures
and
nodes,
so
just
providing
support
for
that
scenario.
C
So
you
know
users
can
pass
those
steps
to
series
directly
or
they
might
be
contained
in
object
graphs.
So
with
these
converters
were
able
to
provide
support.
So
that's
the
first
four
properties
here
and
then
the
last
one.
We
like
a
method
that
calls
the
built-in
get
unsupported
type
converter.
C
So
we
need
this
to
be
able
to
like
properly
disallow
certain
types
for
for
consistency
between
both,
like
you
know,
the
source
generated
serializer
and
the
reflection
on
the
serializer.
C
So
right
now
we
use
this
so
to
just
sell
our
types
like
date
only
and
time
only
so
yeah,
it's
just
a
simple
method
that
just
gets
an
instance
of
that
type.
So
that's
pretty
much
it
for
purpose
changes.
Unless
there
are
any
questions
or
comments.
C
So
just
throws
a
not
supported
exception.
It
gives
a
generic.
A
C
Saying
that
you
know
this
type
is
not
supported,
we
could
extend
the
message
for
like
concrete
reasons
like
you
know,
a
security
or
just
for
you
know.
This
is
a
point
in
time
type
of
thing,
but
yeah
just
throws
the
north
of
the
exception,
so
meaning
that
if
you
have
a
type
that
we
create
this
converter,
for
we
have
a
runtime
exception
saying
the
type
is
not
supported.
L
C
L
A
follow-up
to
that
that
occurs
at
run
time
when
you
first
use
that,
given
type
if
you
have
your
own
custom
converter,
registered
that'll,
be
called,
of
course,
and
the
exception
won't
occur.
A
C
If
I
type
that
we
absolutely
like
to
not
support
for
serialization,
like
multi-dimensional
array,
we
have
different
behavior.
There
will
just
log
a
compile-time
error,
because
and
why
why
an
error
makes
sense.
There
is
because
you've
explicitly
indicated
that
type
of
serialization
and
we
don't
support
it.
I
think
that's
about
the
only
case
where
we
do
something
like
that.
Everything
else
that
is
not
supported
by
serializer
will
be
treated
by
objects.
A
C
Yeah,
so
you
know
that
was
all
we
had.
We
had
a
previous
discussion
with
like
more
changes
and
general
feedback
was
just
do
some
renamed,
so
we
implemented
those
changes
already.
So
this
is
pretty
much
all.
I
had.
A
C
I
see
so
for
for
the
converters,
they're
all
consistently
called
get
gets
x,
converter
or
cases
where
it's.
A
C
Yeah,
so
the
other
stuff
is
creating
metadata
classes
like
json
property
info
and
just
in
type
14..
A
I
see
I
see,
I
see
they're,
all
converters
is
what
you're
saying
I
see
so
only
the
I
see
the
converters
are
all
get
and
then
the
metadata
infos
are
all
or
the
type
infos
all
create.
B
C
Consistent
that
way
that
works,
maybe,
okay,
we
could
yeah.
I
think
this
is
fine.
A
All
right,
then,
unless
somebody
has
something
else
to
say,
I
would
say
that
looks
good
as
proposed.
A
A
A
Alrighty
so
then
I
guess
we
have
a
few
minutes
left
to
do
other
stuff
unexplained
unexplainedly.
I
guess
we
should
have
some
people
on
the
call
to
answer
these,
or
did
people
drop
off?
I'm
still.
J
Okay,
all
right
so
for
this
one,
there's
people
who
try
and
use
vector
two
vector
three
vector
four
in
hash
tables,
sometimes
because
functionally
it's
similar
to
a
two
three
or
four
dimensional
point,
and
so
they
may
just
want
to
create
a
hash
set
of
those
right
for
various
reasons,
because
it's
a
struck
comprised
of
float
fields.
J
This
is
the
same
general
problem
that
exists
for
float
itself,
which
is
that
the
equals
operator
is
not
the
same
as
the
equals
method
or
shouldn't
be
due
to
due
to
how
nands
compare
vector,
2,
3
and
4
today
do
not
actually
respect
this.
They
just
call
the
the
equals
operator,
and
so
you
can
have
two
things
with
equal
hashes,
which
won't
compare,
which
will
never
compare
equal,
even
if
they
are
the
same
object,
so
you
can
basically
corrupt
your
hash
set.
J
I
J
No,
you
can,
you
can
have
an
object
that
will
never
be
hittable
in
the
hash
table,
because
it
will
never
compare
equal
to
itself.
Okay
yeah
so
like.
If,
if
you
create
a
vector
two
with
any
nan
in
it
and
you
put
in
a
hash
set,
the
hash
code
you
get
returned
will
always
be
correct,
even
accounting
for
even
accounting
for
nands.
However,
when
you
go
and
try
and
compare
and
say,
is
the
actual
object
equal
because
the
hash
equals
it
will
never
return.
True,
because
fans
never
equal
themselves.
A
Yeah
I
mean
I
mean
to
me:
it
makes
sense
it's
one
of
those
things
that
always
annoy
me.
It's
like
things
should
be
equal
to
itself.
I
hate
these
semantics
that,
like
null,
has,
for
example
or
db
null,
has
that
never
compares
to
itself
and
what
you're
saying
is
that
with
floats?
If
you
use
double
equals,
you
get
one
behavior.
If
you
use
dot
equals
you
get
a
different
behavior
on
float
today,.
A
J
J
I
I
think
the
biggest
risk
for
breaking
someone
here
is
not
necessarily
on
the
semantics,
but
instead
on
the
this
is
going
to
regress.
Perf
for
dot
equals,
probably
about
2x,
because
we
have
to.
We
have
to
do
an
additional
comparison
and
then
merge
them
both
together.
It's
still
going
to
be
completely
cmd
and
vectorized.
So
it's
not
going
to
be
like
terrible,
but
if
people
are
using
dot
equals
instead
of
operator
equals,
they
will
see
a
perfect.
A
I
guess
that's
my
question
like
like:
if
people
use
it
as
a
numerical
type,
normally
I
don't
think
they
do
dot
equals,
but
it
would
probably
use
double
equals
right
and
so
people
that
actually
use
equals,
or
probably
people
that
do
put
it
in
you
know
as
keys
and
dictionaries
or
you
have
it
in
a
collection
and
ask
for
contains
or
something
right
would
be.
My
guess.
J
That
that's
my
guess
as
well.
I
just
wanted
to
call
out
that
there
will
be
some
subset
of
users
that
may
complain
because,
for
whatever
reason
they
use,
I
equatable
or
or
yeah
or
whatnot,.
J
D
Sure,
out
of
curiosity,
I
think,
doesn't
the
jit
actually
automatically
create
equals
implementations
for
various
structs
and
doesn't
it
defer
to
the
dot
equals
methods?
So
if,
if
we
were
to
not
declare
dot
equals
at
all
for
vector
2
things
would
have
just
worked
correct.
D
I
I
thought
that
it
was
all
code
gend
as
needed,
but
I
I
don't
know.
A
D
Do
we
so
there
was
mention
in
this
issue
of
having
an
analyzer
for
vector
2?
If,
if
we
weren't
going
to
take
the
change
here,
I
wonder
if
it
would
be
worthwhile
to
have
an
analyzer
more
generally,
that
says
you
are
implementing
an
equals
method
and
you're
doing
an
equals,
equals
comparison
of
a
floating
point
value.
Is
this
really
what
you
intended.
A
J
J
I
Yeah,
so
for
net
seven,
we're
adding
a
source
generator
for
regular
expressions
that
effectively
outputs
that
c
sharp
build
time.
The
same
thing
you'd
get
in
with
dynamic
reflection
emit
at
run
time.
If
you
use
regex
options
not
compiled,
there
are
a
variety
of
ways.
We
could
expose
this.
The
current
plan,
which
we
could
obviously
evolve
before
we
ship
that
n7,
is
to
have
a
method
that
returns
a
regex
and
put
an
attribute
on
it.
That
takes
the
regex
pattern,
options
and
timeout,
exactly
as
you
pass
otherwise
to
the
regex
constructor.
I
So
you
end
up
basically
declaring
a
factory
method
attributed
appropriately
and
then
you
can
use
that
method
to
get
your
regex
instead
of
using
the
regex
constructor,
assuming
we
actually
end
up
shipping
that
path.
We
need
that
attribute
so
just
just
like
with
the
with
the
json
source
generator,
and
so
this
would
be
that
attribute.
I
That's
pretty
straightforward!
It's
exactly
what
I
said
just
the
same.
It
basically
has
the
same
constructors
that
regex
does
now.
Obviously,
we
could
choose
to
change
our
approach
before
we
ship,
in
which
case
we'd
rip
it
out,
buys
it,
but
but
that's
the
current
one.
D
D
I
Absolute
worst
case,
which
is
what
my
my
current
implementation
does,
is
it
just
emits
an
implementation
that
cash
that
basically
returns
new
regex
effectively
so
worst
cases?
We
could
do
that.
The
alternative
is
in
such
a
situation
where
it
couldn't
be
supported
with,
but
either.
J
D
I
I
It'll
it'll
either
fail
because
the
c-sharp
compiler
can't
find
the
implementation
or
it'll
fail,
because
the
because
the
the
generator
issued
diagnostics
or
both.
I
Yeah,
that's
that's
what
happens
on.net
framework
if
you
use
regex.compile
to
assembly
it
basically
emits
into
your
which
is
effectively
what
this
is
just
as
part
of
the
build
you
it
basically
spits
out
into
the
assembly
a
type
derived
from
regex.
I
That's
also
what
happens
with
regex
options.compiled,
effectively,
there's
internal
to
system
text,
regular
expressions,
there's
a
type
derived
from
regex
that
accepts
two
delegates
and
the
this.
The
regex
options.compile
basically
manufactures
those
two
delegates
and
then
constructs
that
drive
type
and
the
source
generator.
Does
the
exact
same
thing.
It
spits
out
a
custom
derived
type
into
the
assembly.
A
G
I
Works
and
then-
and
then
there
are,
there-
are
abstract
methods
on
regex
runner.
So
the
the
way
it's
designed
for
whatever
reason
regex
has
a
protected
field
on
it.
That
is
a
regex
runner
factory,
the
regex
runner
factory.
It
gives
you
back
a
runner
and
that
runner
has
three
abstract
methods:
okay,.
I
Unfortunately,
yes,
we
don't
currently
have
a
way
in
c
sharp
source
generators
to
create
unspeakable
names
you
know
so,
for
if,
for
example,
we
had
the
ability
to
create
method,
local
types,
then
we
could
embed
the
type
inside
the
partial
method
and
it
would
end
up
with
an
unspeakable
name.
At
the
moment
we
generate
a
name
that
you
probably
won't
type
you
know
accidentally,
but
if
you
were
to
figure
out
the
the
pattern
that's
used,
you
could
speak
it
and
we
would
say
please
don't
do
that.
I
G
Yeah
and
emo
the
api
catalog
doesn't
seem
to
list
protected
fields.
You
might
want
to
work
on
that.
G
I
Worked
this
way
since
dot
net
framework
1.1
or
whenever
it
was
that
compiled
to
assembly
was
introduced,
but
it's
also
one
of
the
reasons
why
we
can't
change
certain
aspects
of
the
implementation
of
regex,
because
those
implementation
details
like
using
a
hash
table
instead
of
a
dictionary
for
things,
are
end
up
being
surfaced
through
those
protected
fields.
D
I
Yeah,
so
the
answer
is
yes,
it
is
inconsistent
and
it
uses
erroneously
for
both
interpreted
and
compiled
data
from
the
current
culture
at
the
time
of
regex
construction
and
at
the
time
of
match,
and
you
can
end
up
with
weird
issues,
I
think
okay,
so
they're,
not
necessarily
consistent,
they're.
D
I
I
We
just
say
it
said
at
the
time
of
math
at
time
of
match,
but
that
has
implications
for
performance
because
now
you're
having
to
there
are
things
that
you
can
do
based
on
culture
at
kind
of
compile
time
that
you
now
would
have
to
do
at
runtime.
I
I
D
I
We
could
do
that
the
we
could
do
that
in
one
of
two
ways:
either
you
know
throw
if
you
don't
specify
culture
and
variant,
regex,
options.culture,
invariant
or
say,
regardless
of
whether
you
specify
a
culture
and
variant.
You
get
culture
and
variant.
I
right
now
my
implementation
does
exactly
what
regex
option
stock
compile.
Does
it
just?
Does
it
at
build
time,
so
you're
gonna
get
potentially
strange
behavior
I
mean
if
you're,
you
know,
if
you're
building
in
enus
you're
going
to.
I
You're
building
an
frfr
you're
going
to
get
french
you
know
or
if
you're
building
in
turkey
and
you're
running
in
the
u.s.
Weird
things
are
going
to
happen,
so
we
can.
We
can
figure
that
out.
There's.
Definitely
some
open
issues
here:
hey
both
for
the
current
implementation
and
for
the
sorcerer.
D
Okay,
yeah,
I
mean
this
seems
this
seems
fine
to
me
match
timeout.
What
is
if,
if
someone
doesn't
specify
a
match,
timeout
in
the
attribute,
do
you
hard
code
a
default
or
do
you
pull
it
ambiently
from
the
environment
at
runtime,
right.
I
Now
well
so
it's
an
interesting
question,
so
the
compilation
hard
codes,
whether
there
was
a
timeout
or
not,
and
it
generates
more
efficient
code
if
there
was
no
timeout.
So
currently
what
happens
is
it
will?
I
It
will
generate
the
code
based
on
whether
there
is
a
timeout
or
not,
and
it
doesn't
pay
attention
to
any
ambient
settings.
We
could
change.
D
D
I
Well,
let
me
you
mean,
reject
option
regex
not
compiled
to
assembly.
Yes,
I
am
actually
I
take
that
back.
I
think
regex.compile
to
assembly.
I
It
actually
spits
out
a
public
type,
that
it
expects
you
to
use
and
you're
just
calling
the
regex
constructor
yourself
so
you're
gonna
and
it
generates
a
constructor
that
takes
a
timeout
okay,
whereas
this
is
just
giving
you
back
the
already
constructed
projects.
I
Now
we
could
we
could
you
know
we
have
lots
of
flexibility
in
how
we
want
to
do
this.
We
could
have
it
check.
There
is
a
there's,
a
static,
regex,
dot
default
timeout,
or
something
like
that.
I
That
you
know
we
could
have
that
consulted
at
match
time.
That
adds
some
expense,
but
we
could
do
it
if
we
think
that's
the
right
thing
to
do,
but
that
would
also
require
the
implementation
to
generate
code
that
always
accommodates
the
timeout.
It's
a
choice
we
could
make.
I
I
These
are
also
you
know
from
an
api
perspective.
I,
unless
you
were
saying
you
would
want
to
remove
the
match
timeout
from
here
altogether,
and
it
would
just
always
just
respect
a
global
thing
which
I
don't
think
we
want
to
do.
I
don't
think
this
would
have
an
impact
on
the
api.
No.
D
I
Yeah
this
will
this
will
use
the
default
at
the
time
of
build
okay,
but
you
know
we
could
make
it
use
the
default
at
the
time
of
match.
But
that's
you
know-
and
this
is
all
just
tweaks-
that
we
can
make
to
the
generated
code.
D
And
that's
fine
like
it
it
as
long
as
you
know
it's
under
consideration.
That's
really
all
I
wanted
to
to
poke
out
the
actual
implementation
of
it
like
we
can
figure
it
out.
I
G
G
That's
good
yeah.
So
then
the
other
only
other
feedback
that
I
have
on
it
is.
I
assume
it's
milliseconds,
so
maybe
we
want
to
call
it.
I
guess
the
problem:
if
we
call
it
timeout
milliseconds,
it
was
like
the
generator's
timeout
so
match
time
at
milliseconds
feels
really
long.
I
don't
know
it.
A
J
A
I
just
said
seven
six,
but
I
meant
seven
all
right
so
then
I
think
this
one
looks
good
as
proposed
and
I
think
I'm
fine
with
the
name.
I
The
only
other
question
I
had
was,
I
made
the
property
match:
timeout
getter
match
the
type
and
name
of
the
parameter,
so
I'm
assuming
we'd
want
to
make
this
match
timeout
milliseconds,
unless
we
actually
wanted
to
make
the
property
return
a
time
span.
I
don't
know
if
we
have
guidelines
for
that.
G
G
I
G
G
D
Can
we
can
we
also
look
at
what
I
pasted
in
chat
just
now,
five,
eight,
nine,
nine
four:
it
it
goes
hand
in
hand
with
the
regex
generator
attribute.
D
Is
is
this
something
that
we
would
want
to
consider
at
the
same
time?
I
know
this
isn't
marked
api
ready
for
review,
but
the
regex
generator
attribute,
I
think,
is
kind
of
forcing
the
issue
here.
D
What
this
is
saying
is
it's
an
attribute
that
you
put
on
an
attribute,
that's
responsible
for
cogeneration,
and
it's
used
by,
for
instance,
the
build
system
to
say:
hey,
don't
put
the
regex,
don't
put
the
regex
code
gen
attribute
in
the
final
product,
because
no
one's
going
to
be
looking
for
it
anymore.
D
I
I
We
do
this
by
just
telling
the
trimmer
to
turn
out
certain
prop
parameter
attributes
or
it's
a
conversation
with
the
c-sharp
team,
because
it's
c-sharp
that
would
that
controls,
whether
it's
emitted
or
not.
Okay,.
A
D
Yeah,
if
there's,
if,
if
this
is
generally
seen
by
the
group
as
something
worth
pursuing
kind
of
in
general,
then
you
know
one
of
us
should
probably
at
least
start
driving
this
again.
Just
because
it
seems
like
it
goes
hand
in
hand
with
what
we
just
discussed.
I
Yeah
and
we've
had
conversations
for
I
think
years
now
about
the
source,
only
attributes,
which
is
a
effectively.
This
is
saying
this
is
describing
that
capability.
G
H
D
Awesome
and
steve
you
said
you
were
actually
ready
to
check
in
already
not
I
mean
I
saw
some
bugs,
but
I'm
working
those
out
you
can.
You
can
just
say
that
those
are
bugs
in
regex
and
not
your
own
code.
I
No
they're,
definitely
in
my
own
code,
I've
been
staring
for
an
hour
line
by
line
eye
versus
c-sharp,
to
figure
out
what
I,
what
what
I
fingered.