►
Description
We'll be talking about
* Add file enumeration extensibility points (https://github.com/dotnet/corefx/issues/25873)
A
A
A
B
D
E
A
A
B
G
H
B
G
B
Side,
this
is
the
surface
area
that
we
actually
are
pretty
close
to
the
surface
area
that
we
actually
have
them
on
to
change
things
back
in
the
back
in
the
late
fall
to
do
this
based
on
investigations
were
coming
out
of
both
my
end
and
the
project
system
built
system
stuff
visual
studio
I
made
some
changes
on
the
desktop
side
to
dress
some
of
the
over
allocated.
This
was
the
more
fundamental
rewrite
that
I
did.
B
They're,
our
biggest
fundamental
performance
problem
right
now
is
that,
like
we
allocate
way
too
much
for
particularly
when
you
start
to
filter
out
and
things
that
you
don't
care
about,
so
which
you
know
and
build
scenarios
is
pretty
frequent
right.
You
know,
like
you,
want
to
look
for
just
c-sharp
files.
Well
right
now,
it's
really
hard
to
do
that
or
look
more
worse.
You
want
to
look
for
a
set
of
inputs
right.
You
don't
look
for
all
like
C++
files
right.
B
You
know
that
our
source
files,
you
know
to
be
able
to
do
that
on
the
front
end,
and
it's
very,
it's
not
possible
all
right,
so
Univ
allocating
a
ton
of
strings
like
when
you
may
not
want
anything
from
that.
Sarah
I
think
it's
one
of
the
examples.
I
gave
get
a
full
bath
with
an
extension,
with
a
set
of
exceptions
right
and
that's
a
fairly
simple
example,
but
like
this
is
fully
extensible
to
the
point
where
you
can
actually
go
in
and
like
keep.
There's
a
state
object
that
you
pass
through.
B
B
D
B
D
B
Is
meant
it's
paid
to
play?
Yes,
it
is
performance,
oriented
and
as
such
like
there
is
some
the
it
allows
you
to
get
at
the
the
lower
level
data
using
span.
So
it's
leveraging
span
and
in
order
to
keep
the
allocations
from
happening,
we
have
to
pass
stuff
by
ref.
So
there's
a
little
bit
of
contortions.
We
have
to
do
they
make
the
API
not
as
pretty
as
it
would
be
if
we
didn't
care
so
much
about
the
allocations
that
are
happening.
Some
of
the
api
s--
every
10
chains,
guess
which.
B
You
know,
as
we
my
hope
with
this
is
that,
like,
as
people
can
like,
we
have
more
work
that
we
can
do
ourselves,
providing
the
higher
level
easy
abstractions
on
things,
but
like
the
hope,
is
that,
like,
as
people
are
building
solutions
around
this
as
well,
that
through
the
community
we'll
see
where
the
common
patterns
are
coming
up
instead
of
trying
to
second-guess
them
like,
for
example,
like
you
might
think
right
now
that
like
getting,
I
just
want
the
file
right.
I
don't
want
the
full
path,
don't
get
the
whole
string.
B
I
just
want
all
the
file
names
in
this
directory.
That
seems
like
it
would
be
a
pretty
common
scenario,
but
that's
still
guessing
on
our
part
right,
but
you
can
do
that
now.
You
can
say
like
well
look.
I
don't
need
to
combine
the
path
together.
I
want
the
two
pieces
separate
because
I
may
do
additional
things
or
I
may
not
even
care
right.
So
you.
B
B
I
I
A
To
say,
like
I
mean,
though,
one
of
the
problems
that
we
have
is
that
if
you
look
at
this
code
here
right
so
let's
say
we
would
have
just
filtered
to
literally
like
two
C++
files,
right,
let's
say
just
C
files
like
dot
C
files.
We
could
just
pass
start
at
C
here,
which
means
we
would
pass
that
filter
down
all
the
way
to
into
the
two-way
API.
So
what
they
would
turn
to
us
already
is
filter
down
to
everything
that
just
ends
with
like
C
by
discipline.
A
Sort
of
custom
processing
like
is
it
is
that
off.
That's
where,
basically,
you
go
to
the
override
of
our
machinery,
because
we
have
to
allocate
you
basically
a
very
rich
object
so
that
you
can
just
write.
Oh,
I
don't
only
want
to
do
the
things
that
are
actually
suffix
of
summer.
I
don't
want
anything
with
this
particular
attribute.
Your.
I
A
Is
a
basically
giving
you
like
some
sort
of
like
lower-level
building
blocks?
What
you
call
like
transforms
and
like
predicates,
essentially,
where
you
do
the
processing
effectively
above
win32,
but
still
well
below
the
overhead
other
rich
things
that
we
give
you
back
and
strings
and
all
that
and
the
idea
is
that
yeah.
That
code
is
probably
pretty
ugly.
But
the
idea
would
be
that
we
expose
more
high-level
building
blocks
that
allow
us
to,
like.
B
Based
on
demand
right,
so
we
have
some
building
blocks
that
you
would
still
be
using
the
gate
guy
like
here,
which
I'm
using
a
few
of
them
there
but
like
if
there's
a
set
of
building
blocks
together
like
we're
doing
like
the
simple
match,
and
people
really
want
that.
I
assume
that
they
do
that's
one
of
the
ones.
B
That's
kind
of
high
on
my
bucket
list
is
that,
like
I,
just
want
star
to
be
starred
on
my
question
marketing
question
mark
I,
don't
want
to
have
to
worry
about
whether
or
not
like
star
dot
means
something
on
this
deployment
versus
that
one
which,
like
foo
dot,
means
something
different
on
Windows
than
it
does
on
UNIX.
So.
K
B
B
It's
never
not
completely
hundred,
not
allocating
you
always
resetting
a
string,
I
mean
it
but
like
well.
You
know
you
don't
have
to
you:
don't
have
to
create
an
output
string
like
there's
the
buffer.
That's
coming
back
to
Windows
what
you
decide
so
we're
giving
a
span
into
the
name
that
comes
back
from
the
buffer
from
Windows.
We
start
to
allocate
that
buffer
so
ways
in
which
code
others
I
am
the
buffer
and
they
pass
it
to
win
30
guys
to
fill
in
the
data.
B
So
we're
doing
that
now,
which
is
the
difference
remote
we
used
to.
Do
we
used
to
allow
Windows
to
do
it.
That
was
another
big
performance
it
so
like
we
don't
use.
This
is
very
window
specific
in
this
case,
but
like
Windows,
when
you're
enumerated
like
as
you
workers
through
the
directories,
you
would
create
another
buffer
every
directory
going
into
on
the
inside
Windows.
Now
we're
not
letting
we
don't
call
the
win32
avi
the
fine
purse
file.
B
G
B
B
K
B
Right
then,
you
have
to
copy
into
pipe
and
stuff,
so
it
basically
there's
there's
a
class
fine,
innumerable
that
you're
constructing
we
can
add
an
ill
or
over
loop
to
that
in
the
future.
That
allows
you
to
construct
it
with
a
buffer
there's
that
so
it's
pretty
simple
thing
to
do,
and
it
is
internally
using
a
buffer
anyway
from
the
array
pool.
So
it's
all
architected
that
way.
So
when
we
had
two
different
because
I
had
one
up
like
expensive
time,
we
may
do
it
so
now,
but
I
want
to
play
start
time
right
now.
A
You
can
see
have
a
coat
is
still
like
somewhere,
because
it's
hard
to
see
that
types
and
it's
actually
being
passed
in
so
like
this
is
this
is
the
key
type
that
you
basically
have
right.
So
that
here
is
that,
if
I
want
to
enumerate
like
the
file
system,
I
would
construct
this
guy
yep.
And
then
they
see
what
I
pass
to
the
constructor
is
the
route
of
the
direct
here.
But
you
want
to
start
and
then
I
pass
in
a
predicate
and
so
a
transform,
a
predicate
and
then
a
first
particle.
B
There
is
an
option
in
there
to
use
a
larger
buffer.
That's
people
been
asking
for
doing,
SMB,
work
and
stuff
like
that,
and
also
there's
about
one
of
the
big.
This
is
a
big
bucket
list
item.
Is
that
there's
an
option
to
skip
on
access
tonight,
so
this
does
what
I
want
to
have
right
off
the
latrone
any.
D
Probably
so
I
have
a
slightly
more
interesting
question
on
the
previous.
On
the
example
in
the
top
one,
you
were
looking
for
starter
CS
or
something
that
was
going
to
the
OS
right
and
the
OS
was
there
for
filtering
doing
the
filtering,
albeit
using
it
strange
rules
in
your
example,
it
seemed
like
that
was
only
happening
in
the
filter
predicate,
so
the
OS
is
coins
every
single
one
and
it
sounds
like
it
turns
them
in
groups.
So.
B
Like
this,
only
it
actually
isn't
like,
certainly
not
on
the
windows.
I,
don't
general,
some
fairly
painful
detail,
but
like
fundamentally
that
buffer
was
always
getting
created
and
always
filled
with
the
full
set
of
data.
It's
just
what
they.
What
they
decided
to
pass
back
is
like
based
on
that
filter.
If
there
happens
to
be
one
so
and
when
you're
doing
recursive,
which
is
the
fundamental
one
that
I'm
trying
to
solve
here,
is
that
like?
There
is
no
way
to
filter
out
directories,
so
the
existing
implementation
in
desktop
is
that
we
actually
always
enumerate
twice.
B
So
we
go
to
the
windows,
we
ask
it
for
the
we
ask
it
for
a
start
on
CS.
It
gives
back
the
file
items
and
we
go
and
ask
it
for
everything.
So
we
can
find
all
the
directories
whenever
we
do
a
recursive
thing
and
what
happens
under
the
covers
is
that
you
have
these
intermediate
buffer
is
being
created
if
the
fine
first
file
level,
which
is
then
doing
transforms
the
native
data
back
and
forth
out
of
there,
the
second
internal
buffer.
What
happens
now
is
that,
like
none
of
that
translation
is
happening.
B
So
the
raw
data
doesn't
have
to
be
filtered
out
in
this
intermediate
buffer.
That's
coming
up
to
theta
cool
file
system
that
would
be
able
to
instantly
tell
you
whether
there's
any
start
or
text.
It's
worth
doesn't
do
that.
So
you
haven't
bothered
to
worry
about
no
and
there's.
There's
there's
a
there's,
some
level
of
like
being
able
to
provide
still
provide
higher
level
abstractions
for
common
scenarios
that
we
come
up
with
say
some
particular
set
of
support
comes
in
or
we
find
that
like
right.
B
B
Find
all
these
delegates
delegates
Ghirardelli,
so
the
thing
to
look
at
really
is
look
at
you
look
at
the
find
data
right.
So
this
is
really
the
fundamental
part
of
where
this
thing
allows
you
to
build
fairly
low
level.
So
what
it's
doing
here
is
that,
like
leave
your
read-only
span
car
great,
that's
allowing
you
direct
access
to
the
buffer
right,
that's
being
passed
back,
the
other
things
are
sort
of
trivial
in
size
and
they're.
All.
B
Because
the
abstractions
we
have
to
do
across
units
so
like
it
just
so
happens
that
our
current
stuff
is
defined
around
this
set
of
data
right
and
this
set
of
data
is
returned
as
a
single
block
in
Windows
that
all
comes
back
is
the
like
the
initial
block
for
a
tea.
That's
why
my
final
name
is
suspend,
but
the
other
strings
in
the
other
strings
are
passed
in
screws,
so
they
were
already
allocated.
Those
are
just
packed
over
just
well
with
the
example.
Sorry,
the
directory.
B
We
have
to
allocate
something
to
do
that,
so
that
was
a
conscious
trade
line
yeah,
because
it's
really
an
American
candles.
We
need
to
provide
some
sort
of
thing,
and
that
was
those
kind
of
a
trade-off
thing,
rather
than
add
real
super
complex
logic,
room
that
that
said
or
a
bulb.
The
thing
we
still
allocate
is:
it
is
a
string
for
every
directory.
You
look
at,
but
that's
far
less
than
what
we
use
do,
and
quite
often
that
needs
to
be.
Would.
B
The
problem
there
is
that
my
expectation
is
that
there
will
be
a
lot
of
cases
where
people
want
to
get
the
string
out
right
now.
We
don't
have
a
way
that
way
we
have
a
if
we
have
a
span
wrapped
around
the
string.
This
is
another
thing
I
was
concerned
about
it's
like
we
have
a
scanner
under
on
the
screen,
then
you
string
it
again.
You've
just
created
another
bring.
D
D
Like
if
you
just
okay
well
and
sorry,
I'm
confused
a
if
we
have
read
any
spent
child
right
now,
they
did
to
string.
They
would
not
allocate
right,
but
you
could
imagine
some
because
you
ready
got
the
string.
You
could
have
imagined
some
help
you,
if
you
do
to
string,
you
will
get
an
allocation
even
if
it's
backed
by
real
strength.
Yes,
this
wrong.
Well,
we.
B
A
I
A
A
B
Though
they
can
do
it
on
both
so
I
mm,
what
I'm?
Finally
doing
the
read-only
expand
around
it
and
like
dealing
with
the
fact
that,
like
there
might
be
an
extra
allocation
there,
but
let
me
sew
the
directory.
Is
it
there
combined?
You
know
it's
it's
the
well,
it
is
the
combined
like
we
need.
We
need
to
give
a
contiguous
finally
into
Windows,
at
least
in
UNIX
as
well.
We
open
a
handle,
the
director.
We
need
an
actual
span,
something
right
to
do
that.
B
D
B
D
B
M
B
To
get
the
data
back
really
positive
involved,
so
I'm
fine
with
that
one
being
read-only
standard,
just
like
what
we're
trying
to
juggle
with
what
whether
people
would
want
to
be
actually
using
that
string
correctly,
there's
some
distance
between
multiple
instances
of
the
this.
So
like
you
have
a
thousand
files
in
the
directory.
You
don't
have
one
instance
of
that
directory
string.
B
A
Was
the
last
time
I
guess:
there's
one
fine
data
right,
because
you
posited
by
ref
right
so
in
theory,
if
you
would
have
one
buffer
that
used
for
the
directory.
Yes,
you
have
to
call
winners
of
contiguous
memory,
but
you
could
basically
override
the
directory
every
single
time.
We
do
a
traversal
right.
You
could
reuse
the
same,
be
the
only
like
sorry,
the
span
of
yes
and.
B
Like
I
looked
at
that,
it's
it's
more
complicated,
you
think,
but
like
there's
some
possibility,
we
might
be
able
to
get
that
far
so
I'm
fine
with
doing
that.
It's
just
like
if
you,
if
you
do,
need
to
get
that
out,
it'll
be
really
nice
to
have
the
ability
to
unwrap
a
certain
if
you
already
had
it
in
there.
But
if
we
have
the
read-only
span
there
anyway,
I
mean
people
should
be
able.
People
should
be
thinking
through
that
process.
K
Anyway,
if
you
wanted
to
be
close
about
directories,
the
batter
would
be
different
lengths,
yes,
nice
and
it's
hard
to
do,
and
then
you
can
have
a
drop
it
because
there's
no
shape
this.
You
don't
have
actually,
instead
of
allocating
a
string
without
a
char
array,
you
could
allocate
it
longer
than
it
has
to
be.
You.
I
D
K
B
It
was
not
condition
yeah
and
I'm
fine,
with
this
particular
one
being
being
the
read-only
spent,
because
then
there's
also,
it's
also
obvious
on
the
consumer
side,
whether
it's
not
back
by
spring
or
not
internally,
you
know
you
should
have
to
cache
it
right.
If
you
don't
want
to
keep
allocating
it's.
K
Should
we
look
at
the
predicate
but
I
think
it's
fine,
because
you
would
basically
imagine
what
cold
would
do
is
would
get
a
span
and
just
compare
it
for
equality
or
side
sweep
or
something
like
this,
which
we
have
api's
for
you
know
working
with
the
Sun
and
then
when
it
finds
something,
then
it
could
materialize.
The
string
but
span
would
give
it
a
bit
more
flexibility,
because
imagine
that
she
wants
to
combine
the
directory
with
death
file
name
to
have
a
full
path.
K
When
you
have
two
strings
suddenly,
like
we
allocate
two
strings,
so
we
can
combine
them
and
create
the
third
string
versus
if
they
are
spans.
We
could
actually
just
allocate
an
array
of
the
proper
length
because
we
know
they're
like
we
have
those
two
spans
and
then
copy
the
data
into
NZ
to
the
shape
those
ideas.
A
I
I
B
A
uniqueness
for
distinct
other
ways.
What
is
food?
Honest
food,
our
Tech's
work?
Well,
because
they
have
two
original
directory
in
the
user
directory,
are
used
for
building
up
output
screens
like
right
now
like
if
you
pass
in
a
path,
that's
like
relative.
We
give
you
back,
so
this
allows
you
to
provide
the
same
sort
of
behavior
that
we
find
in
all
paths.
We
give
you
the
relative
path,
so.
D
You
stop
or
whatever
you
guys
to
the
path
from
there.
We
can
expand
it
with
no
allocate
right
because
it
just
be
to
span,
has
found
over
two
stands
with
paths.
Combined
has
been
more
complicated,
I'll
talk
of
mine
I'm,
just
saying,
could
you
put
pass
on
there?
That
returns?
We
don't
need
span
and
it
would
not
cause
any
allocations
if
I
got
it
because
it
would
just
be
a
span
over
the
directory
slash
phone.
What
do
we
have.
D
B
B
H
B
B
B
N
B
Both
they're,
both
the
roots,
is
just
like.
Then
we
take
that
thing
like.
If
you
pass
in
C
colon
backslash
food
they're
going
to
be
identical
right.
If
you
pass
in
foo,
and
your
current
directory
is
the
C
column,
then
one
is
going
to
be
fou
and
the
other
one's
gonna
be
C
:,
and
that
allows
you
to
build
up
results
like
we
do
right
now,
which
is
like
gives
you
the
results.
I'll
come
back
is
like.
If
you
had
passed
in
food,
then
you
would
get
the
food
back
slaps.
You.
K
B
O
P
B
A
K
B
I
B
Also,
when
do
you
want
our
apartment,
you
about
the
I,
don't
really
care
as
long
as
we
don't
have
to
leave.
We
have
to
convert
it
from
the
native
stuff
anyway.
So
when
the
exactly,
when
do
there's
that
one
as
it
comes
back
because
it's
really
on
the
UNIX
guy's
side,
it
requires
another
API
call.
So
we
don't
do
it
kills.
You
actually
get
the
property,
but
but
I
don't
have
to
convert
from
you
talks
or
whatever
right
you
give
me
it
UTC
yeah.
B
I
think
right
now
we
have
it
nothing
like
it.
We
would
do
the
same
thing
when
we
do
for
really
file
it,
though.
So
it's
really
you're
just
you're
like
act
but
not
on
the
next
is
Linux.
It
doesn't
have
it
Mac
has
it?
Yes,
that's
right.
So
Mac
has
creation
time.
Linux
only
has
it
on
some
distributions,
but
it's
birth
time.
Let's
call
them
those
ones
group
and
then
length
is.
B
D
D
B
M
B
I
B
K
B
B
D
B
Q
B
B
G
A
B
Well,
the
normal
case
is
like
you're,
providing
like
the
most
common
case,
you're,
providing
a
filter,
so
they'll
be
street,
providing
the
start
at
CS,
but
you
may
want
more
complicated
scenarios
like
some
of
the
buildings
where
you
like
I,
already
have
some
sort
of
caching
mechanism,
and
you
want
to
be
looking
stuff
up
within
that
and
populating
that
cache
or
changing
the
cache
based
on
the
information
that
you
pull
back
and
so
I
can
wrap
that
plus
the
filter,
plus
this
plus
put
it
yeah
you'll
struggle
this
date.
It.
A
So
I
think
the
way
the
way
this
works
is
I
mean
this.
The
other
question
I
was
like
I'd,
actually
have
to
be
on
this
stage,
because
it
seems
to
me
like
all
you
do.
Is
you
just
pass
it
back
to
my
to
my
to
my
delegates
right?
So
even
the
DoD
cost
me
this.
Why
would
you
just
pass
me
another
item
of
my
state
because
that's
much
more
consistent
of
how
we
do
callbacks,
but
you
won't
happen
to
burst
right,
but.
Q
You
get
cold
for
every
single
layer,
I
mean
at
least
we
have
a
notion
of
a
path
table
where,
because
we
have
to
store
millions
of
file
a
patch,
so
we
just
store
it
as
a
tree
structure
right.
So
this
way
you
can
just
pass
it
along
and
keep
adding
it
with
the
current
context,
and
we
can
pass
the
state
as
it
traverses,
where
he's
still
saying
pasta
stay
into
the
petticoat
just.
D
A
Well,
you
never
return
them
by.
Basically,
the
only
thing
you
return
is
whatever
you
transform
stuff
ends
up
being
right,
like
fine
data
is
the
only
thing
you
ever
get
passed
to
you,
you
never
return
it
right,
and
so,
when
all
the
sides,
where
it's
passed
to
you,
it's
a
separate
argument
that
gives
us
the
state
it's
exactly
as
expressive,
but
have.
A
D
B
D
A
A
M
But
a
permissible:
this
is
useful
if
you
would
have
a
state
with
a
set
object
for
each
sub-tree,
because
there
is
some
data
that
we
need
to
propagate
through
the
traversal
like
that
remaining
wild
card
directory
or
remaining
clickable
excludes.
So
you
can
wrap
the
state
in
another
state.
They
keep
passing
along
yeah
I,
don't
know
it
has
to
keep
a
dictionary
from.
B
M
A
That's
one
of
the
reasons
I
think
having
is
a
separate
argument,
makes
much
more
sense
because
then
you
don't
have
to
do
that.
You
just
pass
it
in
right,
I!
Guess!
If
you
look
at
this
code
here
right
I
mean
you
pass
in
the
state,
as
your
you
know,
into
the
route
ienumerable
right.
If
you
want
to
do
any
sort
of
recursion
here
well,
I
think
it's
much
easier
if
I
can
just
effectively
pass
them
to
the
state
as
a
separate
argument
than
me
having
to
walk.
A
M
R
M
G
G
F
K
B
C
B
B
R
Question
for
the
MSB:
they
want
skip
some
folders
for
the
book,
but
to
find
all
for
them
on
top
see
a
spot
beneath
their
folder,
but
certain
folders
for
that
IP
I.
You
looks
like
it
was.
This
cancel
all
goodness
they
have,
they
match
the
directory
and
any
skip
moment.
You
cannot
skip
hold
your
pipes.
B
B
A
B
You
right
now
the
state
is
you
get
you
get
everything
in
the
directory
before
you
get
any
other
directory,
so
the
question
how
it
goes
down
from
there
like
its
its
depth
but
well
bits.
So
it's
not
so
you
get
the
entire
set
of
files
for
a
directory,
and
then
we
just
start
popping
off
the
thing
off.
Sorry,
it's
evidently,
if
that's
true
so
but
there's
ways
we
could
tweet
that
to
in
the
future
or
plea
that
enables
better
scenarios
how'd,
you
say
so.
K
K
L
B
B
I
B
A
Select
to
me,
the
value
of
unifying
on
delicate
is
much
more
profound
when
you're
likely
to
combine
multiple
things
right,
which
is
basically
more
like
a
link
start
scenario
where
you
have
already
a
funk
of
something,
and
you
want
a
composite
of
something
else.
This
doesn't
strike
me
as
an
example
where
that's
very
likely,
because
your
your
transforms
are
super
specialized
to
your
current
use
side,
so
I
mean
you're
not
very
likely
to
have
the
wrong
delegate
type
at
your
hand,
so.
A
D
A
A
We
could
use
predicates,
but
then
find
terms,
and
we
would
say
it's
thunk
of
T
result,
comer,
sort
of
funk
of
T,
state,
comma
T
result,
and
it's
just
you
know
at
the
call
side
like
in
the
well
in
the
API,
has
to
take
it
so
right
now,
there's
no
name
type
anymore,
so
you
couldn't
have
put
any
documentation
on
what
the
expectation
was
delegate
is
because
you
have
no
place
to
put
it.
You
would
have
to
put
it
on
the
based
on
the
constructor
of
a
new
mobile,
essentially
versus.
A
B
Document
I
have
to
read,
whereas
if
fine
transform
we
kind
of
have
to
because,
like
you
can't,
you
don't
know
what
you're
expected
to
do
for
you
have
two
objects
and
like
what
are
you
supposed
to
name
the
other
one
I
get
it
because
a
predicate
is
a
predicate
but
like
it's
like
do
I
want
this
or
not.
Let
me
ask
even
like.
K
B
Other
things
I
did,
but
it
like
it's
it's.
There
was
a
little
bit
more
awkward
to
build
the
the
like
to
compose
in
that
case,
like
bits
and
pieces
of
solutions
from
other
people,
if
you're
already
like
forcing
them
down
this
predicate
path,
and
you
can
like
combine
another
predicate
on
top
of
an
existing
run.
B
I
K
I
K
A
It
does
look
more
heavy
waited
for
us,
but
I
do
think
it
allows
you
to
document
the
bits
and
pieces
much
more
easy
because
they
basically
avoid
global
predicates
in
the
namespace.
It
avoids
nested
generics,
because,
basically
you
only
have
the
root
I,
that's
very
Tamar's.
Everything
else
just
get
signatures
I
mean.
Is
that
what.
B
B
B
A
Have
to
find
a
numeral
that
you
already
have
that's
abstract
and
then
the
users
would
have
to
derive
from
that
and
all
the
built-in
predicates
you
currently
offer
you
would
just
make
them
either.
Instance:
methods
on
the
fighting
uribl,
that
implementations
of
that
are
supposed
to
call
or
you
make
them
top-level
extension
methods
somewhere
on
the
undefined
find
data.
One
of
the
two.
K
Just
goes
your
delegates
inside
the
virtual.
You
look
like
that,
get
to
see
out
the
middleman.
So
the
point
is
that
I
think
that,
like
delegate
based
API
is
they
work
when
they
are
simple
right,
there
is
an
advantage.
I
don't
have
to
impair
it
from
a
class
I,
don't
have
to
override
anything
I.
Just
basically,
you
know
call
it
with
one
lambda
and
I'm
done
the
moment.
You
know
this
I
think
a
line
at
which
point
when
there's
like
three
lambdas
with
complicated
parameters.
It's
like
it,
maybe
not
that
much
more
usable.
A
There,
if
you
look
at
code
like
this,
like
basically,
you
have
to
reach
all
commentation,
to
figure
out
what
the
line
is
supposed
to
do
sure
it
imagines
that
you
see
you
know
internal
field
class.
You
know
my
full
path,
with
extension,
a
extends
fine
new.
More
than
you
see,
you
know
override
predicate
override
transform.
When
you
may
see
see
what
the
bodies
do
like
I
mean
the
code
almost
explains
itself
right
and
I
bet.
If
you
like
this
something.
A
I
think
that
one
of
the
problems
you
have
to
consider
is
that,
as
soon
as
you
have
like
a
few
generics
involved
like
especially
with
delegates,
it
gets
complicated
quickly,
like
I
mean
just
just
like
open
intelligence
on
link
and
see
what
intelligence
shows
you.
You
cannot
read
the
API
signatures
like
it's
impossible,
but
the
thing
I.
B
D
B
B
The
framework
is.
We
provide
the
additional
like,
instead
of
like
just
one
method
added
on
somewhere,
where
we
have
another
or
another,
some
other
set
of
flags
to
like
enumerate
in
a
special
way
like
with
like
the
type
of
filter
that
you're
gonna
use.
Right,
you
know,
are
you
going
to
use
a
the
simple
filter,
you're
going
to
use
the
toss
filter?
You
can
use
the.
B
B
B
B
B
I
D
And
effectively
to
move
then
get
the
idols.
It's
one
method
do
I
get
next
to
something.
It
feels
weird
to
me
to
define
a
type
for
a
job
that
I
just
want
to
probably
do
in
one
function
and
then
have
that
in
my
namespace.
It
just
feels
odd,
like
I
want
to
have
a
class
nested
in
my
function.
That's
what.
E
A
D
B
There
there's
there's
weirdness
around
this
at
the
performance
of
the
framework
right
like
if
you
want
to
get
this
thing
to
the
delegates.
You
have
to
do
it
like
this,
so
yeah
like
if
you
don't,
if
you,
if
I
just
had
the
methods
called
in,
that's
why
it's
uglier
than
it
has
to
be.
Otherwise.
This
is
the
best
practice
right
now.
This
caches
the
delegates,
the
other
like,
if
you
just
pass
fine,
transforms
as
full
user.
K
A
B
B
G
A
Should
do
the
same
thing,
but
I
mean
the
problem
when
you
do
that
is
then
you
don't
only
get
type
inference.
You
literally
have
to
spell
out
the
delegate
signature
like
you
have
to
call
the
delegate
name
right
now.
It
knows
that
it's
a
fine
predicate
if
you
assign
it
to
local.
You
have
to
say
it
at
some
point.
I
can't
use
var
anywhere
because
the
data
gets
on
at
the
type
of
tea
shop
unless
you
so.
K
K
B
B
Area
teching
would
be
a
little
different.
I'd
have
to
move
that
around
so
like.
If
you
don't
set
some
of
those
you
have
to
have
something
right
like
I
need
to
I
need
to
have
a
transform.
You
need
to
have
wait.
Where
do
you
need
that
we
didn't
get
through?
Sorry,
don't
even
know
just
we
have
no
we're
taking
you.
We
can't
go
back
to
find
a
right.
We
have
to
give
back
something.
What
do
we
get
back?
We
can
make
defaults.
D
B
Well
as
to
what
does
it
do,
what
does
transform
doing
it?
So
like
you
right
now,
for
example,
like
we
provide
out
you're
getting
pilot,
though
right,
because
you're
asking
file,
you
did
it
from
directory
info,
your
numerating
and
five
of
those
right.
So
there's
one
that
will
turn
that
thing
into
a
file
info.
It's
got
an
optimized
internal
path
that
doesn't
Halleck
eight
as
much
as
the
old
one
used
to
gives
back
Pilon
perfect,
something
you
convince
from
the
new.
K
G
B
B
B
B
It's
like
I
actually
had
it
have
defaults,
so
what
he
didn't
specify
that
it's
full
bath,
it's
a
string
and
I
hadn't
looked
through
the
type
of
the
output
say
like
if
you
if
he
said
if
you,
if
you
ask
for
one
of
these
types
like
the
normal
ones,
yes
profile
info,
yes
for
a
directory
in
total,
yes
per
string
and
instead
of
getting
complicated
right,
you
have
all
this
logic
and
the
thing
to
like
try
and
pick
something,
and
it's
a
little
hard
to
like
go
back
and
track.
I
mean
it
kind
of
works.
B
State
is
my
struct
right
and
not
strength,
anything
that
was
that
was
another
part
of
it
too,
like
the
that's,
were
kind
of
what
you
guys
might
end
up
doing
in
some
cases
or
a
just
like
you
want
to
like
get
bits
and
pieces
of
that
data
and
associated
with
some
state
that
you
were
doing
internally
right
here.
It's
okay
like
what's
the
current
position
in
state
right,
you
know,
so
they
have
a
stripe
that
gives
back
out
the
string
plus
the
position
in
their
state
and
some
other.
K
It
may
be
a
very
maybe
insurance
it.
What
I
was
saying
is
you
know,
the
delegate
would
still
take
fine
make
them,
but
the
default
one
would
just
extract.
The
Koopa
would
allocate
and
give
you
some.
But
if
you
don't
like
the
behavior,
you
change
it
and
you
do
whatever
it
has
information.
You
want.
The
T
result.
B
A
So
the
type
you're
passing
in
here
this
one
here
is
the
return
type.
Sorry,
that's
the
state.
This
one
here
is
the
return
type
of
all
the
predicates
that
you
constructed,
so
the
user
constructed
like
let's
say
it
says
in
well.
You
cannot
just
return
the
full
path,
because
the
types
don't
align
well.
B
K
D
B
J
B
Don't
if
you
don't
provide
those
those
key
words,
I
can
I
can
see
the
other
ones,
the
optional
ones,
moving
those
parameters
right,
I'm,
fine
with
that
the
other
one
is
like.
The
error
case
becomes
weird,
because
if
you
don't
have
the
necessary,
you
need
to
transform
the
filter
can
like
fine.
You
can
make
that
always
return
true
or
something
like
that.
I,
don't
that's
the
best
decision,
but
at
least
the
transform
you
have
to
have.
And
if
you
push
that
off
to
a
property,
then
you
would
throw
when
you
actually
start
numerating,
which
so.
K
B
B
P
B
B
I
don't
get
this
this.
This
thing
is
intended
to
like
it's
to
be
like
a
two-stage
thing:
right
one
is
it
like
this
opens
up
everybody's
from
a
substantial
chunk
of
like
what
people
want
to
do
without
having
to
have
us
write
a
higher
level
nicer,
ABI
on
it,
and
the
hope
is
twofold.
One
is
that
people
are
unblocked,
but
the
other
one
is
that
we
actually
see
that,
like
the
same
people,
are
writing
the
same
chunk
of
helper
code.
We
say
like
well,
this
is
done
here
here.
A
lot
of
people
need
this.
B
Let's
add
another
API
to
the
root
surface
area.
That's
easy,
like
isn't
his
container
bowl,
but
gives
you
that
particular
scenario.
So,
right
now
that
that's
been
second-guessing
right
like
we
go
like
well,
we
think
it's
like
this
is
what
like,
how
many
people
need
just
the
file
names
with
one
of
the
examples
I
gave
in
the
beginning
right.
You
know
like
that,
could
be
a
lot
of
people
who
could
not
be
like
I.
Can
yes,
but
the
proof
of
the
pudding
is
like
looking
at
what
ends
up
in
people's
repositories,
but
I.
A
F
I
I
A
Thing
we
need
to
fix
in
our
API.
Is
it
is
not
perf?
Is
it
Jeremy
said
it's
the
thing
that
when
you
request
recursively
and
we
cannot
access
one
directory,
you
have
to
do
everything
yourself,
because
we
like
there's
no
way
for
you
to.
Basically,
you
know
handle
errors,
because
we
don't
do
anything
right.
So
that's.
B
Related
right
because,
like
I'm
actually
providing
that
now,
but
this
is
the
sort
of
thing
because
we're
built
on
this
internally,
it's
relatively
in,
like
the
the
perimeter,
is
a
ssin
that
I
have
is
like
that's
one
of
the
ones
I
offered
right
off.
The
bat
is
like
look
skip
on
ignored
access,
denied
right
comment.
I
K
B
What
I'm
kind
of
expecting
is
something
along
those
lines
is
that,
like
we'll
have
those
those
wrappers
for
the
for
the
comments
areas
are
built
up
and
then
you
just
go
and
like,
but
I
want
I
want
that
to
be
more
data
driven
by
like
not
just
like,
but
we're
looking
at
what
people
are
voicing
opinions
about,
but
seeing
how
things
actually
get
written
code
is
like
just
that
much
more
because,
like
the
other
thing,
I
don't
want
to
do
is
have
an
explosion
of
stuff.
That,
like
is
not
very
broadly
Musel
or
that's.
P
B
P
Can
live
with
you,
postponing
I
think
there's
a
couple
that
are
so
obvious:
maybe
don't
postpone
them,
but
I
think
you
know
we
could
live
with
postponing
all
of
them
if
there's
a
plan
for
where
they
go.
But
if
you
make
just
one-
and
you
know
where
it's
going
to
go
when
you
have
your
pattern
set
and
that
just
might
be
a
little
more
future
proof
than
putting
that
up
front,
so
that's
just
a
call
to
make,
but
it's
you
know
obviously
you're
not
going
to
put
it
or
they
don't
think
you
put
it
on.
B
B
Before
we
add
our
first
one,
where
we
add
a
new
I,
have
one
very
simple
one
that
we're
doing
is
we're
adding
the
options
you
can
see
that,
and
that
only
gives
a
subset
of
things
that
we're
looking
at
here
but
like
to
provide
pre-camp
things
like
like
I.
Think
that,
like
we
wouldn't
want
to
take
our
time
to
think
about
to
do
that
right
now,
we're
not
doing
it
so
it
does.
This
doesn't
block
any
decision
wherever
we
put
this
Ionis.
P
If
the
bar
is
and
I
don't
know
where
the
bar
is,
but
I'm
worried
that
if
you
have,
if
it's
hard
to
write
these,
because
you
have
to
write
a
lambda
expression
to
do
use
the
find
a
get
the
thing
out,
you
say
you're
going
to
look
at
our
postures.
You.
How
many
people
actually
writing
this
and
then
that
one
there
they're.
B
Already
they're
already
existing
like
helper
libraries
that
people
were
building
and
that's
that's
kind
of
the
I,
don't
I
don't
expect
like
your
average
developer,
to
be
going
rapidly.
It's
what
I
expect
is
that,
like
some
of
the
existing
community
things
and
all
higher
level
abstractions
and
the
more
like
you
see,
build
people
building
things
and
things
like
that,
then
you'll
actually
be
able
to
that's
a
good
indicator.
What's
going
down,
look
I'm
not
expecting
your
your
average
developer
to
be
coming
to
them.
B
A
Think,
honestly,
if
you
look
at
this
API
like
the
way
I
think
we
end
up
going,
if
you
just
look
at
the
way,
our
API
isn't
structured,
they're,
basically
mostly
static,
helpers
right
and
like,
if
you,
if
you
think
of
a
homework
from
a
functional
standpoint,
I
would
say
we
are
at
the
point
where
adding
more
inputs
to
these
methods
is
not
helping
anymore
because
they
get
like
long
words
on
myeloma
and
the
biggest
problem.
Is
that
there's
combinatorics
at
some
point
you're
like
here
in
this
case
we
just
want
to
add
fight
options,
we'll.
A
A
I
B
That's
just
awkward
between
the
platforms
right
like
so
that's
where
something
like
well,
this
is
a
built-in
functionality
within
tracking
cycles
would
be
something
that
we
would
potentially
add
in.
The
future
is
another
one
right
so
because
other
other
API
to
do
this
right
so
Java
does
that,
for
example,
they
allow
you
if
you
actually
do
recursive
evil,
they've.
B
O
K
K
B
A
Of
adding
like
find
options
as
an
argument
and
could
imagine
that
will
hard
level
API
instead
of
PCAC
being
said,
a
CalPERS
is
more
something
like
a
fluent
API.
They
basic
construct
your
query
and
then
at
some
point
you
just
say
run
similar
to
how
you
find
new
mobile
works,
but
much
more
convenient
API
was
I.
Think
about.
K
K
You
know,
file
a
numeration
options
and
you
have
a
field
that
says
buffer
size
and
you
have
a
field
out
in
all
errors,
and
then
you
can
add
more
fields
in
the
futures
or
where
everyone?
How
does
that
help
with
a
valid
combination
problem
installed
one
time?
Well,
it
doesn't
completely
solve
development,
but
it,
for
example,
salts
that
round.
Above
now,.
B
B
B
R
For
the
CGS
side,
we
actually
constructed
tree
masks
and
a
disk
buta
immutable
data
tree
structure.
So
we
always
so
the
tree
is
beautiful.
We
viewed
it
a
beautiful
structure.
There's
subdirectory
then
create
a
parent
so
for
this
one
said
they'd
be
harder
because
I
don't
know
when
they
finish.
One
directory
I
can
use
the
next
one
to
see
what
it's
now
a
different
directory
to
know.
The
previous
one
finished
well.
R
Another
when
director
so
we're
basically
is
a
deep
first
of
scanning
and
that
every
subdirectory
returned
the
structures
in
would
combine
everything
beneath
odor
to
up
to
the
parent.
So
it's
a
immutable
structure,
so
we
cannot
insert
any.
We
just
explode
in
memory,
there's
always
a
constructor
from
leaf
to
to
root
okay.
So
you.
R
B
B
B
B
To
get
the
because
it
gives
you
a
set
of
stuff
and,
like
you
get
like
your
buffer,
is
let's
say
you
get
10
items
in
that
thing
and,
like
you
get
to
the
tenth
item
and
you
ask
for
more
data,
it
says
nope,
no
more,
you
could
always,
but
it
would
overwrite
the
buffer
right.
What
users
do
is
keep
T
buffer.
You
know
you
could
move
next.
B
O
N
K
B
B
In
seizure,
yeah,
I
agree,
but
bling
to
this
this
this
whole
like
finished
enumeration.
The
finish
directory
thing
is
pretty
simple:
if
you're
putting
it
on
side
of
on
putting
it
on
the
state
of
a
I,
don't
know
but
like
as
a
method
call
is
a
callback
way.
You
said
it
is
a
callback.
If
you
have
it,
you
drive
and
you
care
about
that,
oh
because,
if
they
were
efficient.
K
B
You
could
add
yet
another
which
I
wouldn't
do
because
it'll
be
like
I
like,
but
like
a
combination
of
the
two
I
think
would
work
really
well
for
some
of
these
things
and
I
was
even
considered
that
we
were
talking
about
like
like
some
of
these
more
like
the
recur
sting
right
is
like
well,
maybe
because
the
recurse
thing,
the
things
that
you
don't
eat
all
the
time
like.
Should
I
recurse
right
like
well,
maybe
that's
one
I
use.
D
A
Well,
either
way.
I've
got
a
type
right
then,
but
yeah,
but
the
time
already
exists
like
fine
new
mobile
has
to
exist
regardless
right
right.
So,
instead
of
having
another
fine
options
truck,
you
could
just
make
the
moment.
You
know
members
on
that
type
and
then
maybe
make
them
protected
sets
or
the
only
divide,
plus.
D
A
Right,
whereas
with
this,
where
you
only
ever
have
two
sure
where
they're
going
next
to
me,
it's
about
net
its
it's
about
net
reduction
of
concepts
and
lines
of
code
right.
So,
for
example,
imagine
like
the
predicate
is
a
virtual
function
always
returns.
True,
imagine
that
you
know
recurse,
it's
a
predator
is
the
predicate
is
a
virtual
that
always
returns
true,
so
there's
already
two
things
you
never
have
to
overwrite.
Unless
you
care
about
that
policy
would
be
the
same
with
the
bag
of
state.
You
just
wouldn't
set
the
delegate.
D
You
know
the
number
of
all
thoughts
and
combinations
yeah:
it's
like
no,
no,
not
a
constructor
the
bag
of
State,
so
the
constructor
just
takes
the
directory
and
then
the
transform
and
then
all
the
other
predicates
and
options
are
set
on
the
bag.
That
was
the
other
proposal.
I'm
sure
you
could
do
that.
D
K
A
To
say
bases
earlier,
I
could
think
about
being
fully
there
not
being
like
somewhere
else.
I
think
like
c-sharp
tries
to
be
more
functional,
but
like
this
doesn't
strike
me
as
a
functional
API
like
this
is
a
this
is
a
low-level
you
know,
potentially
non-trivial,
API
and
I'm,
not
sure
that
a
bunch
of
delegates
is
is
logically
the
way
to
model
it.
I
mean
yes,
you
can
I
mean
technically,
you
know
every
object
is
like
is
the
said.
Like
a
dictionary,
probably.
A
B
Of
you
know,
I
want
this
thing
to
perform.
Well
with,
like
you
know,
500,000
files
right
so
looking
at
overhead
prefer
particular
things.
I
was
trying
to
keep
it.
It's
got
a
lot
of
time
talking
to
David
other
folks,
just
try
it
like
what's
legally
give-and-take,
calling
the
virtual
Corvis
is
a
delicate,
delicate
calls
are
actually
pretty
fast.
B
L
B
D
I
K
B
They're
not
that
big
of
a
deal
but
like
I
still
at
least
want
it
to
not
eat
jerk
and
create
a
whole
pizza,
gazillion
of
them.
The
the
real
and
the
real
scenario
I
think
I
brought
it
up
in
getting,
but
like
again
is
not
it's
the
hot
the
measure
the
metric
is,
you
know
moderate
to
huge
datasets
right
so
like
and
recursive
and
hot
io
right,
you
know
understand.
I
was
like
that,
like
that's,
where
we
really
like.
G
B
B
So
the
size
of
the
strings
or
whatever,
like
you,
could
keep
those
things
separate
as
well.
Look
good
like
the
directory
portion
and
the
file
thing
has
never
put
them
together.
Unless
you
really
really
have
to
I
mean
there's
lots
of
opportunities,
but
there's
just
the
sheer
number
of
strings
like
what
did
they
think
it
was
so
david
keene
was
doing
the
examinations
on
his
like
he's.
Looking
at
the
prevalent
project,
he
started.
It
was
like
what
forth
multiple
terabytes
worth
about
allocations
on
startup
phase.
B
B
I
B
This
one
is
the
windows
heuristic
right,
so
it
does
exactly
what
Windows
does
we
keep
a
stuff
on
the
command
line,
so
star
dot
has
a
very
specific
behavior
which
is
not
like
representable
in
UNIX
or
Phi
or
Fuu
dot.
This
can
get
files
and
get
directories.
Implementations
go
through
this
then
because
it
may
correct,
but
right
now
we
try
to
replicate
some
of
the
behavior
in
the
UNIX
ID.
B
So
if
you
have
these
like,
when
you
have
like
trailing
periods
and
things
like
that,
where
stuff
gets
kind
of
wonky
like
the
behavior
is
not
going
to
be
consistent
right
so
but
that's
what
we
do
so
I'm
providing
that
if
you
really
want
to
do
that
on
UNIX
now,
you
can
do
that
right,
but
I'm
also
want
to
provide
these
things.
Like
you,
eventually,
a
little
bit
more
use,
it's
used
to
do
the
filtering
right.
So
why
is
it
this
study.
A
A
K
A
B
Seems
easier
to
call
it
method
is
delicate
and
it's
in
the
rules
are
super
complicated.
So
there's
another
API
on
there
as
well
I
mean
I.
Have
the
comments
in
the
source
in
the
source
code
of
Billick.
There
is
actually
more
wildcards
than
start
and
question
mark.
You
know,
there's
a
quote
and,
and
some
less
than
and
greater
than
but
like
so
this.
The
translate
is
for
that
right.
K
L
B
B
D
B
B
B
B
B
Right
but
I
mean
most
people
just
don't
know
that
rate
but
like
we
have
to
handle
it,
so
it
matches
the
other
behavior,
but
most
people
don't
expect
it
to
not
be
translated.
So
star
is
actually
treated
like
star
and
question
mark
is
created
like
question
mark,
it's
just
there's
an
intermediate
step
in
the
win32
layer
where
it
takes
some
of
the
stars
and
some
of
the
question
marks
and
converts
into
these
things
to
give
you
that
weird
toss
behavior.
So
that's
what
that.
K
N
B
K
B
B
K
Like
that,
generally,
if
you
combine
you
know,
if
you
combine
that
helpers
interesting
who
died
so
I
think
you
will
have
to
know
them
like
you
will
have
to
work
on
their
names
of
the
methods
and
parameters.
They
will
become
like
right
now.
The
tightening
this
old
does
matter,
so
you
can
kind
of
think
what
the
methods
are
for
and
what
the
parameters
are
for,
but
the
OMA
needed
to.
G
D
K
B
B
K
A
B
A
K
B
Have
to
come
from
here,
you
could
get
it
out
of
a
list
and
say
like
alright,
these
in
a
match,
I,
don't
what
I
want
to
do
is
I'm
going
to
eventually
shove
people's
face
of
this
right.
I
mean
this
is
starting
to
that
point.
No
seriously,
because
it's
a
problem
right
now
is
like
you,
you
will
find
breaks
because
you
try
to
put
your
stuff
on
core
and,
like
matching,
does
not
work
exactly
the
same
between
the
two,
so
I
I.
B
Don't
really
think
people
will
use
this
or
want
to
use
it,
it
will
work
the
same.
It's
just
they
won't
wear
the
same
in
UNIX.
Is
that
that's
the
problem
I'm
saying
like
it's?
It's
not
a
cross-platform.
We
don't
have
a
cross-platform
way
to
describe
this
one
because
the
algorithm
isn't
available
and
it's
horribly
convoluted.
B
Fortunately,
we
had
already
exposed
it
in
the
file
and
file
watcher
I'm,
just
kind
of
rolling
it
upstream,
a
little
bit
and
publicizing
me,
but
like
by
doing
this,
I
want
to
eventually
get
to
the
point
where,
like
as
part
of
the
options
and
things
that
we
have
is,
we
can
provide
more
easy
wrappers.
We
go
down
to
the
simple
matter,
which
is
just
like
it's
starred
question
mark
period,
and
so
name
can.
B
Could
be
called
input
like
that's
what
we
do
in
regex
right
call
it
I,
don't
mind.
I
would
like
to
match
whatever
regex
does
I
mean
I
I
started
with
what
the
actual
it's
RTL
is
name
and
Express
when
it's
called
that's
the
actual
windows
API
it's
public,
but
that's
what
that
thing
provides
a
provides.
A
cross-platform
version
of
that
and
the
parameter
in
our
case
is.
K
R
P
O
B
C
O
O
B
B
You
know
I'm
I'm,
pretty
sure
they're
using
ordinal,
but
I
need
to
go
back
and
look
with
like
looking
at
the
windows
code.
They're
just
the
table
that
they're
loading
that
they're
using
is
the
one
that
comes
as
part
of
the
NT
startup.
It's
thinking
what
they
have
I'm,
pretty
sure.
That's
Owen,
all
right,
where's
that
invariant
sorry
I'd
have
to
do
first.
B
B
O
O
B
This
is
a
file
system
is
actually
pretty
simple
in
the
way
it
does
its
matching,
so
oh
I'll
definitely
take
it
offline
and
we'll
look
at
it,
but
I'd
like
it
was
very,
very
explicit
trying
to
match
the
exact
same
API
semantics
it's
hard
to
follow,
though
so
I
could
have
gotten
it
wrong,
like
the
way
it
loads.
That
I
mean
that's
really
really
early
in
the
startup
of
teen.
It's
really
hard
to
read
that
if
we.
D
D
B
D
K
B
K
K
Working
directory
up,
you
basically
walk
all
the
files,
and
then
you
notice
cut
that
and
you
go
into
the
chart
and
you
keep
doing
it
and
when
you
get
to
the
root,
there
is
no
dot
dot
and
you
have
rhythm
stops.
You're
saying:
if
I
have
a
barking
professor
from
doing
stupid
stuff,
it
prevents
it
from
algorithm
being
mischievous
I.
Think.
K
A
D
I
K
B
A
A
A
I'd,
like
sure
that
we
call
two,
rather
than
as
the
Demi
called
two
rather
than
as
because
as
kind
of
implies,
it's
cheap
versus
relatively
speaking
to
this
feature.
That's
an
expensive
method
call
right,
because
the
whole
point
is
that
you
don't
have
one
advocates.
I
would
call
them
to
directory
and
for
to
file
info
to
file
system
info
to
user
full
path,
because
it's
basically
a
conversion
writer.
You
basically
do
something
anyway,
which
you
shouldn't
do
in
general
right.
B
K
A
K
K
B
B
B
A
Before
we
go
there,
although
I
think
I
would
like
to
say
is
that
if
it's
there's
no
layer,
it
cuz,
we
clearly
sit
em
up
on
its
collar
because
they
said
above
whatever,
the
primitive
is
so
like
these
lightweight
times
cannot
be
no
other
directory
into.
It.
Does
they've
actually
already
involved
so
the
trick
there
they're,
not
a
problem
in
terms.
B
Of
whether
they
instance
methods
or
not
the
tricky
thing
for
this
one
is
that,
like
there
are
internal
optimizations,
so
your
performance
is
slightly
better
when
I
have
internal
constructors
for
directory
and
file
info.
So
if
you
were
actually
creating
those,
then
you
would
take
a
performance
hit
an
allocation
hit.
You
know
if
you're
like
using
the
amount
of
auxin
area
I,
think
they
won't
be
creating
notes.
I,
wouldn't
assume
you
guys
did
it,
but
like
them,
that's
that's.
B
G
B
B
Way:
you're
not
in
box
and,
of
course
that's
like
but
like
until
it
until
your
your
inbox
from
summary
review
its.
If
it's
inbox,
you
would
the
places
where
in
horror,
since
we
control
everything
I
could
even
do
through
reflection
or
something
stupid
like
that.
But,
like
I
have
the
ability
to
to
initialize
those
things
more
efficient,
I'm
saying
that
I
mean
if
your
inbox,
it.
A
B
A
Is
that,
if
is
this
feature,
goes
out
of
band
the
way
I
expect
the
feature
to
be
is
expected
you've
built
twice
like
there's
one
implementation
for
core.
We
don't
have
to
check
whether
two
constructors
exist.
You
just
call
them,
because
this
is
the
compilation
of
the
assembly
for
dotnet
core
way.
You
know
you
can
call
it
the
yeah.
I
K
B
So
I
want
to
come
up
with
a
solution
where
we
can
continue
to
the
thing
I
one
of
the
fundamental
design
things
I'm
trying
to
get
at
it
with
all
this
stuff
is
I
want
to
stop
like
rewriting
the
same
low-level
code
all
over
the
place.
I
want
us
all
to
be
sharing
logic,
because
it's
easy
to
get
this
stuff
wrong
right
and
subtly
different
between
implementations,
because
it's
just
so
many
subtleties.
You
know
we
just
talked
about
a
few
of
them
with
the
wild
card.
B
Don't
we
put
it
this
way,
I,
don't
care
which
way
we
go.
You
know
whether
it's
building
another
or
like
like
assembly
like
like
a
product
whatever
we
call
it,
what
I
call
them
prototype
or
like
advanced
or
something
like
that.
That
like
gives
people
an
out-of-box
solution
for
the
exact
same
code
that
sent
we
just
to
clue
the
code
in
both
places.
It
allows
you
to
just
take
the
dependency
on
that
assembly
and
as
long
as
they
say,
different
namespaces
no
problems.
No!
B
No-
and
this
is
this-
is
sort
of
orthogonal
because,
like
they
don't
really
need
the
creating
in
the
directory.
Well,
that's
the
only
tie
back
right
directory
and
file
it
those
stuff
to
the
rest
of
the
system
and
make
them
right.
You
know
we
can
write
little
wrappers
in
there,
even
they
like
give
you
the
same
helpers
to
get
the
same
old
behavior.
If
you
want
that
or
whatever
like
it's.
H
B
F
H
K
K
What
we
would
do
in
the
past
is
to
be
able
for
the
parameter
false
you
would
drink
with
the
reversed
awarding.
So
it
would
call
it
not
even
our
case,
but
rather
another
case
or
use
case,
and
then
it
would
be
fun
for
us,
but
in
this
particular
case
I,
don't
think
it
makes
sense,
because
no
case
is
such
a
common
name
that
now
changing
it
to
a
quick
holiday.
B
A
D
B
D
B
Whether
to
use
an
abstract
class
and
on
I'm
not
sure
there
was
really
a
consensus,
I,
don't
think
I
I
think
I
think
that
the
consensus
I'm
seeing
right
now
is
like
for
lilies.
The
next
iteration
is
to
move
the
non
to
reduce
the
size
of
the
constructor
right.
That
was
a
pretty
clear
one
and
I
can
do
that
through
a
combination
of
those
things
and
I
think
I
want
to
explore
the
addressing
scenarios.
I'll
come
back
with
a
definition
that
looks
that
way
right.
That
has
a
couple
other
virtuals
on
it.
B
A
A
A
Option
to
either
be
structuring
them,
but
it
will
be
a
separate
type
most
likely
right.
Unless
we
can
merge
it,
we
find
you
will
be
make
it
an
abstract
type.
Then
we
already
said
the
predicate
to
either
be
yeah.
I,
don't
know
about
the
party
like
the
predicate.
You
have
to
have
I,
think
I'll.
Let
you
move
away
from.
E
K
A
B
I
K
K
Easy
to
name
that
right,
but
I,
think
that
this
API
were
not
used
by
a
lot
of
people
right
I
think
you
have
like
helpers
in
directory.
That's
you
know,
help
new
helpers
area
that
will
solve
majority
of
the
DUP.
They
will
solve
the
problem
of
this
API
failing
when
it
cannot
access
an
item
and
the
problem
for
the
average
developer
is
so
now.
We
have
a
second
problem,
which
is
performance
which
is
not
for
their
preserver,
and
then
they
connects
us
in
your
namespace
yeah.
A
I
think
that
I
honestly
think
back
to
you,
we
will
probably
add
more
stuff
to
them.
Instead,
eventually,
like
I,
guess
you
said
you
want
to
explore
some
more
unique,
see,
stuff
and
I'm.
Honestly,
finally,
saying
you
know
even
things
you
consider
a
platform
agnostic
like
does
matter
to
me,
is
something
that
I
would
put
in
any
physicals
like
there's
like
five
people
in
the
world.
A
B
Finally,
putting
it
as
a
sudden
interest,
so
that's
another
interesting
question
for
you,
though,
is
like
changing
this
from
into
you
know
to
a
struct:
how
for
the
fire
doctrines
right,
how
difficult
is
the
cognitive
load
there
for
users
on
the
existing
things
cuz
flag?
Have
we
done
that
much
in
other
places,
because
Flags
has
been
the
standard
that
we've
done?
One.
K
Thing
we
could
consider
in
the
API
some
directory
instead
of
passing,
find
options.
Why
don't
you
just
add
a
boolean
that
say
ignore
it
inaccessible,
because
all
those
things
are
useful.
Well,
they
are
useful,
but
they
may
be.
Then
you
just
have
to
use
this
other.
You
know
name
space
and
you
just
use
no
more.
K
Hey
it's
a
bit
more
but
constructor
yeah,
it's
a
bit
more
tricky
to
use
this
chart
that
is
mutable
like
has
properties.
That's
how
weird
I
have
to
create
a
disposed.
You
know.
So
if
we
use
this
water,
so
if
we
use
this
chart
in
DOS
main
line
scenarios
for
the
millions
of
developers,
then
you
have
a
point:
I
mean
it.
You
know
we
just
made
a
bit
more
complicated
API,
whereas
the
only
thing
that
they
want
to
do
is
ignore
error.
You're
not.
M
M
Belong
to
different
domains
like
this
accessibility,
something
with
buffers
recursion,
there
will
be
like
traversal
options.
They
have
different
meanings.
They
have
different
meanings.
If
they
shouldn't
be
an
you
know
like
a
submarine
INS
and
I'm
about
I
want
to
do
with
accessible
files,
a
network
files
or
another.
A
I
mean
if
you,
if
this
thing
is
distract
you
can
do
whatever
you
want
right.
I
would
almost
say
that
if
it's
a
strong
to
make
them
all
boolean,
because
if
you're
concerned
about
Tyler's
distract
well
as
your
structs
in
your
implementation,
you
can
have
a
32-bit
packed
in
and
look
like
30
flex.
If
you
wanted
to
so
you
can
all
them.
You
know
in
one
giant
field
if
you
want
to
size
strong
tree
in
that
sense
like,
but
really
the
only
concern
is,
you
know
non
flag
style.
A
A
The
biggest
problem
is
usability
at
some
point
like
if
you
look
at
binding
Flags
like
there's
so
many
things
you
have
to
set
to
get
any
results
back,
that
it's
like
usually
hard
to
get
it
right
the
first
time,
but
if
you
make
it
instructor,
you
just
have
you
know,
12
properties
that
you
know
owls
offer
you
can
all
set
them
independently.
Well,
who
cares
like
I
mean
they
I
mean
at
that
point,
I,
don't
think
any
different
type
for
you
know
recurse
and
then
different
type
for
accessibility.
You
just
say
that.
B
R
B
B
A
What
are
you
saying
different
you
saying
we
have
these
api's
here
which
are
used
by
a
lot
of
people.
I
got
this
one
here,
but
these
guys
here
I
know
they
use
for
a
lot
of
people.
The
problem
is
that
this
API
here
sorry
this
one
here
the
base
allows
you
to
request
today,
doesn't
work
in
a
lot
of
cases
in
order
for
you
to
use
something
else,
you
have
to
rewrite
that
message
and
recurse
yourself
and
catch
exceptions,
for
example
super
annoying
right,
so
the
lady
would
be
there.
Maybe.
I
A
K
B
About
that,
the
it's
the
track
cycles
because,
like
this
is
like
by
default
right
like
it's,
a
Java
will
track
the
cycles.
If
you
need
recursive
right,
we
don't
so
like
cycles
is
a
problem.
This
is
one
of
the
main
reasons
why
Windows
didn't
have
the
right
on
by
default.
It's
because
cycles
get
introduced
in
the
file
system
and
most
programs
followed
her
right.
A
Is
that
we
want
people
like
the
people
that
don't
care
we
want
them
to
be
successful
today,
there's
two
things
that
if
they
have
to
rework
it
themselves
like
we
lose
the
mess
in
the
process,
they're
not
going
to
rewrite
the
whole
thing
that
you
find
data
thing
right:
they
can
barely
do
it
in
this
way.
So
what
about.
B
Don't
expect
it
to
stop
it
to
expect,
there's
more,
like
the
other.
One
is
important
to
people
been
asking
for
that
because
they're,
like
my
my
SMB
performance
sucks,
why
don't
you
have
the
ability
so,
when
you're
going
to
a
network
share,
the
new
running
files
is
horrible,
because
we
have
a
4k
buffered
set
of
sixth
and
say.
A
So
example
of
something
where
you
know
you
know
in
full
family
for
a
second
would
do
there,
but
encore
I
would
feel
somewhat
more
comfortable
saying
you
know
we
change
our
implementation
to
not
fall
over
when
you
get
an
access
denied
and
like
we
change
your
implementation
to
not
fall
over
me
the
cycle
and
run
out
of
memory,
because
basically
we
just
make
things
that
would
fail.
It
spectacularly
feel
less.
It
seems
generally
like
a
safe
thing
to
do.
Yeah.
I
B
B
A
B
So
if
I
go
and
open
up
another
directory
I'm,
giving
it
a
full
path
right
right,
but
they
would
prevent
you
from
actually
navigating
to
that
point,
because
once
you
get
ten
Reaper
points,
they
boil
up
now.
That
said,
there's
another
optimization
that
I'm
intending
to
do
that
I
haven't
done
yet,
at
least
in
the
in
the
actual
public
code.