►
From YouTube: Silk.NET Coffee & Code Catchups
Description
Join the Silk.NET team for a quick catchup. This is a more informal stream wherein we'll be discussing what we've been doing on the Silk.NET project, what we've been doing outside of Silk.NET, bouncing ideas off each-other, and (most importantly!) provides us an opportunity to answer any questions the community may have.
These streams are impromptu and the VOD will be unlisted as a result.
GitHub: https://github.com/dotnet/Silk.NET
Discord: https://discord.gg/DTHHXRt
Background music by HOME.
A
A
C
All
right,
hello,
hello,
I
believe
we
are
live,
but
please
correct
me
if
I'm
wrong,
I
haven't
actually
got
the
YouTube
page
up,
so
I
have
no
idea
how
many
people
are
with
us,
but
yes
welcome
to
the
coffee
and
code.
For
those
who
don't
know,
this
is
basically
just
the
maintainers
Jillian
and
maybe
discussing.
C
Not
there's
we'll
find
out.
D
A
I
just
heard
myself
in
stream
and
and
I
was
fine
but
you're
very
quiet
on
on
this
thing.
C
There
we
go,
I
am
louder
right,
yeah,
let's
get
the
let's
get
the
stream
up,
because
that's
probably
courteous
but
yeah,
hello,
hello.
We
have
three
people
here.
We
have
Kai
Thomas,
who
are
acceptable
net
maintainers
and
Skye.
Who
is
a
who
is
a
provingly
Avid
contributor,
so
yeah
I
mean,
but
before
we
get
into
the
silky
stuff?
How
are
you
guys
doing?
Okay,.
A
It's
very
hot
right
now
so
I
uncomfortable
but
I
think.
E
A
E
E
Enough
yeah,
my
problem
is
that
I
should
have
done
physics
free
like
one
or
two
years
ago
and
instead
I
just
didn't
so
I'm,
basically
doing
it
now.
Well
and
I,
don't
remember
anything!
The
professor
starts
first
class
and
starts
doing
some
heavy
integrals
and
I'm
like
oh,
my
God
I.
Don't
remember
any
of
this
stuff
yeah.
C
Well,
I
did
one
year
available
physics,
and
that
was
enough
to
make
me
run
away
forever.
C
Yeah,
no,
that's
a
hardcore
stuff,
I
think
with
a
level
maths
as
well
that
they
I
mean
I,
didn't
do
a
level
Mass,
but
I
did
one
induction
course
and
realized
it
wasn't
for
me
is
that
the
purp
at
the
start
of
the
year
they
purposely
picked
the
hardest
bits
just
to
scares.
It
scared
the
weak
people
off.
E
A
E
It's
literally
the
first
programming
subject
we
have
and
it's
in
C.
We
have
to
basically
do
everything
like
we
start
with
yeah
Basics,
basic
stuff
variables,
memory,
malloc,
free
and
by
the
end
of
the
subject,
we're
doing
object,
oriented
programming
using
adts
on
C.
We
also
have
to
do
a
lot
of
recursion
which,
like
I,
don't
have
much
issues
with,
but
most
people
are
seeing
programming
for
the
first
time
in
that
subject
and
they
just
yeah
once.
A
E
E
C
F
Yeah
I'm,
okay,
that's
all
I
can
say
the
weather
is
lovely.
No
I've.
F
E
C
A
A
C
A
A
C
Well,
I'm
I'm
flying
out
to
Texas
on
Thursday
and
that's
that'll,
be
home
base
for
for
the
foreseeable.
C
Organizing
these
up
on
stream
I
swear,
we
won't
be
rated.
Oh
man,
eight
I
know
I,
didn't
notice.
You.
A
Honestly,
probably
once
I've
moved
and
ever
on
flat
like
if
you're
a
silk
contributing
and
you're
in
Germany
come
visit,
I'll
give
you
my
address.
I,
don't
care
like
I'll
I'll,
give
you
a
silk
top
I
have
like
lots.
A
E
C
C
C
B
I'm,
pretty
good
just
prepping
for
the.net
release.
B
C
Yeah
yeah
well,
I
I,
must
admit.
I
do
like
the
the
annual
annual
major
releases,
though
it's
a
lot
better
than
what
we
had
with
dotnet
core
two
and
Dot
net
called
there,
but
I
remember
when
DNX
was
a
thing
like
it
was
yesterday,
like
man.
B
X
was
definitely
interesting.
It
was
ambitious
and
there's
just
too
much
back
compat
in
history
and
need
to
Port
existing
projects
over.
It
was
just
never
going
to
last.
C
Yeah,
but
it
was
kind
of
fun
because
it
felt
it
felt
very
much
like
a
Skunk
Works
project,
and
it's
like,
like
opening
the
eyes
to
yeah
the
C
sharp,
can
be
other
places
too
yeah.
No,
it
was
no
I.
Do
have
fond
memories.
Of
that
I
mean
it
was
a
definitely
incomplete.
I
know
that
I
still
remember.net
core
one
when
that
came
out
having
to
have
to
write
my
own
HTTP
listener
or
whatever,
but
you
know
there
was
something
fun
about
it,
because
it
was
new
and
shiny.
C
Yeah
but
I
mean
it
was
like
it
was
kind
of
great,
because
that
was
what
really
what
kickstarted
everyone
moving
over
to
net
core
I
mean
I,
remember,
dotnet,
standard
2.0
coming
out,
and
that
was
revolutionary.
B
Yeah,
it
will
be
interesting
to
see
how
rust
ends
up
lasting
long
term
because,
like
part
of
the
split
part
of
the
thing
for
net
core,
one
was
trying
to
get
rid
of
our
Legacy
crud,
revamp
it
in
in
ways
that
we
could,
without
being
too
breaking
and
and
really
minifying
the
standard
Library
there.
B
But,
of
course
that
didn't
work
for
us.
We
had
to
bring
everything
back,
but
for
rust,
they're
trying
to
stay
very
much
on
the
minimal
standard,
Library
get
everything
from
third
party
packages
path
and
they
don't
have.
The
back
compact,
so
it'll
be
interesting
to
see
if
they're
able
to
keep
that
or
if
they're
going
to
end
up
finding
out.
You
know
what
we
really
do
need
to
provide
all
this
crap
in
box,
yeah.
C
I
did
see
I
think
it
was
the
last
first
comp
there
was
a
talk
from
I
think
Josh,
Triplett
I
was
talking
about
the
whole
standardization
process
and
how
they,
how
they
decide
on
apis
being
in
the
standard
library
and
yeah.
Their
approach
is
very
much
well
yeah.
If
the
community
needs
it.
They'll
come
up
with
the
right
answer
and
then
we'll
just
bless
that
with
the
standard,
Library
treatment
and
well
it's
more
time
consuming
for
everyone
getting
access
to
the
right
way
to
do
things
it's.
A
C
A
Say
I'm
a
big
fan
of
like
so
many
of
the
new
languages.
Doing
this
like
minimal
standard
Library
thing,
especially
like
rust
or
like
that
have
like
super
like
they
don't
have
Dynamic
linking
or
like
not
as
like
a
first
fast
thing
like
sure,
well,
I
think
it
makes
a
lot
of
sense
of
this
yeah.
C
A
Like
we'll
biology
together-
and
you
can
just
like
get
things
the
way
you
want
them
and
I
think
it
also
opens
up
a
lot
of
possibilities
that
are
hard
in
C
sharp,
like
you
know
some
scientific
stuff,
or
you
know
things
like
that,
where
you
just
want
things
to
look
slightly
different,
and
then
you
really
thought,
because
everything
just
relies
instead
of
the
library.
C
Yeah
I
mean
c
plus
one
that
kind
of
went
that
route
and
then
the
answer
to
every
single
stack,
Overflow
post
was
just
use
boost
so
I
think
as
much
as
it
is
nice
having
a
minimal
standard,
Library
developers
also
want
one
correct
way
to
do
things.
A
But
I
think
that's
I
think
I
think
the
whole
those
people
of
those
things
also
a
bit
just
because
the
package
management,
like
story
is
just
not
not
a
thing,
while
in
Russ
that's
very
much
everyone
that
you
trust,
whether
they
like
the
language
or
not
I
think
pretty
much.
Everyone
says
the
the
package.
B
The
I
think
the
big
consideration
there
isn't
necessarily
going
to
be
on
open
source
projects,
but
the
big
Enterprise
ones.
B
B
So
now
you
have
to
find
one
of
those
networking
Stacks
that
is
going
to
be
sufficient
for
your
use
in
an
Enterprise
environment
at
scale
and
that
you
know
will
be
able
to
be
correctly
patched
handle
cves
at
the
scale.
You
need
Etc,
so
it
ends
up
being
you
know,
a
big
question
on
how
it's
going
to
work
for
Enterprise
and
I.
Imagine
what's
going
to
happen
is
even
though
there's
a
central
package
management
system.
Now
it's
probably
going
to
go
much.
The
way
C
and
C,
plus
plus,
did
which
is
big.
B
Enterprises,
go
and
write
their
own
in-house
version
that
they
can
actually
maintain,
especially
if
you're
like
one
of
the
top
five
or
ten
Global
Distributors
for
for
software
or
services.
C
Yeah,
but
it's
it's
one
thing
that
affects
me
a
lot
with
pretty
much
anything
is
just
duplication
of
effort.
Is
that
and
but
the
thing
is,
standardization
is
so
hard
because
it's
like
well,
who
controls
it?
How
what
do
you
need
to
take
and
really
that's
what
standard
library
is
doing,
is
waiting
for
the
community
to
have
that
battle
for
them
and
then
bless
the
result
of
it
but
yeah
you.
A
A
They
like
they
provide
all
the
things
if
they
end
up
becoming
like
like
a
company
of
some
kind
or
it's
like
some
large
software
distribute
like
comes
out
and
they
build
their
own
I
think
that's
still
preferable
to
the
model
that
we
often
see
in
like
other
languages,
where
the
people
that
make
the
language
they
just
control,
basically,
all
of
it
and
like
the
packages
around
it
are
just
like
small
communities,
but
there's
not
really
a
chance
like
professional,
like
developers
there,
because
you,
you
have
very
little
like
packages
that
still
are
in
demand
enough,
that
they
wouldn't
be
inside
Library,
where,
like
the
the
language
makers,
but
would
program
it,
but
also
have
enough
demand.
A
C
Because,
like
because
I
guess
there
is
I,
I
mean
a
famous
example
was
probably
Windgate
and
whatever
they,
whatever
the
precursor.
That
was
because
they,
if
I,
remember,
correcting
a
story
that
was
they
were
trying
to.
They
were
trying
to
hire
the
original
great
Crater
of
the
of
well
with
the
the
precursor
to
win,
get
and
drag
their
feet.
So
much
and
all
of
a
sudden,
by
the
time
that
these
negotiations
ended
and
they
didn't
land
on,
they
didn't
end
up
hiring
him.
They
made
their
own
version
that
was
suspicious.
C
They
like
it
so
I,
guess
it
really
it
it.
It
really
depends.
There
is
I.
Think
there
is
net
is
evidence
that
a
fully
vertically
integrated
language
and
framework
can
be
very
good.
I
mean
if
you,
if
you've
ever
used
cjapan.net
with
Microsoft
Azure,
it's
amazing
because
they
very
heavily
optimize
it,
but
I
suppose
it
kind
of
Narrows
the
scope,
because
in
the
the
first
thing
the
first
use
case
they
will
always
optimize.net
for
will
be
Azure,
because
that's
where
the
money
is
so
it's
it.
It's
pros
and
cons.
I
guess.
B
And
it's
it's
Hit
or
Miss
as
well.
You
can,
you
can
end
up
with
with
doing
too
much.
You
can
end
up
with
doing
too
little.
You
know.
None
of
our
UI
Stacks
are
particularly
amazing.
Lots
of
people
are
going
towards
avalonia
instead,
just
because
well,
winforms
is
getting
updates.
B
Wpf
is
is
getting
some
updates,
but
it's
been
in
that
limbo
state
of
trying
to
get
those
tests
online
for
a
few
years
now,
so
people
are
just
going
to
Abalone
instead
and
then
you've
also
got
win
UI
and
Maui
and
xamarin
forms
and
everything
else.
B
You
got
like
six
different
competing
UI
stacks,
where
that's
not
good,
but
on
the
other
end
you
have
cases
like
the
BCL,
where
it's
providing
very
core
fundamental
types
that
other
people
can
build
off
of
like
in
128,
the
new
generic
math
interfaces,
the
hardware,
intrinsics
and
so
I
think
you
really
have
to
find
that
balance
between
what
are
the
foundations
you
want
to
provide
versus
what
are
the
things
that
you
really
should
leave
towards
other
people
and
I?
Think
that
ends
up
kind
of
being.
B
You
want
perf
Primitives
and
security,
Primitives,
inbox
and
other
things
out
of
box.
A
Yeah
for
sure
I
think
I,
probably
like
personally
I'm,
just
like
a
bit
I
prefer
having
the
lower
level
Primitives,
basically
and
then
what
that
generally
has
and
I
think
I
I
argued
a
lot
with
various
people
between
net
quarter
three
and
like
Nets,
five
or
six
about
this.
That,
like
I,
would
much
prefer
if
I
could
go
into
like
Source,
subnet
or
whatever,
to
GitHub
or
whatever
and
like
steal
the
code
and
it
just
works
which,
for
a
lot
of
the
high
performance
types,
isn't
the
case
anymore
and
I
mean
it's.
A
A
C
Other
thing
yeah
actually
in
chat
as
mentions
that
that
things
like
async
being
in
the
standard
library,
is
a
useful,
primitive
as
well,
but
yeah
I
mean
I've
I,
fully
agree.
There
is
work
being
done
to
make
the
BCL
less
magic
I
mean
if
you
look
at
all
the
intrinsic
stuff
that
Tana's
been
doing
and
how
that
enables
people
to
make
their
own
Speedy
math
types
I
mean
it's,
certainly
not
like,
not
not
quite
there
yet
and
and
stay
Royal.
C
There
is
still
work
work
to
be
done
like
with
things
like
the
in
registration
aspect
of
it,
but
it's
getting
there
and
there
is
work
being
done,
but
I
mean
naturally
I
mean
there's,
there's
not
that
much
priority
there
as
well,
because
I
mean
it.
It's
just
used
the
BCL
it
works.
Why
do
you
want
to
make
your
own.
B
Yeah,
there's
there's
a
lot
of
cases
like
like
system.
Runtime
intrinsics
is
true:
Primitives
they're
part
of
the
core
application,
binary
interface
defined
by
most
platforms.
No
one
else
could
provide
them,
but
then
things
like
system
numeric
vectors
for
for
Vector
of
T,
Vector,
2,
3
and
4,
Matrix,
quaternion,
plane,
etc.
Those
were
made
intrinsic
back
in.net
framework
days,
but
they
shh
but
they're.
Fundamentally,
user-defined
types,
they're,
not
Primitives,
and
so
those
are
a
good
example
of
well
here's
magic
that
only
the
BCL
gets
and
that
shouldn't
be
the
case.
B
Anyone
should
be
able
to
get
the
same
magic
that
those
types
get
and
the
the
biggest
problem
with
doing
that
is
just
the
the
risk
of
breaking
or
harming
performance
for
existing
user
types.
B
Just
because
of
because
how
it
operates
very
much
depends
on
how
it's
used
a
lot
of
people
who
are
just
getting
started
with
Vector
types,
treat
them
like
like
regular
structs
and
so
they'll
go
in
they'll,
go
and
modify
a
single
element
directly
or
they
won't
consider
the
impacts
of
you
know
doing
four
different
operations
is
actually
more
expensive
than
doing
it
as
one
vector
operation,
and
so
the
the
risk
of
us
going
in
and
enabling
the
what
we
call
type
Sim
D
recognition
everywhere
is
that
we
will
end
up
massively
regressing
many
other
people's
scenarios,
because
you'll
you'll
get
the
in
registration
and
then
you'll
end
up
getting
a
bunch
of
extracts
or
shuffles
to
move
the
elements
around
do
the
scalar
operation
and
then
move
it
back
into
the
right
position.
B
We've
made
a
lot
of
progress
towards
recognizing
the
patterns
and
improving
those,
but
we're
still
not
quite
to
the
point
where
we
can
just
flip
the
switch,
and
it
might
honestly
be
better
if
we
go
with
some
kind
of
opt-in
approach
where
we
have
this
functionality.
It's
general
purpose,
but
it's
opted
into
users
for
their
types
via.
You
know
some
I
am
a
vector
attribute,
but
with
a
better
name.
A
Yeah
I
think
that
the
PCL
has
two
types
it
has
like
quaternions
and
things
like
that.
Just
also
kind
of
the
reason
why
it's
I
mean
it
still
hasn't
taken
that
long,
but
it
has
taken
quite
a
while
for
like
the
sport
to
start
and
then
like
go
anywhere
while
if
from
the
start,
the
idea
would
have
been,
we
want
Vector
types
of
BCL,
but
we
don't
want
to
do
anything
special.
Then
I
feel
like
there
would
be
much
more
pressure,
I
guess
on
finding
a
solution
there
versus.
C
Yeah
absolutely
I
think
I.
Think
with
a
lot
with
a
lot
of
these
things
is
I
mean
I
kind
of
like
how
Ross
strikes
a
balance
with
having
lib
call
and
lib
standard
in
the
core
is
the
fundamental.
C
I
I
think
dot-net
C
sharp
it's
very
unique
in
that
it
doesn't
have
a
well
language
core
Library,
it's
just
all
the
BCL
like
if
there's
a,
if
there's
a
type
that
is
required
by
the
language
specification,
it
is
in
the
BCL
and
not
in
not
in
some
other
library.
That
is
just
the
fundamentals
to
make
the
language
work,
but.
B
At
the
same
time,
the
the
spec
does
allow
for
such
an
environment
to
exist.
Yes,
so
if
you
were
to,
if
you
were
to
you,
know,
look
at
Cosmos
or
Midori
or
the
the
open
source
version
of
Midori,
which
was
Singularity
you
can
you
can
very
much
see
that
they
have
basically
that
lib
core
for
the
the
OS
loading
step,
and
then
they
pull
in
the
full
core
lib
later,
which
is
basically
the
kernel.
C
Yeah
yeah,
it's
I,
don't
know,
I,
think
I.
Think
the
things
that
make
most
languages
are
unique
is
that
it's
the
way
that
they
approach
the
sort
of
division.
I
mean
you
know,
I,
think
C,
Sharps
Pro
main
selling
point
has
always
been
its
physical
integration.
C
I
mean
even
back
when
when
we
were
on.net
one
and
its
main
selling
point
was
it's
it's
win32,
but
better
and
it's
while
net
has
grown
a
lot
past,
that
its
anchor
has
always
been
to
some
other
Microsoft
tool
that
you're,
probably
using
and
I,
think
it
works
really
well
as
that.
But
at
the
same
time
it
is
also
a
great
Library,
so
yeah
a
great
a
great
tool
set.
C
So
yeah
I
think
if
every
language
approach
this
problem
the
same,
then
there
wouldn't
be
any
point
to
use
one
language
over
another.
C
Anyway,
snuck
in
at
the
back
there,
how
are
you
doing.
B
D
Silk
for
side
stuff,
but
nothing
major
yet.
C
That's
cool
wow,
it's
a
it's
a
hell
of
a
first
copying
code
to
catch,
so
obviously
the
last
coffee
we
were
discussing
the
sort
of
structure
of
Civil
Right
3.0.
C
Now
that's
now
that
some
now
that
a
non-zero
amount
of
effort
is
going
into
the
the
development
of
the
3.0
finally,
but
because
we
do
need
it,
so
we
will
talk
about
the
the
package
structure
at
last
time
and
I
think
we
landed
on
some
pretty
good,
some
pretty
good
ideas
that
will
be
formalized
in
a
proposal
at
some
point
and
this
one.
C
This
one
comes
off
the
back
of
a
I,
wouldn't
say
heated
debate,
but
you
know
some
extensive
discussion
around
how
we
approach
how
we
approach
unsafe.
This
is
unsafe
in
the
library,
so
I
I,
guess,
let's
just
jump
right
into
that.
So
for
those
of
you
who
don't
know,
I
mean
since
silver
neck
was
first
developed,
we've
had
a
number
of
neighboring.net.
Foundation
projects
come
to
light,
so
clang
sharp
is,
which
is
a
PN
vote.
C
Generator
is
now
part
of
the.net
foundation
as
well
as
Terror
effects,
so
we've
we've
sort
of
expanded
the
bindings
portfolio
a
bit
and
one
of
the
things
that
one
of
the
things
that
makes
Terror
effects
unique
is
that
it
does
focus
on
completely
raw
unsafe,
as
if
you're
writing
C
code
in
C,
sharp
one-to-one,
direct
mappings
and
so
then,
as
always
prided
itself
in
being
one-to-one
direct,
but
making
Guild
code
feel
more
at
home
with
C
sharp
and
one
of
the
opportunities
I
identified
with
the
3.0
development
is
to
try
and
really
really
Embrace
that
in
the
really
what
I
want
to
get
to
is
that
all
these
uh.net
Foundation
bindings
offerings
use
clang
sharp
as
a
common
base.
C
So
that
way,
there's
there's
the
same
stability
across
the
entire
portfolio
and
yeah,
and
that
way
there's
no
compromise
between
picking
Terror
effects
but
terrafx
interrupt
sorry
versus
silt.net.
It's
literally
just
the
bindings
The
Binding
style.
We
prefer.
C
However,
at
the
same
time,
we
don't
want
to
alienate
the
entire
supplement.
Well,
the
subset
of
the
supplement
user
base
that
do
like
the
unsafe
aspect
of
it.
We
want
to
be
that's
seamless
as
well,
so
it's
strugging
that
balance
that
we
discussed
extensively
yesterday
and
how
we
should
approach,
because
what
are
the
problems
with
silk.net
2.0
is
that
they
try
to
do
everything.
Okay,
try
to
have
it
all
which
it
tried
to
have
managed,
overload.
C
Well,
there's,
unquote,
safe,
overloads
and
role
such
unsafe
overloads,
and
it
it
because
we
generated
all
the
permutations
of
that.
It
resulted
in
some
amusing
cases
where
he
had
like
65
000
overloads
for
a
single
function,
which
we
cannot
do
again
for
3.0.
C
So
one
of
the
things
I
came
up
with
in
silk
X,
which
is
a
experimental
interpretation
of
that
I
started
of
3.0
goals.
It
is
not
3.0
yet
it's
is
that
we're
using
sort
of
like
rapper
strikes
to
sort
of
have
like
almost
duct
typing,
really
so
that,
if,
if
you
have
a,
if
you
have
a
a
pointer,
wrapper
struct
and
it's
it,
it's
t
is
bite
or
S
byte
you
can
cat.
C
You
can
just
pass
in
a
string
and
implicitly
casts
and
implicitly
Marshall's
using
that
rapper
type,
rather
than
having
to
generate
loads
of
overloads
and
generate
loads
of
Martian
code
with
it,
and
one
of
the
extensive
discussion
points
which
I
think
we
should
just
pick
right
back
up
is
is
whether
we
should
have
that,
in
addition
to
the
raw
and
safe
overloads,
to
make
sure
that
well,
the
beginner
users
that
don't
want
to
use
the
the
scary
rapper
types
can
just
use
unsafe
and
yeah
I
ended
up
going
to
bed
after
we
were
discussing
all
that.
C
So
why
don't?
We
I
think
this
guy?
That
was
probably
a
really
old
discussion.
So
did
you
want
to
expound
on
what
was
discussed
yesterday.
F
I,
don't
really
know
you
know,
because
I
came
in
a
bit
late,
so
the
pointer
types
that
I
didn't
really
understand
too
much
about
them,
but
yeah
I
still
very
much
think
the
concept
of
using
those
sort
of
types
may
cause
confusion
to
to
some
users,
especially
those
who
are
who
are
new
and
they
see
the
types
and
they
sort
of
go
I.
Don't
really
know
what
that
is.
I
was
just
expecting
an
array
and
so
I've
sort.
F
You
know
it
so
that
that
was
the
point
that
I
was
making
yesterday
was
was
instead
of
doing
that.
It's
just
kind
of
you
know
it's
either
unsafe
and
then
just
an
overload
that
takes
an
array
and
then
that's
it,
which
I
I
know.
You
said
that
was
done
in
version
1.0
and
there
was
some
problems
with
the
style
of
overloads
or
something
like
that.
But
on
a
personal
level,
that
was
what
that's,
what
I
prefer
to
use.
F
C
So
I
suppose,
to
give
some
context
to
what
at
what
we're
going
to
be
talking
about
is
so
I've
actually
got
a
rough
demo
of
the
generation
pipeline
working.
So
this
is
invoking.
C
Clang
show
up
feeding
the
raw
bindings
into
Rosalind
and
then
modifying
them
to
to
make
them
safer
and
silkier,
and
we
haven't
got
to
pretty
names
yet
we're
still
raw
names,
but
we've
started
investigating
the
use
of
wrapper
types
and
I
suppose
the
the
the
key
point
for
me
was
to
always
make
sure
that
the
the
rapper
types
could
be
implicitly
converted
to
from
an
unsafe
type.
C
So
it's
if
you
wanted
to
use
fully
unsafe,
you
could
just
you
could
just
pretend
that
the
signature
takes,
that
unsafe,
pointer
type
and
it's
it
just
implicitly
converts
it's
magical
and
because
of
the
how
good
the
the
just
inside
compiler
is,
these
days
it
all
gets
in
lines
and
there's
no
unnecessary
fixing
or
pinning
or
method
calls
or
whatever
it's
basically
equivalent,
but
I
guess
I
guess,
given
we
have
that
already
I,
don't
want
to
jump
the
gun
and
well
we've
got
to
have
unsafe
as
well,
so
that
you
know
it's
an
option
like
I
I
am
well
it's
well
forcing
people
to
read
the
documentation
in
detail,
isn't
necessarily
what
what
I
would
want
to
do.
C
At
the
same
time,
you
can't
I
think
it's
a
but
I
I'm
not
objected
to
adding
unsafe
overflows,
but
I
think
it
should
be
for
the
right
reasons
and
thinking
that
our
users
should
be
able
to
use
this
Library
without
reading
a
liquor.
Documentation,
I,
don't
think,
is
the
right
one.
A
A
Or
something
overloads,
which
is
just
way
too
much,
and
it's
also
a
point
where
having
those
overloads
becomes
useless,
because
you
can't
really
look
at
the
time
signatures
anymore.
Anyways.
B
A
Won't
find
the
overloaded
in
what,
and
so
like
the
pointer
type
is
basically
the
like
a
way
to
combine
more
of
those
overloads
together,
but
yeah
I.
A
Just
like
a
general
problem
that
like
if
we
want
to
strongly
type
everything,
then
there's
just
too
many
and
the
comments
pointer
or
like
any
sort
of
like
combining
type,
is
just
sort
of
an
escape
hatch
out
of
that
and
yeah
I've
been
wondering,
like
really
I
can't
come
up
with
a
good
argument
that
differentiates
the
cons,
pointer
or
whatever
from
just
like
taking
object,
because
it's
really
the
same
logic.
I
think
so
I
would
be
interested.
What
you
think
I
mean
I
think
it
sounds
really
obvious.
A
That
is
a
bad
idea
to
just
take
object.
Just
an
argument,
but
I
also
can't
come
up
with
a
good
like
difference
between
the
pointer
types
it
just
not
having
typing
at
all,
because.
C
C
A
A
Just
don't
really
see
how
Constructor
helps
our
typing
problem
so
much
anymore,
because
because
I
think
it
has
the
same
ambiguity
problem
that
just
not
having
a
type
at
all
has
also
and
I
think
the
whole
point
we're
trying
to
do
with
this
is
provide
better
typing
than
just
having
a
pointer.
What
and
it's
not
just
about
easily
calling
the
functions
also
about
glow
input,
you
can
provide
and
I'm
not
sure
how
pointer
actually
helps,
but.
B
Yeah
well
and
I
I
think
there's
some
cases
like
glfw
create
window
here
where
cons,
pointers,
probably
the
wrong
type
to
use
in.
In
this
particular
case
you
know
you're
having
dependent
anyways
and
what
what
it
is.
Is
it's
a
it's
a
string,
it's
a
no
terminated
ski
or
sometimes
utf-8
string,
and
so
just
taking
read-only
span
of
byte
and
allowing
users
to
pass
in
a
utf-8
string.
Literal
is
probably
the
better
choice
because
then
it
becomes
friendlier
to
use
and
you
have
the
same
quote-unquote
penalty
of
pinning
here.
B
But
lately
the
latest
versions
of
the
runtime
will
actually
completely
align
the
pin.
If
glfw
create
window
is
inlined
and
a
title
is
determined
to
be
already
fixed,
such
as
from
a
stack,
Alec
or
or
something
like
that.
So
here's
a
case
where
you
can
make
it
better
and
remove
the
case
of
of
having
a
const
pointer
by
just
taking
the
read-only
span
a
byte
instead.
C
C
Answer
that
I'm
sure
that
has
some
problems
but
oh
well,
but
if
you
wanted
to
do
that,
you
can't
well,
okay,
you
can
I
swear
and
it
just
implicitly
occurs
and
I
I
guess
the
main
thing
from
a
possibility.
Point
of
view
is
that
if
you've
got
some
code
that
is
fully
unsafe
back
when
we
had
terrible
overloads
in
silk
one
it
just
pulled,
but
ports
forwards,
it
I,
guess
it.
C
We
are
trying
to
be
silk
in
the
with
you
know.
It
was
sort
of
flexible
to,
however,
the
user
wants
to
use
it
and
I
suppose
that's
that's
always
been
one
of
silvernet's
benefits.
Is
that
we've
never
we've,
never
forced
our
users
to
use
safe,
manage
stuff
and
I.
Think
the
user
for
the
the
well.
The
users
that
are
using
unsafe
has
always
respected
that.
B
B
It
then
provides
in
a
separate
mechanism.
B
Basically,
if
you
wrapper
types
such
as
CX
cursor
and
then
it
provides
instance,
methods
on
that
which
provide
the
quote:
unquote:
safe
and
net
friendly
versions
of
the
C
interface.
So
you
know
if
it's
an
API
that
takes
a
CS
cursor
as
the
first
operand
in
its
functionally
operating
like
an
instance
method
on
that
I'll
throw
the
the
API
in
there.
It
will
take
span
Etc
that
way,
users
who
want
to
operate
in
a
more
dot
net,
object-oriented
manner
can.
B
B
From
the
perspective
of
like,
let's,
let's
remove
the
the
interop
aspect
all
together
and
give
you
what's
what's
more
similar
to
a
properly
usable
API
surface
that
allocates
and
doesn't
worry
about
any
of
that,
and
this
is
extremely
friendly
to
use
and
you
you
could
imagine
doing
a
similar
thing
in
silk
you,
you
might
not
have
wrapper
types
like
a
like
a
glfw
window
type
that
has
instance
methods,
but
you
might
still
have
a
raw
interop
bindings
version,
that's
in
one
static
class,
and
then
you
have
a
second
package
which
is
basically
the
friendly
API
overloads
which
references
the
raw
package
and
and
calls
those
and
then
users
who
want
the
raw.
B
They
want
the
absolute
perf.
They
can
remove
all
the
middle
layers
and
use
it
directly,
but
the
users
who
want
to
use
a
mix
or
want
to
have
the
you
know
they
want
to
be
able
to
pass
in
string,
literals
or
any
or
arrays
or
spans
and
just
get
the
get
it
all
handled
for
them.
They
have
that
other
package
they
can
use.
Then
you
don't
have
to
worry
about
overload
resolution
conflicts.
B
You
don't
have
to
worry
about
making
breaking
changes
across
them
or
anything
because
you
just
have
the
you
have
those
two
very
distinct
boundaries
for
the
distinct
cases
that
you
want
to
support.
F
B
F
Kind
of
what
I
was
trying
to
suggest
yesterday
as
well
and
I,
I
I
I,
think
that's
a
a
I
quite
like
that.
In
terms
of
you
know
just
from
a
usability
point
of
view,
because
for
anyone
that
wants
the
lower
level
unsafe
stuff,
then
it's
pretty
much
no
different
from
the
C
API.
But
then
there's
the
the
high
level
one
which
takes
in
arrays
and
strings
and
all
that
sort
of
stuff,
and
it
allocates
and
does
everything
that
you
know
to
make
it
nice
and
safe
for
the
user.
F
But
so
and
it's
somewhere
in
the
documentation
would
be
written
that
you
know
there's
an
unsafe
version
of
this
as
well.
That
doesn't
do
all
of
the
extra
allocation
and
stuff,
but
for
most
users,
I
I,
don't
think
they'll
be
that
bothered
I!
Think
they'll
just
want
to
take
a
string
or
an
array
or
whatever
and
just
pass
it
in,
and
it
does
all
the
stuff
and
they
don't
need
to
worry
about
the
underlying
code
and
whatever.
A
D
Wanna,
oh
sorry,
sorry
I,
don't
want
to
derail
this
and
hopefully
but
I
I
have
a
question:
I
haven't
actually
used.
Terafx
is
I'm
under
the
impression
keep
in
mind.
I
haven't
used
hair
effects
but
I'm
under
the
impression
that
terafx
has
the
bindings
around
opengl
and
Vulcan
as
well
as
silk.
So
there's
there's
overlap
there
right
and
isn't
terafx
designed
to
use
the
unsafe.
D
All
right
is
this
conversation
kind
of
I,
I
guess
what
I'm
trying
to
ask
is
this:
is
this
conversation
kind
of
trying
to
decide
the
design
of
silk
to
fill
a
different
Niche
than
terafex
they're.
B
They're
not
quite
the
same
so
so
terafx
doesn't
provide
opengl
I,
mostly
consider
opengl,
well
I
personally.
Consider
opengl
like
deprecated.
Basically
there's
a
lot
of
things:
I
don't
like
about
it.
I
plan
on
never
using
it
myself,
so
I'm,
just
not
planning
on
ever
providing
it
I
do
provide
Vulcan
and
DirectX
bindings
for
11
and
12,
though
now
the
one
of
the
big
differences
between
the
raw
Bindings
that
Silk
provides
and
the
raw
Bindings
that
that
terrafx
provides
is
terafx
is
literally
one-to-one
with
C.
So
you
get
the
underscores.
B
B
That
way
you
can
write
your
code
more,
like
you,
wouldn't
see.
So
it's
it's
basically
as
close
to
at
include
windows.h
or
include
vulcan.hs.
You
can
get
in.net,
whereas,
whereas
silk
is.
A
B
Some
creative
there's
been
some
creative
differences
in
how
the
naming
goes.
So
you
know
it
you'll
correct
the
casing
of
it.
They'll
remove
the
underscores
from
the
name,
and
things
like
that,
so
it
will
be.
It
will
look
more
like
a.net
API,
even
if
it
is
unsafe
and
taking
the
pointers
and
everything
like
that.
Yes,.
C
D
Yeah,
my
I
I,
don't
obviously
I'm
only
one
user
but
as
as
someone
who's
been
casually
coding,
Graphics
code
for
quite
a
while,
but
never
been
super
serious
about
releasing
a
thing
or
whatnot,
but
a
casual,
even
myself.
I
would
prefer
straight
straight
bindings
to
the
Sea
personally,
so
that
I
don't
know
how
much
another
one
opinion
matters,
but
that's
my
opinion
I
actually
actually
prefer.
C
That
yeah
I
think
I
think
the
split
is
probably
50
50
on
people
who
wouldn't
who
want
to
want
some
ccrp
names
versus
people
who
want
it
one.
You
know
completely
raw
names
and.
A
C
Why
these
two
libraries
exist,
I
mean
Terror
effects
is
completely
as
you
want
it,
as
you
would
use
it
in
C
and
C
sharp
is
always
well.
It
is
for
those
people
who
want
something
a
bit
bit
silkier
to
use
and.
D
I'm
gonna
ask
another
dumb
question:
if,
if
silk
is
just
intended
to
essentially,
if
one
of
the
goals
is
to
make
it
friendly
to
use
from
C
sharp
with
C
sharp
conventions
and
whatnot,
is
there
any
reason
that
we,
what's
the
benefit
of
continuing
to
do
custom
bindings
versus
essentially
making
a
silk
uh-ish
wrapper
around
Terror
effects
and
have
terafx
be
the
base?
I'm
not
I
realize
that
they're
separate
projects
and
different
people
have
worked
on
each
one,
but
I'm
I'm
just
curious.
If,
if
they're
competing.
C
Too
much
the
answer
is
literally
just
maintenance
effort.
We
want
something
also
generated
so
that
we
don't
have
to
manually
write
hundreds
of
functions.
That's
it.
A
You
know
I
think
so,
I
think
it's
I
think
it's
lots
of
difficult
for
us
to
like
make
more
bindings.
That's
probably
also
not
so
difficult
for
us
to
make
fully
managed
findings.
I
think
the
difficulties
mostly
where
we
mix
them
so,
for
example,
like
it's
very
common
I,
think
for
people
to
when.
D
A
A
Think
that's
where
it
gets
harder
for
us
to
make
the
functions
and
that's
ultimately
with
all
of
the
orthod
notes,
came
from
into
an
O,
because
we
want
to
support
cases
where
you
have
that
array
of
endpointers,
because
the
pointers
are
averaged
and
they
came
from
some
other
API
where
they
came
from
like
wherever,
basically
like,
usually
from
the
same
API
or
maybe
from
like
another
like
model
parser,
you
use,
that's
like
written
in
C
doesn't
really
matter.
So
it's
like
an
unmanaged
pointer.
C
That's
why
we've
come
out
with
the
the
implicit
types
where
you
know,
whatever,
whatever
you
want
to
pass
in,
you
just
implicitly
cast
it
to
this
rapper
type
and
it
it
it's.
It's
got
your
back
sort
of,
but
it's
it's
very
different
to
what
binding
other
bindings
libraries
are
doing,
and
so
that's
fundamentally
where
it
comes
from.
Is
that
but
it's
it's
the
deviation
for
the
sake
of
usability
really.
A
Give
you
the
proper,
like
suggestions
again,
but
right
now,
if
you
have
a
like
a
variable
in
scope
with
the
right
type,
your
IDE
could
probably
recommend
you
use
that
for
the
argument,
or
maybe
you
have
a
variable
with
like
the
right
type
and
then
even
like
the
naming
is
similar
and
your
ID
will
be
smart
to
like
tell
you.
Oh,
this
is
probably
what
you
want.
A
C
I,
don't
know
there
are
things
we
can
do
with
like
well,
the
resharper
plug-in,
which
we
keep
promising,
will
eventually
be
released,
but
if
we
could
add
stuff
to
that,
but
it's
it's
obviously
relying
on
tooling
to
make
that
work.
C
B
A
C
A
That's
probably
not
great
code
but
yeah.
That's
a
good
example
of
what
this
might
look
like
and
I.
Think
that's
like
one
of
the
places
where
you
might
look
at
that
function
and
then,
like
not
realize
you
can
use
an
array
because
we
don't
like
with.
Consequently,
we
just
don't
have
really
any
typing
on
like
what
the
possibilities
are
anymore
and
that's
kind
of
what
I'm
worried
about
that.
Even
if
you
like
look
at
the
dogs,
if
I
kind
of
know
what
the
type
does
it's
quite
unintuitive
to
use
it.
Yet.
B
C
My
Hope
with
as
much
as
these
points
types
are
weird
I
hope
that
I
can
summarize
like
how
you
can
get
a
feel
for
using
these
bindings
in
just
a
few
sentences
like
oh
well.
If
you
want
to
pass
a
ref,
do
a
DOT
as
pointer
at
the
end
of
it.
It'll
automatically
convert
it
or
if
you
want
to
pass
a
string,
you
just
pass
the
string
it.
C
You
know
sentences
like
that
where
I,
ideally,
you
can
just
read
this
one
page
and
know
how
to
use
the
bindings
in
the
way
you
want,
because
that's
really
the
important
thing
we
could
be
a
direct
rule
mapping.
But
then
we
just
again,
we
just
tear
effects
with
pretty
names.
C
It
just
it
just
ten
like
over
10
overloads
and
it
starts
becoming
an
absolute
nightmare
to
know
what
you're
doing
you're,
probably
less
even
and
it
starts
becoming
a
nightmare
to
figure
out
what.
E
A
Don't
know
about
this
Visual
Studio
or
in
my
piece
folder,
or
something
like
that,
but
I'm
pretty
confident
that
if
you
like,
as
soon
as
we
tightened
the
first
derivative,
the
like
Rider
can
illuminate
all
of
the
other
overloads
already,
because
you've,
essentially
given
the
first
time
and
so
as
you
keep
putting
in
your
property
or
your
parameters,
it'll
get
progressively
better,
of
course,
for
some
functions,
it's
so
unreasonable,
but
for
something
like
enumerate
device.
A
Extension
properties,
I
think
the
system
works
really
well
because,
like
yes,
there's
like
lots
of
all
those,
but
it's
not
so
many
that
it
would
be
a
problem
and
it
is
in
the
end,
fully
typed,
which
is
just
I,
think
better
across
the
board
for
like
all
the
tooling
that
exists
as
long
as
it's
not
too
many
of
us
so
for
most
functions.
I
feel
like
this
is
kind
of
okay,
yeah.
C
This
maintenance
effort
is
like
you
know
we
have
to
well.
We
either
have
to
codify
when
that
point
is
which
okay
we
can
do,
but
also
it's
and
documentation
as
well
I
mean
we
have.
We
have
never
had
an
API
reference,
probably
because
the
amount
of
overloads
that
we
have
it's
an
API
reference
becomes
pages
and
pages
long,
and
you
know
if.
A
C
I
mean
I
I
would
probably
disagree
that
I,
probably
because
I've
tried
both,
but
it's
I,
but
yeah
I
really
don't
know,
I
put
I
I
personally
think
if
it,
the
thing
is
with
the
point
types
is
that
it's
only
that
initial
curve,
but
where
we're
going
to
have
any
impacts
once
the
user
has.
You
know
read
that
initial
paragraph
on
our
website
and
it's
saying
how
to
bind
it's.
C
You
know
we're
past
it
and
yeah.
A
C
It's
an
inconsistent
experience
and
once
you've
hit
a
function
that
would
have
otherwise
generated
thousands
of
overloads,
you're
gonna
have
to
learn
anyway.
F
A
Because
I
like
I,
would
love
to
talk
to
like
or
like
I
haven't,
really
look
into
this,
maybe
there's
some
documentation
somewhere.
They
don't
know
how
to
PC
opposite
with
Stan,
and
we
only
spend
because
I
think
it's
the
same
thing
we
would
be
doing
basically,
like
you
just
introduce
some
type
that
like
that,
combining
something
from
other
things
and
you
can
like
use
a
new
apis
but
I
think
it's
not
so
easy
to
just
say.
A
Well,
once
you've
read
it
once
it's
like
done,
I
think
even
now,
after
I've
used
span
for
probably
thousands
of
lines
of
code,
I
still
find
it
not
that
intuitive
to
use
I
know
what
it
does,
but
it's
so
not
the
same
intuitive
experience
that
you
would
get
with
her.
It's
obviously
worth
the
the
trader,
but
just
seeing
like
the
the
type
is
I
think
easier
and
it's
also
easier
to
like
copy
for
using
it
like
your
own
class,
and
you
know,
like
often
you
have
things
where
you
have
like
code
refactorings.
A
That
say
like
use
the
same
type
of
the
inside
things
like
that,
where
it's
like
it's
it's
often
easier
with
just
an
explosive
type,
but
I
I
would
have
to
look
up
what
I
don't
actually
even
know
what
the
current
state
is,
the
vpcl,
whether
they
want
to
only
use
one
or
whether
they
still
do
a
very
expensive
I.
C
Mean
so
I
I
mean
obviously
not
BCL
developer,
but
I
mean
the
spans
are
a
relatively
trivial
case,
because
the
same
implicit
operations
on
regular
span
are
also
applicable
for
read-only
span
and
likewise
a
full.
A
read,
write
span
implicitly
cast
to
a
read-only
span.
If
you
want
to
use
it
that
way,
so
the
usability
trade
block,
it's
a
lot
less.
There.
A
A
It's
the
same
that
we
would
have
right,
like
consequential
and
normal
pointer,
but
basically
Loosely,
cast
that
out
so
I
think
it's
very
similar.
Just
the
water
types
has
to
more
types
has
to
our
like
custom,
pointer
type
and
test
to
expect.
C
A
Sure
but
I
guess
so.
This
could
be
like
another
way
to
do
it.
I
guess
it's
like.
Could
we
not
just
accept
everywhere,
so
it's
pointer
or
staff,
because
that
would
also
be
valid,
basically
everyone
what
about
riffs,
but
you
can
make
a
reference
to
this
fan
and
technically,
oh.
C
C
A
First,
like
the
pointers,
do
you
make
one
type
for
every
possibility,
or
do
we
find
some
other
way,
but
like
that
I
think
the
discussion
we
ended
up
on
yesterday
is:
do
we
want
pointer
types
like
another
type
at
all,
and
or
do
we
just
want
like
I,
think
that
was
the
discussion
that
we
had
yesterday
but,
like
I,
think
do
we
want
this
at
all
I
think
the
the
alternative
to
like
having
our
own
funnel
type
would
sort
of
be
using
standard
right.
Yes,.
C
A
C
Well,
let's
suppose
one
thing
is
that
spans
have
lengths
as
well
as
the
pointer
but
a
reasonable
right,
we're
sure,
but
when
you
implicitly
cast
an
array
to
a
custom
pointer
type,
which
is
basically
just
a
standard
span,
but
with
some
more
stuff
on
top
of
it,
it
throws
away
the
length.
C
Well,
I
suppose
it
again,
this
there's
the
use
case
of
like
well
right
now,
with
this
current
design,
you
can
just
pretend
that
the
functions
are
unsafe.
If
you
really
want
to
use
it
like
that,
I'm
trying
to
it
the
way
that
I'm
approaching
this
is
I'm
trying
to
get
the
solution.
That
is
the
most
flexible
for
all
of
our
users
and
it's
a
very,
very
hard
balance
to
strike.
C
But
I
think
that
should
be
the
main
approaches.
Sure
we,
if
you
want
unsafe,
go
to
terafx.
That's
the
that's
the
official
stance
from
brazil.net
Project
I'm,
happy
to
say,
because
it's
the
dot,
it's
the.net
Foundation,
it's!
C
If
you,
if
you
want
to
dot
net
Foundation
binding
that
is
unsafe,
that's
terafex's
Forte
open
to
their
effects,
please,
but
at
the
same
time
we
don't
want
to
alienate
all
about
users
who
have
loyalty,
silk
or
who,
who
want
the
pretty
names,
for
example,
if
all
you
want
is
a
library
with
pretty
names,
then
I
still
want
you
to
be
able
to
use
something
that
exactly
how
you
would
as
if
that
was
the
only
thing
we
offered.
A
Yes,
I
think
value
is
our
president
going
to
reduce
review.
A
You
can
comment
on
like:
why
would
you
I
think
you
mentioned
you'd
be
like
happy
to
have
space,
but
you
wouldn't
be
so
happy
to
have
like
a
classified
on
that.
F
It's
just
it's
for
two
reasons,
maybe
not
even
two.
The
main
reason
for
the
custom,
but
not
for
kind
of
suggesting
staying
away
from
the
custom
pointer
types
is
because
I
don't
personally
think
if
someone's
coming
from
say
C
someone
shouldn't
need
to
read
some
documentation
to
be
able
to
use
the
functions,
they
should
just
be
able
to
see.
Oh,
this
takes
an
array.
F
Good
I'll
just
create
this
array
and
then
pass
it
in
and
then
it
works
as
expected,
and
then
you
know
there's
the
unsafe
one
for
for
people
like
me
who
do
want
it
and
yeah.
That's
that's
why
I'm
sort
of
against
the
pointer
custom,
pointer
types.
A
Right
but
so
I,
don't
really
understand
where
the
difference
is
in
terms
of
like
coming
from.
Ceo
also
have
to
be
documentation
if
we
were
to
use
and
so
I
I,
don't
really
see
the
difference
in
like
that
argument
between
pointer
and
spawn.
F
Yeah
I
mean
I,
can't
really
say
much
about
spans:
I,
don't
use
them.
I've
used
them
like
twice
I
I,
don't
see
really
the
point
in
their
existence,
so
I
can't
comment
on
spans,
particularly
it
is
and
I
think
for
a
lot
of
people.
You
know,
bands
might
not
be
something
they
would
use.
They'd
just
use
raw
arrays
or
pointers,
but
maybe
having
yeah
span
would
be
good
as
well.
I,
don't
really
know
the.
A
B
So
the
the
99
of
Developers
are
never
going
to
learn
about
span
they're,
probably
never
going
to
use
Spam
directly,
but
there
is,
in
general,
the
the
need
to
have
an
abstraction
over
a
region
of
memory
in
a
fast
and
efficient
manner
and
so
spam.
What
span
represents
is
it
allows
you
to
pass
an
array?
It
allows
you
to
pass
in
a
pointer
with
a
corresponding
length
and
you
can
have
one
algorithm
that
supports
both.
But
on
top
of
that
you
can
also
pass
in
a
slice
of
an
array.
B
So
you
can,
you
can
ask
you,
can
have
an
an
overall
allocation,
Eve
or
even
a
list
of
T
that
contains.
You
know
thousands
of
elements,
but
if
you
only
want
to
pass
in
a
hundred
of
those,
then
you
can
just
slice
and
take
that
take
a
reference
to
those
100
elements
pass
it
into
your
algorithm
and
you
still
have
one
algorithm
supporting
all
three
scenarios:
whether
you're
unsafe,
whether
you're,
safe
or
whether
you
want
to
be
safe
and
allocation
free
and-
and
so
that's
really.
B
The
reason
why
span
existed
so
that
a
framework
and
Library
authors
can
make
their
they
can
provide
an
overload
that
provides
more
functionality
and
that
provides
the
core
of
their
algorithm
without
having
to
maintain
multiple
copies
and
without
having
to
worry
about
perf
considerations
or
anything
like
that.
Another.
D
Random
user's
opinion
is
I
would
never
make
a
method
that
takes
a
raise
when
you
could
take
a
span
just
I
just
wouldn't
do
it.
Spans
are
only
going
to
become
more
and
more
common,
going
forward,
they're,
just
a
relatively
new
feature
that
hasn't
not
not
every
Ctrl
developers
learned
yet,
but
I
mean
it's
going
to
become
more
and
more
popular
going
forward.
So.
B
So
the
the
big
issue
and
why
you
want
to
still
continue
providing
both
Ray
and
span,
there's
kind
of
two
parts
to
it
and
it
it
really
depends
on
what
kind
of
scenario
you're
in
so
CLS
compliance
isn't
really
that
much
of
a
thing
anymore.
It's
the
the
concept,
still
exists,
but
the
actual
attribute
isn't
correctly
tracked
anymore.
The
bbcl
still
cares
about
CLS
compliance
from
the
perspective
that
the
original
intent
of
it
was
to
ensure
that
any
apis
we
expose
in
the
BCL
can
be
used
from.
B
Basically,
any
language
span
is
itself
a
very
special
type
if
CLS
compliance
still
existed,
ref,
structs
and
therefore
span
would
be
considered
non-compliant
because
they
are
not
usable
from
every
language.
So
that's
why
the
BCL
still
provides
array
and
span
overloads
now,
even
on
top
of
that,
you
still
have
this.
Other
consideration
of
span
is
a
relatively
Advanced
concept
it.
B
It
is
both
simple
in
the
fact
that
it's
just
memory
you're
just
taking
a
a
region
of
it
and
tracking
it,
but
the
advancedness
comes
from
it
being
a
ref,
struct
and
ref
structs
having
extreme
limitations
on
how
they
can
be
used.
Both
because
they
track
an
interior
point,
they
can
track
an
interior
pointer
to
the
GC,
but
also
because
there's
limits
on
how
they
can
be
used
and
passed
around.
B
For
example,
if
you
return
a
span
and
you
take
in
your
passing
in
a
ref
there's
a
lot
of
things
that
will
suddenly
become
illegal
to
do,
the
compiler
will
stop
you,
because
now
you
could
be
accidentally
capturing
that
span
outside
the
lifetime
of
what
that
ref
is
supposed
to
live
around.
B
A
Yeah
yeah
I
know
for
you
by
chance
to
know
what,
like
the
I
guess,
stands
for,
like
I
think
influence
oriented
apis
I
guess
is
in
like
ecl
like.
Is
it
just
a
Spano
or
do
they
still
do
stand
and
erase.
B
Or
for
basically
any
API
we
expose
in
the
BCL,
because
it's
the
BCL,
we
basically
provide
both
a
span
and
a
array
overload,
and
that's
because
we
want
to
make
sure
that
that
F
sharp
can
use
it.
We
want
to
make
sure
C,
plus,
plus
CLI,
can
use
it.
We
want
to
make
sure
VB
can
still
use
it.
There
are
some
notable
exceptions
in
Niche,
apis,
intrinsics,
Primitives
or
things
like
that.
B
Interop
and
memory
Marshall
Primitives
or
things
where
you
have
to
deal
with
raw
pointers
anyways
and
where
there's
already
not
going
to
be
an
expectation
that
any
language
can
use
it
and
for
those
cases
we
will
only
provide
a
span
overload.
But
those
are
those
are
very
much
the
minority
case.
A
Authoritative
but
I
guess
by
that
logic
it
would
make
a
lot
of
sense
for
us
to
say
the
race
at
least:
don't
really
make
sense,
and
if
anything
there
should
be
spam
everywhere.
B
Yeah,
so
so,
for
silk
in
particular,
I
think
that
silk
and
tariff
exercises
in
the
same
boat
it
it's
providing
interrupt
bindings,
you're,
already
exiting
the
safety
of
dot
net,
the
safety
of
the
GC
and
any
kind
of
language
guarantees
that
c-sharp
provides
you're
doing
some
you're
you're
executing
a
p
invoke.
So
no
matter
what
that
signature
is
you're,
doing
something
that's
fundamentally
unsafe,
and
if
we
were
designing
P
invokes
today
we
would
probably
have
them.
B
We
would
probably
have
them
annotated
as
unsafe
callers
only,
and
you
would
only
be
able
to
call
a
p
invoke
from
something
that
is
itself
marked,
unsafe
and
so
I
think
in
that
context,
that
providing
just
span
overloads
is
fine,
but
that's
also
why
four
terafx
I
went
with
the
approach
of
just
provide
the
raw
bindings
and
if
users
want
to
write
their
own
minimal
rapper
over
it,
for
like
I've
got
this
API
where
taking
in
a
span
makes
sense
because
I
do
it
everywhere,
then
they
can
just
write
that
minimal
helper
themselves.
A
Yeah
everything
that
makes
sense
so
yeah
I
think
my
like.
Maybe
someone
disagrees,
you
know
I
think
my
conclusion
would
be.
That
span
definitely
makes
sense
everywhere
and
that
maybe
we
want
to
have
our
own
like
sort
of
stand
like
fight,
but
that
has
a
little
bit
more
unmanagedness,
but
that
maybe
handles
multi-dimensional
things
a
little
bit
more
for
a
little
bit
better,
but
I
think
in
general.
It
definitely
makes
sense
to
have
something
like
that,
because
it
just
like
looking
at
the
rest
of
the
ecosystem.
C
Yeah
so
I
guess
so:
I
guess,
if
we,
if
we're
still,
we
still
obviously
need
to
account
for
more
multi
multi-indirection
pointers,
so
I
mean
if
we,
if
we
were
going
for
the
span,
read
only
span
route,
we
still
need.
We
still
need
a
span
spam.
We
still
need
a
span,
read
only
span,
we
still
need
a
read-only,
read
only
span
span
and
whatever
and
that's
just
two
dimensions.
C
Then
we
go
into
the
three
dimensions
to
you
know:
keep
that
cons
correctness
that
or
if
you
just
want
to
completely
ignore
cons
correctness
I
mean
we
can
and
make
things
a
lot
easier
for
ourselves,
but
I.
A
Think
having
constructed
slice
and
I
think
we
discussed
this
yesterday,
I
think
it
could
make
a
lot
of
sense
to
just
make.
A
Looking
generic
type
that
that,
like
expresses
this
accurately
but
I,
think
we
discussed
about
it
yesterday
and
I
kind
of
got
sidetracked,
so
not
not
super
sure
what
your
thoughts
just
like
doing
that.
C
C
Suppose,
in
any
case,
if
we're,
if
we're
going
the
span
route,
then
we
are
explicit.
We
are
making
an
explicit
decision
that
you
can't
use
raw
pointers
because,
or
at
least
not
without
manually,
cursing
them
to
a
span
or
whatever
other
multi-dimensional
span
type.
We
make.
A
Yeah
so
I
think
I
I
think
the
idea
would
be
that
stands
so
regular
supersede
pointers.
A
C
Okay,
so
you'll
you'll
content
with
shutting
off
the
users
that
do
want
to
use
unsafe.
A
C
That's
the
main
point
is
that
it
if
we're
going
to
spam
route
yeah,
that
sounds
great.
That
sounds
like
they
are
very
good
decision
to
make
from
a
from
a
high
level
perspective.
It's
the
existing
users
who
ones
are
pretty
ones,
are
pretty
names,
but
still
using
raw
pointers
side
of
things.
With
this
code,
with
the
current
design
you
can,
you
can
still
do
that,
because
everything
magically
implicitly
casts,
but
you
won't
be
able
to
do
little
spans,
especially
considering
span,
is
the
type
that
we
don't
control.
A
A
So
I
think
your
design
is
having
multiple
types
that
like
face:
I
guess
just
like
pointer,
that's
funds
pointed
and
there's
like
I
guess,
constant,
smooth
pointer.
There
is
mood
point
to
this
like
once
once
pointer
for,
like
3D,
Etc
right
I
think
that's
basically
a
design.
C
Yeah,
pretty
pretty
much
I
mean
I
was
going
to
Shorter
the
name
to
PTO
PTO
and
PTO
mute
or
mute
PTO.
A
A
C
Up
to
three
dimensions
but
I
suppose
the
thing
is
with
this:
like
I
I,
really
like
this
design
that
you
came
up
with
yesterday,
I
mean
I
had
a
1am
thought
that
I
did
put
in
team
talk
is
that
we
can't,
we
won't
be
able
to
add
implicit
casts
from
typed
pointers,
because
the
language
doesn't
allow
that
if
we've
got
a
PTR
type
T
the
the
the
the
thing
you're
casting
to
has
to
be
PTO
type,
T,
not
PTO
type,
Intel,
PTL
type,
PTR,
int
or
whatever.
C
Yeah
exactly
but
other
than
that
I
was
completely
happy.
A
C
A
C
Loud
no
I
think
that's
not
allowed
I
mean
there's
this
whack
it
in
sharp
lap.
A
C
Thing,
oh
sorry,
I'm
not
I'm,
not
screen,
sharing!
Oh
fix
that
soon.
C
C
All
right,
we
are
sharing
yeah,
not
allowed.
A
C
A
C
A
C
A
B
C
B
A
To
have
interface,
aesthetic
interfaces
and
restaurants
is
that
possible.
A
B
B
And
while
there's
there's
there's
some
things,
you
can
violate
there's
some
language
things
you
can
violate
using
around
operators
with
in
in
static
abstract
interfaces.
You
can't
violate
everything.
B
It's
the
only
implicit
operator,
you're
defining.
Then
then,
what
you
can
do,
and
and
notably
this
won't
work
for
same
assembly,
but
it
does
work
for
cross
assembly,
provided
that
the
language
will
actually
resolve
it
during
the
lookup
and
it
might
not
because
it
would
end
up
finding
pointer
of
pointer
pointer
of
t.
But
you
can
you
can
you
can
define
an
operator
using
the
op
underscore
name
and
Mark
it,
as
with
the
with
the
special
name
attribute
and
then
another
assembly
referencing?
B
A
C
A
C
So
I
suppose
I
suppose
we're
at
the
point
where
we're
at
the
hour
and
a
half
mark.
Where
do
we
go
from
here,
then
so
I
I
mean
I'm
more
than
happy
to
continue
down
the
road
I'm
already
going
down
and
to
figure
out
after
everything's
implemented
how
usable,
how
usable
it
is
because
vitamin
C
this
is:
silk
X.
C
This
isn't:
silk
3.0
I
just
want
to
propose
ideas
to
sell.net
team,
but
but
at
that
yeah
I
suppose
what
have
we
decided
on
is
today
or
what
do
we
want
to
decide
on
the
route
forward
game
to
be
I.
A
Mean
honestly,
it
kind
of
just
depends
on
what
you
want
to
do,
because
really
it
was
just
the
oh.
It
was
at
least
just
me
seeing
that
you
wanted
to
like
T4
generate
pipes
yeah.
That
has
to
be
a
bad
solution,
but
it
really
depends
on
what
you
want
to
do
and
I
think
this
is
mostly
just
like
an
idea
that
we
have
yeah.
C
Absolutely
I:
don't
like
the
the
idea
of
having
56
types,
I,
think
that's
terrible,
but
at
the
same
time,
I
I
I'm
happy
to
make
that
sacrifice
in
silk
it
in
the
core
library.
For
the
sake
of
our
users,
usability
and
I'm,
happy
to
continue
down
that
road
to
figure
out
how
much
of
an
impact
that
is
but
yeah
I.
Suppose
if
If
This
Were
to
become
real
silk.net
3.0,
what
decision
would
we
want
to
make.
C
A
So
I
can
only
say
what
I
think
and
I
guess.
This
is
me.
A
So
I'm
a
fan
of
having
these
types
that
are
very
pretty
on
the
outside
and
or
terrible
on
the
inside,
because
I
think
that's
like
good
developer
experience
and
it
doesn't
really
matter
to
us
because
we
like
have
to
write
this
like
ugly
code,
what
we
don't
really
care
so
so
I'm
a
fan
of
doing
this
but
yeah
I,
don't
know.
C
Yeah,
that's
what
that's
what
I
think
as
well
I
mean
with
everything
we've
always
made
sacrifices
for
the
silk.net
team
to
make
it
easy
for
our
users.
I!
Think
that's
the
that's
the
responsibility
of
a
good
Library
framework,
but
yeah
I
suppose
I
mean
I.
Can
I
can
implement
it
see
if
I
can
you
know
hide
it
away
right,
instead
of
like
maybe
making
them
nested
classes
instead
of
instead
of
regular
classes,
so
that
you,
the
user,
doesn't
accidentally
run
across
them.
C
It's
there's
lots.
We
can
do.
A
And
you
can
absolutely
make
it
our
42
and
pointer
marketing
all
of
those
assets.
I
guess.
Another
thing
that's
like
interesting
is
that
with
the
design
of
pointer
will
be
like
this
is
the
generic
design
you
do
enable
users
to
make
their
own
things
widgets,
while
with
the
56
types,
it
seems
quite
unlikely
that
anyone
else
will
ever
actually
write
an
extension
method
or
things
like
that
for
all
of
56
types.
They
might
do
it
for
the
like
three.
A
C
Well,
okay,
I
guess
the
so
I
guess
the
route
we
could
go
is
that
if
we,
if
we're
happy
with
custom
types,
we
could
I
mean
the
the
code
I've
written
for
silke
so
far
is
up
on
my
personal
GitHub
by
all
means
Fork
it.
If
you
can
figure
out
a
way
to
make
this
pretty
like.
Instead
of
having
you
know,
56
types
you
can
figure
out
a
way
to
I,
don't
know,
maybe
maybe
cut
that
really
cut
that
by
66
or
whatever.
C
Then,
please
do
because
really,
ultimately,
the
the
solution.
The
solution
that
we're
going
to
ship
with
is
the
one
that
gets
implemented
and
it's
all
well.
I
think
the
mistake
that
we
did
make
certainly
with
the
initial
iteration
of
3.0,
that
you
start
working
on
Kai,
is
that
it's
an
absolutely
beautiful
design,
but
no
one's
working
on
it.
Yes
and
it's.
It
requires
a
lot
of
works
that
have
a
shippable
3.0.
C
So
it's
please
by
all
means,
take
the
work
that
I've
done
and
try
and
Implement
a
better
solution.
But
if
no
one
does
that,
then
there
is
going
to
be
no
better
solution.
A
I
agree,
I
will
yeah,
you
know,
I'll
see,
maybe
I'll
send
you
something
like
that
and
maybe,
if
we
can
make
it
pretty,
I,
don't
need
I
think
this
is
interesting.
General
also
the
same
problem
advice
to
my
design,
I
guess
so
it's
like
this
is
something
you
have
to
come
up
with
at
some
point,
anyways.
C
Yeah,
absolutely
it's
a
it's.
A
nice
generation
framework
that
if
someone
does
want
to
make
a
make
a
sort
of
generator
picker
mix,
then
they
absolutely
can
take
this
work
that
we've
already
done
and
spin
it
off
into
its
own
Library.
Whatever
I
think
with
my
my
silk
act,
so
far
is
like
you,
you
will
be
surprised
how
little
code
there
is
in.