►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
B
So
I
did
some
amount
of
work.
You
know
in
the
last
year,
two
year
frame
to
try
and
improve
performance
and
wind
forums
on
drawing
part
of
that
was
making
some
changes
to
system
drying
internally.
The
other
ones
are,
you
know,
looking
through
the
paint
loops,
in
particular
for.
A
B
Wind
forms
and
one
of
the
things
that
that
shows
up
a
ton
is
this
get
context
info.
B
You
know
we
have
to
you
know,
because
winforms
was
originally
totally
system
drawing
in
gdi
plus
and
in
2.0
they
tried
to
move
as
much
as
they
could
to
gdi,
because
you
know
gdi
plus
has
performance
implications,
and
this
thing
was
part
of
that
and
it's
a
way
to
apply
the
well
translation,
transform
and
also
the
clipping
that
are
layered
on
top
of
the
underlying
hdc
in
a
graphics
object.
B
B
As
you
see,
it
returns
an
object
that
object
is
actually
an
array
of
a
region
and
a
matrix,
and
that's
not
great
we're
allocating
allocating
an
array.
Every
time
we
try
to
paint
anything
that
shows
up
a
ton.
You
know
in
a
larger
windform
thing,
so
one
aspect
of
this
is
just
simply
providing
a
way
to
get
it
out
without,
like
sticking
them
in
an
object
array.
B
The
other
thing
is
a
change
in
behavior
and
that's
to
track
internally,
whether
the
clip
or
the
or
the
transformer
ever
set
by
the
end
user,
so
that
the
complicated
logic
it
has
to
do
internally
and
there's
some
allocations
along
that
as
well,
that
it
can
skip
out
on
some
of
those
things
if
we
know
that
the
that
the
thing
is
in
a
clean
state,
basically,
so
both
of
those
things
will
cut
out
a
lot
of
allocations
for
redraws
and
wind
forms.
A
B
Change
here,
as
we
document
what
this
does,
but
it's
conceivable
that
other
people
would
want
to
do
the
same
pattern
I
mean
if
we
do
it,
why?
Wouldn't
they
you
know
so
because
there
there
is
no
way
currently
in
the
api
surface,
to
get
this
thing,
that
you
can
save
state
with
a
graphics
object
and
it
builds
a
stack
internally.
B
A
A
B
B
A
B
A
B
So
I
would
presume
that's
what
they
were
trying
to
do
is
kind
of
leave
it
sort
of
open-ended.
There
is
really
nothing
else
that
you
can
apply
the
one
one
thing
we
might
end
up
doing
in
the
future,
but
I
I
sort
of
doubt
it
is
actually
returning
the
full
transform
instead
of
just
the
offset,
but
we're
so
baked
into
just
doing
the
the
the
just
applying
the
the
offset
that
I
I
doubt
that
we
would
ever
do
that.
So
that's
probably
the
only
thing
we
would
ever
do
is.
B
We
might
have
a
third.
You
know
another
overload
where
we'd
add
one
more
thing,
because
it's,
though
those
two
pieces,
so
the
the
underlying
thing
is
not
that
point
up.
That's
an
optimization,
you
know
it's
a
matrix
class,
but
we
have
ways
to
avoid
creating
that
class.
Internally
right,
we
can,
you
know,
get
the
native
object,
get
the
stuff
out
of
it
and
then
free
it.
You
know
the
the
gdi
plus
thing
to
avoid
creating
a.net
thing
around
it
right,
a
dynamic.
B
The
the
matrix,
the
only
thing
we're
turning
in
it
is
the
is
the
actual
offset
pieces.
So
everything
else
in
it
is
zero,
okay
or
identity,
and
even
in
any
place,
this
thing
is
called.
We
would
just
get
those
two,
those
two
well,
that's
all
we
put
in
it.
That's
the
only
thing
we
ever
get
out,
so
it's
it's
possible.
We
might
want
to
return
the
other
ones.
B
I
actually
have
another
api
proposal
up
about,
like
potentially
taking
taking
a
dependency
on
system
numerics
in
here
to
allow
us
to
pass
data
around
without
passing
with
classes,
because
it's
very
heavyweight-
and
I
have
another
proposal-
that's
that
still
needs
to
be
checked
off
on
that.
We'll
actually
fix
some
of
that
too,
because
like
if
you
want
to
do
transforms
and
everything
with
with
system
drawing
you.
B
Class
so-
and
you
know
that
that
thing
you
have
to
like
it-
gets
copied
over
and
applied
right,
you
don't
actually
just
get
a
set
of.
You
know
a
struct.
There
is
no
such
thing
as
as
far
as
gdi,
plus
its
internal
representation
is
a
glass.
It
has
a
bunch
of
stuff
on
it,
it's
kind
of
goopy
but
par
for
the
course
for
gi
plus
performance
stuff.
B
So,
yes,
we
might
want
to
to
go
out
a
little
bit
further
and
the
reason
why
I
have
the
offset
and
the
clip
there
and
not
just
the
clip
is
it's
because
the
in
order
to
get
the
clip
that
you
have
to
get
the
offset
you
could
ignore
it
on
the
way
out,
like
you,
don't
really
want
to
use
the
offset,
but
you
know
calculating
the
clip
requires
calculating
the
offset.
B
Region
is
another
class,
and
it's
it's
really
expensive,
so
we
can
just
you
know
we
can
look
at
the
internal
native
handle
to
go,
get
all
the
the
the
make
the
transform
matrix
stuff
and
never
create
any
dot
net
objects.
E
Just
an
implementation
question
here:
it
looks
like
system
drawing
graphics
unix
for
get
context.
Info
currently
throws
not
implemented
with
a
comment
that
the
only
known
source
of
information
is
some
blog
post
that
doesn't
exist
anymore,
I'm
guessing.
This
is
because
mono
wrote
most
of
the
unix
implementation
originally
and
we
hadn't
shared
that
source.
B
Yeah,
there's
no
reason
not
to
okay.
Well,
I
don't
know
yeah,
I'm
pretty
sure
that
the
unix
one
has
the
same
state
on
it
as
well.
It's
like
when
they
when
they
wrote
this
stuff.
Of
course,
they
didn't
have
access
to
anything
other
than
this
was
in
her
internally
zone
right
so
and
our
implementation
is
simply
a
copy
of
that
a
basis.
Well,
it
started
with
that.
F
A
F
A
E
B
C
B
B
Matrix
times
the
point
yeah
it's
yes,
it's
just
an
identity,
major
identity,
matrix
with
the
with
the
just
the
transform
the
transport
pieces.
What
is
the
I
forget
which
which
part
of
the
matrix?
That
is
it's
a
it's
like
the
fourth
and
fifth.
A
C
A
The
I
I
mean
it
was
always
editor
possible,
at
least
since
the
framework
1x.
So
I
I
mean,
I
think
the
chance
of
somebody
calling
it
is
super
low.
So,
honestly,
I'm
kind
of
okay
with
just
marking
it
as
obsolete,
no
diagnostic
id
and
then
just
say
you
know,
use
the
overload.
A
C
A
C
G
C
C
C
C
E
A
It
probably
did
because
cpu,
like
here's,
the
here's,
the
fun
thing,
a
quarter
of
my
cpu
right
now
does
anti-malware.
I
don't
know
what
the
is
going
on
on
my
machine,
but
that's
just
windows
for
you.
I
guess
it's
grooming
itself
just
in
case,
so
I
think
there
were
some
other
issues
that
jeremy
filed,
which
I'm
wondering
whether
we
should
look
at
now,
even
though
they're
not
on
the
list,
but
I
think
we
have
enough
time
today.
E
A
E
Marked
it
as
ready
for
review,
it
was
missed.
It's
4,
7,
9,
40.,.
A
So,
jeremy,
the
other
ones
that
are
marked
for
six
there's
one.
Let
me
actually
scroll
on
the
other
windows
at
least
the
people
on
the
internet
can
see
it.
A
E
B
Yeah
now
the
other,
the
other
one
is
three:
nine,
four
zero,
six
yeah,
that's
the
other
one
that
I
just
had
open.
A
So
then,
let's
do
the
four
three
three
eight
one
first
add
idevice
context
overload
to
control
pane.
B
B
So
you
know
we
there
there
is
one
already
so
control
paint.
B
So
there's
there's
there's
text
renderer
and
control
paint,
and
you
know
these
are
two
of
the
main
helper
classes
that
allow
you
to
compose
controls
right.
So
let
you
drop
orders
and
3d
borders
and
buttons
and
grab
handles
and
menu
glyphs
all
this
sort
of
stuff.
B
You
know
on
a
few
of
them.
We
already
have
one
that
takes
an
idevice
context
instead
of
the
graphics,
and
we
have
like
text
renderer,
the
more
modern
ones
that
we
have,
which
that
one
came
out
later
just
takes.
I
device
context.
B
These
will
apply
if
you
pass
in
a
graphics
object
as
your
I
device
context,
these
will
apply
the
via
the
api.
We
just
saw
the
the
transform
and
the
clip,
but
that's
really
about
all.
There
is
to
it
and
oh
one,
other
small
detail
is
listed
in
there
as
well,
because
you
know
there
is
no
alpha
when
it
comes
to
gdi,
then
you
know
alpha's
ignored,
but
that's
that's
what
we
do
everywhere
or
we
take
idevice
context
in.
B
No,
no
they're
just
ignored
it
dropped,
so
the
you
you
can
deal
with
that
yourself
if
you
want
to
like
buck
the
other
existing
pattern,
but
this
fits
into
the
whole
thing
where
we
have
the
the
pattern
here.
That's
new
is
that
I
got
we
added
eye
device
context
to
the
paint
event
args,
because
you
know
your
normal
painting
cycle
is
for
a
winforms
app.
Is
that
you
get
a
paint
event
right?
You
know
you
do
on
paint
right.
B
You
override
that
or
you
you
hook
the
hook,
the
event
for
paint
and
you
get
this
paint
of
analogs
and
you
know
historically,
you
just
use
the
graphics
object
on
it,
but,
like
now
that
we
have
an
I
device
context
on
it,
you
know
we
can
avoid
creating
a
graphics
object
to
draw
around
it.
You
can
just
pass
the
pain
and
that
args
into
to
the
overloads
that
you
were
doing
before
and
it's
a
fairly
straightforward
translation
for
most
things.
B
There's
slight
changes
in
behavior.
If
you
were
taking
advantage
of
things,
you
know
that
you
can.
You
can't
go
there
if
you're
trying
to
use
transparency
or
things
like
that,
but
but
that's
true
for
any
of
the
idolized
context,
things
that
we
have,
but
for
normal
situations
when
you're
just
drawing
simple
things,
it's
much
much
faster
to
avoid
creating
the
graphics
object,
which
is
super
heavyweight.
B
A
B
C
I
was
gonna
say
assuming
that
all
of
the
parameters
other
than
the
first
parameter
are
named
identical
to
what
they
are
in
the
existing
overloads
that
it
seems
fine
to
me.
A
So
then,
another
question
I
think
I
asked
this
last
time,
which
is
kind
of
like.
Are
we
now
effectively
saying
I
device
context,
is
an
overload
to
graphics
in
pretty
much
every
api,
because
I
think
there's
like
a
a
ton
of
apis,
detect,
graphics
right
or
is
this.
B
Well,
for
these
support
ones,
you
know
the
other
ones
are
all
just
the
on
and
event
stuff
and
that's
that's
you're,
getting
the
graphics
embedded
in
an
event
arc,
so
yeah
effectively
you're
getting
I
device
context
everywhere.
Now.
E
C
B
B
A
I
marked
it
as
approved
I
painted
I
I
know
I
painted
I
pasted
in
the
apis.
You
can't
see
it
probably
because
teams
is
being
teams
today.
So
then
we
have
these
two
covers
and
I
think
the
next
one
is
in
the
runtime
repo
again,
that
was
the
exposed
system,
drawing
graphics
native
graphics,
which
is
3946.
C
Yep
for
anyone
who's
on
teams,
I
am
trying
to
stream
the
youtube
which
is
on
a
delay
through
the
teams.
Are
people
seeing
that
and
is
it
useful?
Yes,.
C
C
B
This
one
is
just
exposing
the
ability
to
look
at
the
the
native
handle
and
giving
you
the
ability
to
construct
from
the
nato
candle.
We
have
this
for
icon
icons,
a
little
odd
in
the
fact
that
it's
not
gdi,
plus,
it's
the
one
thing
in
system
drawing
that's
gdi,
but
the
following
the
same
pattern
for
that.
This
is
very
useful
for
the
ability
to
do
optimizations
or
interop
with
native
code
that
happens
to
be
using
gdi
plus
in
some
form
or
another.
B
You
know
there
are.
There
are
optimizations
that
we
can
be
doing,
particularly
in
winforms,
where
we
can.
You
know,
basically
develop
the
pattern
and
then,
potentially,
you
know,
evolve
some
of
those
things
into.
You
know
full-fledged
system
drawing
api
changes
around
performance
bottlenecks.
F
B
To
go
straight
up
and
straight
at
the
native
api
for
something
that
doesn't
have
a
an
optimal
system,
drawing
exposure
for
it.
C
We're
calling
everything
handle
here
is
that
what
they're
called
like.
B
A
B
C
B
So
there
there
is
an
obligation
on
your
part
to
when
you're
going
at
the
native
handle
to
like
not
lose
your
containing
disposable,
that's
going
to
like
or
finalize
or
the
finalizable
object.
That's
going
to
close
it,
but.
B
I
don't
think
so
I
mean
winforms
also
predates
safe
handle.
I
believe
yeah.
A
B
No,
you
know
I
I
actually
internally
have
an
eye
handle,
because
he'll
use
that
to
to
identify
the
things
that
have
the
dot
handle
property
because,
like
in
our
in
our
p,
invokes
we.
We
use
that
to
just
you
know,
do
a
gc
keep
alive
on
on
the
object
and
then
do
a
dot
handle
and
be
invoked
to
be
a
little
bit
more
efficient
than
creating
a
handle.
Rough.
C
B
B
Yes,
so
it's
it's
incredibly
non-performant
that
if
you
want
to
do
matrix
stuff
that
you
have
to
deal
with
multiple
instances
of
finalizable
classes,
in
addition
to
which
you
know
it's
pretty
typical
for
people
to
forget
to
actually
dispose
of
these
because,
like
you
know,
you
do
a
property,
get
you
get
you
know
on.
You
know
you
do
dot
transform
you're
getting
this
matrix
class
right,
which
is
a
finalizable
object
that
you
need
to
dispose
and
most
people
don't
so
it
ends
up
on
the
finalizer
cube
the.
B
B
C
B
So
the
one
semi-odd
thing
about
this
is
that
we
would
be
taking
a
dependency
on
system
numerics,
which
is
in
box
now
and
has
been
some
free
one.
Is
that
correct,
tanner
yep?
So.
B
But
you
know
that
that's
the
one
thing
we
have.
That
is,
I
mean
it's
a
direct
one-to-one
relationship
with
the
internal
data,
so
there
is
actually
a
class
in
gdi
plus.
But
you
know
in
that
class
there
is
a
matrix
of
you
know
a
straightforward,
you
know
series
of
floats
and
they
have
apis
to
copy
that
in
and
out
so
with
these
patterns
here
we
would
never
create
the
class,
the
finalizable
glass,
if
you're
passing
in
those
other
things
we
would
use.
B
A
C
Yeah
and
eric
you
use
f
sharp,
does
that?
How
well
does
f
sharp
do
operators.
A
I
they.
A
E
A
C
Like
you
see
the
new,
but
you
know
new
doesn't
really
mean
new.
So
if,
if
you
you
know.
B
B
With
a
constructor
yeah,
I'm
happy
to
add
those,
I
mean
the
point
size
and
rectangle
thing
or
just
like.
If
we're
going
to
take
the
dependency
on
these
people
want
to
be
able
to
interrupt
a
little
easier
with
those
those
three,
those
those
are
just
struts,
of
course
too
well
yeah.
All
of
them
are
they're
direct
mapping
to
the
underlying
stuff,
so
yeah
anyway,
yeah
I
mean.
B
F
B
Yeah,
I
don't
know
why
they
didn't
put
a
setter
on
it
to
begin
with.
They
very
well
could
have
because
there
you
can
set
it
from
that
from
this
permanent
float
array.
So
I
have
no
idea
why
they
didn't
do
it.
I
I
presume
it
was
just
an
oversight,
but
I
don't
know
I
wasn't
going
to
add
one
for
that,
because
I
don't
want
to
encourage
people
to
use
that
anyway.
That's
like
expensive,
I
mean.
E
Four
matrix
in
particular,
should
there
also
be
here
a
get
elements
span,
basically
the
same
method
that
that
you
just
internally
added
but
for
users
who
want
to
just
get
the
elements
into
a
span
either
because
they've
got
their
own
custom
matrix
type
or
they
just
don't
want
to
use
matrix.
3X2
could
because
otherwise
they're
just
going
to
end
up
calling
matrix
elements
and
then
get
span
which
is
a
bit
of
unnecessary
overhead
or
they
they
can.
You
know,
play
unsafe.
B
Yeah,
I
I
I
you
know
if
we
didn't,
if
we
weren't
able
to
take
the
dependency,
I
would
have
had
this
thing
be
a
span
but
like
it's
a
little
bit
more
awkward
to
write
those,
it
doesn't
mean
that
we
can't,
I
just
didn't,
put
it
on
there,
think
we
want
it.
That's
fine.
C
E
Well,
system,
drawing
we,
we
spanified
all
of
the
vector
and
matrix
types
and
so
matrix
in
particular,
jeremy.
Just
put
up
a
pr
for
two
of
the
other
properties,
for
example,
that
are
exposed
on
matrix,
are
offset
x
and
offset
y
and
prior
to
jeremy's
change.
They
were
calling
elements
get
and
then
accessing
index
five
and
so
for
every
single
property
access.
You
would
be
allocating,
so
it
allocated
the
short
term
six
element
array.
E
It
allocated
a
native
memory
via
marshall,
alec,
h,
global
it
copied
the
memory
it
freed,
the
native
one,
and
then
the
the
offset
x
would
return
element.
Five,
which
puts
the
allocated
array
immediately
up
for
freeing
and
so
part
of
his
pr
fix
was
to
fix
that
by
ensuring
we
only
have
one
array
allocation,
but
also
exposing
an
internal
method
that
allocates
directly
to
a
span
that
way
we
could
for
offset
x
and
y
avoid
the
allocation.
E
This
would
be
just
making
that
new
method
that
we've
got
internal
now
public,
just
because
it
is
immensely
useful
for
cases
like
that.
C
Right,
like
it's,
our
other,
are
people
outside
the
library
really
using
the
elements
and
when
they
are
using
the
elements,
would
they
rather
have
the
structure
of
the
matrix
or
do
they
actually
want
it
as
the
flat
data,
and
I
know
that
some
people
who
are
using
matrix
want
the
flat
data,
but
it's
do
the
people
who
are
using
graphics,
want
the
matrix
or
the
flat
data,
and
if
they
don't
want
the
flat
data,
then
I
don't.
I
don't
see
a
reason
to
add
it.
I
mean
it.
C
So
that's
really
my
I
I'd
want
to
see
someone
who
wanted
to
use
it
before
we
said
like.
Oh,
let's
just
add
a
get
elements
and
public
in
to
get
elements
span
of
float,
which
returns
sex.
A
So
I
just
updated
the
api
spec
based
on
what
we
said
earlier,
so
just
want
to
get
back
to
the
constructors
in
the
conversion
method
for
a
second,
so
I
added
those
I
assume
that
it
looks
good
to
people
the
the
conversion.
A
E
Well,
I
was
going
to
say
just
from
the
perspective
of
two
vector
versus
two
vector
n.
We
should
likely
explicitly
use
vector
2
because
so
there's
two
reasons
here:
one
we're
going
to
be
exposing
the
new
generic
vector,
2,
3
and
4,
with
support,
float
and
double,
and
two
we
also
have
a
vector
of
t,
which
is
where
we
commonly
use
two
vector
to
mean.
Today.
We've
got
vector,
128,
vector,
64
and
vector
256
and
basically
everywhere,
except
for
vector
of
t.
We
explicitly
annotate
the
number
of
elements
or
the
number
of
bits.
A
E
C
C
A
Down
to
so
wind
farms,
we
do
tomorrow
and
then
I
think
now
we
have
the
the
link
one
from
eric.
I
believe.
G
Thanks,
jeremy,
hey,
so
this
is
the
I
promised
the
final
api
proposal
for
link
again
coming
from
the
community.
The
final.
G
So
again,
this
is
like
a
very
simple
proposal.
This
method
exists
in
other
link,
libraries
as
well,
I
believe
the
posters
have
mentioned
rust
and
I've
also
seen
this
in
sharp
too,
and
the
idea
is
basically
that,
given
an
input
enumerable
and
they
predicate
on
the
elements,
basically
return
a
tuple
that
contains
on
one
hand,
the
subset
of
elements
that
satisfy
the
predicate
and,
on
the
other
hand,
the
subset
of
elements
that
you
know
do
not
satisfy
the
predicate
so
essentially
you're.
G
Looking
at
a
variation
of
two
lookup.
If
you
scroll
down
a
bit,
you
might
see
like
the
actual
api.
G
Yeah,
I
see
it
so
basically
it
returns
a
couple
of
fully
materialized
collections,
which
is
why
the
return
type
is
a
read-only
list
instead
of
innumerable-
and
this
is
because
it's
basically
to
emphasize
that
this
is
not
a
deferred
calculation,
it
will
actually
run
the
enumeration
and
populate
the
two
collections
immediately.
C
Since
these
are
our
new
newly
created
read-only
lists
right,
why
isn't
it
just
I
list
and
then
I
can
modify
it
if
I
want
to.
G
I
mean
no
real
reason.
I
I
suppose,
echoing
how
to
look
up
works
or
how
group
I
works.
You
typically,
if
I'm
not
mistaken,
you
cannot
really
modify
these
outputs.
G
G
I
don't
have
any
strong
opinion
in
terms
of
whether
it
should
be
ilist
or
not.
Frankly,
I
read,
only
list
was
picked
almost
arbitrarily
and
it
was
primarily
intended
to.
You
know
clearly
communicate
the
fact
that
you
know
this
is
not
a
deferred
computation,
because
it
cannot
be
one.
G
C
If
this
is
going
to
be
implemented,
as
you
know,
returning
two
different
instances
of
list
of
t,
we
should
just
be
honest
in
the
return
type
and
let
people
own
the
object
when
it's
returned
so.
A
C
Does
anyone
have
opinions
on
the
names
I
feel
like
unsatisfied?
I
might
like
better
than
falsified,
because
falsified
feels
weird.
A
C
C
G
Yeah,
I
I
I
mean
match
them
on
match,
sounds
good
to
me
like
they.
They
are
pretty
self-explanatory
in
terms
of
what
each
of
them
means
so
yeah.
I
I
I
guess
I
should
mention
that
there
are
pretty
strong
counter
arguments
against
incorporating
this.
The
primary
counter
argument
is
that
two
lookup
can
be
used
very
effectively
to
achieve
the
exact
same
goal,
but
the
only
the
only
issue
with
that
is
you
know
theoretical
performance
concerns,
because
there
is
a
hash
table
involved
in
the
building
of
you
know
the
the
two
results.
G
So
so,
basically
I
I
think
somebody
actually
added
that
example
describing
how
this
could
be
done
with
to
look
up
if
people
are
interested,
but
you
know
in
practice
I
I
don't
think
it
would
provide
significantly
more
value.
G
G
It
will
it
will
evaluate
the
source
only
once
and
it
will
do
so
eagerly
as
soon
as
you
call
the
method.
So
this
is
not
a
deferred
execution.
Okay!
Oh
it's
returning
a
list.
I
see.
F
A
Very
high,
because
you
can
achieve
this
with
to
look
up
or
probably
also
group
by
if
you
wanted
to,
but
I
mean
what
this
one
is
different
here
in
the
sense
that
it
gives
you
a
back
mutable
objects
which
is
probably
more
useful
than
what
google
buyer
or
to
look
up
would
do
so
the
I
think
it
adds
some
video
and
it's
probably
also
said,
also
more
efficient.
So
if
you
really
need
the
scenario
I
can
buy,
why
you
want
this
api.
A
C
Like
the
group
buy
is
not
the
easiest
thing
in
the
world
to
work
with,
it
does
magic
like
group
by
and
sql,
but
that
doesn't
mean
it's
friendly
to
work
with.
So
I
I
think
it's
a
reasonable
utility
function.
G
Like
yeah
yeah
I
mean
it,
it
should
be.
F
C
It
is,
should
we
be
considering
that
there,
because,
like
just
looking
at
this
naively,
if
I
just
saw
a
partition
method,
it
wouldn't
necessarily
occur
to
me
that
oh,
this
is
going
to
materialize
a
bunch
of
stuff,
but
you
can't
the
fact
that
it's
returning
a
tuple
of
lists
means
you
can't
really
have
used
it
in
an
inline
expression
and
had
a
different
expectation.
Yeah.
C
A
Right
I
mean
I
would
normally
agree,
but
I
think
the
the
reason
we
do
this
is
because,
if
you
chain
them,
you
don't
realize
that
you're
inefficient.
If
that
makes
sense,
but
if
you
like,
for
example,
if
you
have
a
tour
rate
somewhere,
because
the
rate
also
is
innumerable
like
you,
you
just
waste
efficiency
right
versus
in
this
case,
you
can't
really
chain
this
guy,
because
it
gives
you
back
a
non-enumerable
type
right.
A
So
you
would
like,
even
if
you
didn't
know
it
like
your
code,
would
make
that
fairly
obvious,
because
what
I
mean
the
very
next
thing
you
would
have
to
do
after
partitioning
it
is
either
indexing
into
it,
not
indexing
property.
You
know
accessing
into
it
or
or
deconstructing
it
right.
That's
the
only
thing
you
can
do
with
this
method
right,
so
I
think
the
call
side
will
make
that
obvious.
If
you
like,
you
can't
really.
C
Mess
it
up
if
you're
deconstructing
with
var,
then
yeah,
it
could
look
like
maybe
you're
getting
two
unwalked
enumerables,
but
if
we
called
it
like
two
partition,
then
that
really
means
that
we
need
to
make
a
partition
type
to
return,
because
that's
usually
what
two
blank
means,
like
all
the
things
on
link
that
are
are
system.
Enumerable
that
are
that
are
manifesting,
are
always
saying.
I'm
returning
a
thing
of
this
type,
or
you
know
at
least
this
interface,
and
this
one
is
like
I'm,
I'm
I'm
verbing.
D
Usually,
when
I
have
a
collection-
and
I
hear
the
word
partitioning-
I
would
think
that
it
involves
maybe
running
over
it
in
parallel.
I
know
we
use
that
language
elsewhere.
I
think
in
like
parallel
four
or
something
like
that.
Is
there
a
less
ambiguous
name
we
can
think
of
for
this.
C
D
C
A
C
Materializing
as
I
go,
but
making
some
decision
as
I
go
and
doing
something
different
with
those
things
I
mean
we
could
call
it
evaluate
filter.
A
A
A
C
We
have
a
couple
properties
like
this
on
on
ip
address
already,
notably,
is
ipv6
site
local.
This
is
just
another
flag
like
that
certain
ipv6
addresses
or
certain
kind
of
special
addresses,
either
site,
local,
unique
local
that
have
certain
magic,
special
semantics
associated
with
them
and
are
a
reserved
range
of
addresses.
So
the
proposal
here
is
just
to
add
a.
C
A
A
A
All
right,
then,
let's
go
to
the
next
one.
This
would
be
four
six,
nine,
eight
eight
eight,
which
is
the
microsoft
extensions
configuration
app
binding,
which
I
think
is
probably
miriam.