►
From YouTube: S310 - What's new with F# 4.5
Description
Have you heard? F# 4.5 is out! This new version of F# brings some wonderful capabilities with Span T and lower-level programming, better stack traces for async programming, and much more. In this talk, you'll learn all about F# 4.5 and how you can use it today!
A
That
this
is
Phillip
Carter,
we're
talking
about
f-sharp.
He
was
telling
about
all
these
amazing
things.
You've
heard
nothing
of
that.
So
that's,
let's
get
back
to
it
and
maybe,
like
start
a
little
bit
over
again,
maybe
run
through
that.
A
B
Version
of
the
f-sharp
language
came
out.
We
love
it.
It's
pretty
great,
has
some
pretty
cool
stuff
in
it,
so
I'm
gonna
go
through
that
and
then
I'm
going
to
show
you
how
to
get
started
for
existing
f-sharp
developers
and
people
who
are
new
to
the
language.
It
should
be
pretty
easy
to
get
started.
So
there's
a
quick
list
of
the
feature
set,
so
we're
lining
versions
with
some
assets
and
existing
f-sharp
developers
should
be
very
happy
about.
This.
I
know
that
I'm
incredibly.
B
B
B
Is
kinda
nice
we
have
better
async
stack
traces
so
for
our
asynchronous
computation
expression
feature
Diagnostics
should
be
a
little
bit
easier.
So
we
like
that,
a
lot.
We
have
value
option
of
to
you,
which
is
similar
to
option
of
T,
except
it
is
a
value
type.
So
it's
a
struct
rather
than
the
the
heap-allocated
one,
and
so
there's
there's
that
type
and
a
little
bit
of
stuff
with
it.
B
But
it's
kind
of
more
a
building
block
for
some
future
things
that
we
want
to
do
with
it,
and
then
we
have
some
smaller
goodies
in
the
escort
library.
Just
some
nice
improvements,
some
small
performance
improvements
bug
fixes
lots
of
community
involvement
there
and
a
few
kind
of
utility
functions
that
kind
of
make
your
life
easier,
so
cool
yeah.
So
let's
talk
about
versioning,
it's
everybody's
favorite
thing
to
talk
about.
Hopefully
we
made
it
less
confusing
and
that's
our
four
point.
One.
You
had
s
sharp
language
version.
B
B
B
B
B
A
B
It's
pretty
much
good
for
everything.
I
mean
it's
a
general-purpose
functional
programming
language.
So
a
lot
of
systems
that
you're
writing
the
other
state
and
stuff
like
that.
So
functional
programming
is
all
about.
Oh
I,
don't
wanna
have
global
state
I,
don't
want
to
manipulate
state
in
place
or
anything
like
that,
but
most
of
the
stuff
that
people
write
are
actually
functionally.
If
you
think
about
chaining
HTTP
call,
it's
like
you
know,
you're
giving
you're
giving
something
input.
B
B
So
when
you're
building
these
sorts
of
things
using
a
functional
programming,
language
will
give
you
defaults
in
the
language
that
sort
of
make
it
easier
to
do
that.
Okay,
whereas
when
you're
using
something
like
c-sharp,
although
you
can
certainly
use
it
for
these
sorts
of
things,
the
defaults
of
the
language
are
like
you
know:
everything
is
mutable
by
default,
so
you
kind
of
go
towards
a
path
of
mutating
values.
All
the
time
when
you
may
be
working
in
a
context
where
you
don't
want
to
mutate
anything,
and
so
with
with
f-sharp.
B
A
great
question
guys
all
right
cool.
So
so,
let's
talk
about
some
more
f-sharp
four
point:
five
features
span
of
T
and
Friends
is
actually
depending
on
how
you
count.
I'm
gonna
count
it
as
eight
new
features.
Okay,
so
there's
there
are
some
new
types
in
ref
t
out
ref
of
t.
There's
this
this
type
called
a
by
ref,
which
has
existed
in
F
sharp
for
quite
a
while,
but
it
hasn't
really
been
fleshed
out.
It's
basically,
this
managed
pointer
type,
but
we
didn't
really
have
good
support
for
low-level
programming
with
that.
B
B
We
have
a
lot
of
safety
checks
for
using
by
refs
and
by
reflect
types
which
is
kind
of
the
the
thing
that
holds
it
all
together,
because
you
you
want
to
be
able
to
do
low-level
programming
in
a
high-level
language,
but
the
whole
point
of
using
high-level
language
is
to
be
safe,
and
so
we
basically
restrict
what
you
can
do
similar
to
how
some
of
the
newer
versions
of
c-sharp,
like
c-sharp,
7.2
and
some
point
three
restrict
usage
of
certain
things.
Like
span
of
T.
We
basically
apply
very
similar
safety
checks.
B
So
I
want
to
reiterate
that
span
of
T
is
a
by
hreflang
type,
so
we
have
the
ability
to
consume
and
produce
these
by
our
F
like
types
and
one
of
the
most
important
ones
that
exists
in
dotnet
court
today
is
a
span
of
T.
So
this
is
it's
kind
of
important
to
sort
of
flesh
out
everything
around
being
able
to
use
that
effectively.
So
that's
we're
doing
so.
Let's
dive
into
that
a
little
bit
by
ahrefs
it.
B
We
sort
of
this
trifecta
they're
kind
of
they're
related
to
one
another
algebraically,
there's
n
ref
by
RF
and
out
Ref.
We're
in
ref
is
read-only
pointer.
Basically,
it's
saying
that
the
basically
the
the
person
or
I
guess
I
should
say
the
caller
that
has
a
handle
to
that
pointer
can
only
read
the
value
you
cannot
write
to
it.
A
by
ref
is
readwrite.
B
You
can
do
you
know,
basically
whatever
and
then
an
out
ref
for
compatibility
reasons
is
actually
has
the
same
semantics
as
by
RF
similar
to
how
it
exists
in
c-sharp,
but
it's
there
for
documentation
purposes,
because
you
sort
of
want
to
indicate
that
oh
I'm
only
writing
to
this
pointer
I'm,
not
really
reading
anything.
There.
A
B
They
have
some
sub
subt
rules,
so
you
could
pass
in
like
if
you're
expecting
an
in
rent
out
ref,
you
could
pass
in
a
by
Rath
network.
So
there's
some
safety
guarantees
when
you
use
these,
which
did
not
did
not
completely
exist
prior
to
F
sharp
4.5.
So
you
can.
They
cannot
be
used
outside
the
scope
that
they're
finding.
B
So
if
I
define
an
N
ref,
for
example,
or
a
by
RF
in
a
given
scope
and
then
I
try
to
have
that
reference
escape
that
scope,
somehow
so
like
say,
I
have
a
function
and
then
I
try
to
have
the
reference
to
that
value.
That
I
defined
inside
of
that
function
escape
the
function
scope.
We
disallow
that
completely
that's
actually
unsound
and
it
can
lead
to
depending
on
the
way
you
use
that
value
a
crash
at
runtime,
even
though
the
code
compiles
just
fine.
A
B
A
B
B
That's
also
a
similar
thing.
A
heap
allocation
could
occur,
and
so
the
usage
is
restricted.
But
that
means
that
you
can.
You
can
be
very
confident
in
sort
of
the
safety
of
the
stuff
that
you're
doing
there.
So
I
want
to
show
a
little
bit
about
what
that
code
sort
of
looks
like
so
you
can
see
some
of
these
in
action,
cool.
A
B
A
B
A
B
A
B
A
B
Okay,
so
in
this
case
I
can
I
can
read
the
value
and
I
can
write
the
value.
So
if
I
call
these
so
let's
go,
let's
create
a
let's:
let's
say:
that's
12
and
let's
have
num2
is
13.
Okay,
I
can
go
print,
num
like
that,
and
that's
totally
just
fine.
So
this
is
so
this
right
here.
This
is
how
you
sort
of
make
something
a
a
by
RF
in
this
case
right.
A
B
Print
takes
in
an
in
ref
I'm,
basically
getting
a
reference
to
num
here
now.
If
I
try
to
do
this
check
this
out,
okay,
I
get
an
error
now.
The
reason
why
is
because
num
2
is
still
immutable
yet
I'm,
taking
a
by
ref
and
I'm
mutating
the
value
so
so
like
I,
what
you
need
to
do
is
you
need
to
actually
explicitly
make
this
mutable,
and
so
the
error
message
sort
of
says,
like
you
know,
you
know
you're
not
passing
the
right
thing.
B
A
B
This
is
some
sort
of
you
know
that
this
is
sort
of
stuff
that
you're
not
likely
to
write
this
sort
of
code
in
all
of
your
f
sharp
programs,
but
certainly
when
you're
doing
something
that
is
like
very,
like
you
know,
there's
small
kernel
of
your
system
that
is
like
a
hot
loop
or
something
like
that,
or
anything
like
that.
You
can
eke
out
some
more
performance
like
this.
B
Let's
say:
I:
try
to
define
a
value
X
and
then
what
mutable
12,
sorry
that
mutable
y
equals
12,
and
then
we
escaped
Y
from
the
scope.
This
is
that
scoping
rule
that
I
said
right.
There
right,
I
defined
Y
to
be
inside
the
scope
of
whatever
X's,
but
by
saying
oh
well,
there
were
the
effectively
saying,
oh
well,
this
reference
to
this
value
that
I
that
I
defined
it's
out
of
here.
This
is
actually
escaping
nesco.
So
I
can't
do
that.
B
Similarly,
if
I
defined
this
value
inside
of
one
of
these
functions
and
then
I
tried
to
extract
a
reference
out
of
the
definition
that
function,
it
won't
allow
me
to
do
that.
So
basically,
you
have
to
try
really
really
hard
to
screw
up
your
program
with
using
these,
because
any
of
the
ways
that
you
could
sort
of
fall
into
one
of
those
traps
it'll,
basically
not
compile
cool.
A
B
So
that's
that's
something
that
we're
we're
happy
about,
because
safety
is
basically
one
of
the
top
reasons
why
you
should
even
use
a
high-level
language
or
especially,
a
functional
language
where
safety
is
one
of
the
things.
That's
oftentimes
brought
up,
there's
one
of
the
strong
virtues
of
functional
programming,
so
we're
taking
that
quite
seriously.
So
there's
also
a
by
ruff
Returns,
which
I
mentioned
so
an
F
sera
4.1.
We
we
had
support
for
consuming
them,
but
you
couldn't
produce
them.
B
So
this
was
a
feature
that
came
out
in
c-sharp
7.0
and
it
was
useful
if
you're
doing
programming
with
like
unity
or
something
like
that
where
you
want
to
well
basically
return
to
by
ref
and
perhaps
mutate
the
mutate,
the
underlying
values,
while
also
doing
work
at
the
same
time.
So
we
allowed
ya
consuming
them
and
you
could
sort
of
have
fun
with
that,
but
you
couldn't
produce
any
code
like
that
enough
sharp!
B
You
would
have
to
write
that
in
c-sharp,
so
we
change
that
now,
an
extra
four
point:
five
you
can
both
produce
and
consume
them.
A
return
value
is
implicitly
dereferenced
when
you
consume
it.
So
we
match
the
same
sort
of
behavior
that
c-sharp
has
there.
We
also
implicitly
be
reference
of
value
inside
of
a
for
loop.
B
This
is
helpful
if
you're
looping
through
a
span,
and
you
need
to
do
something
with
each
sort
of
offset
that
you
got
there
and
then,
if
you
want
to
sort
of
pass
a
reference
around,
you
know
the
different
different
call
stuff
like
that.
You
just
use
that
that
reference
operator
that
I'd
show
really
cool
so
I'm
just
going
to
show
you
what
some
of
that
looks
like
here,
so
we
got
this
by
ref
returns
got
here.
Let
me
just
set
this
as
a
start
up
project.
Okay,.
A
B
Do
that
with
some
very
very
immutable
code
like
a
counter
that
I'm
decrementing
as
I
have
a
while
loop
and
then
the
key
thing
here
is
I,
don't
return
the
actual
value
I
return
a
by
rat
to
the
value
simply
like
in
both
branches
in
this
case?
So
if
you
look
at
the
type
signature
here,
it's
giving
given
an
end
to
produce
a
by
ref
event
rather
than
and
into
there.
Okay,.
A
B
A
B
Okay,
so
this
is
gonna
print
out,
basically,
just
that
same
137,
15
31,
that
sort
of
stuff,
then
we'll
create
a
target
and
I'll
just
call
it
16
and
then
we'll
have
the
results
equal
to
I'm.
Using
this
by
RF
operator
here,
because
sort
of
when
you
work
with
by
RF
returns
you
the
value,
is
implicitly
dereferenced
to
get
the
actual
value.
But
if
you
want
to
work
in
terms
of
the
ref,
then
you
just
dereference
that
actual
call
okay.
A
B
B
Yeah,
you
can't
talk
thinking
co2,
this
F
okay.
So
now
we're
going
to
call
to
string
again
so
recap
I'm
just
to
stringing
the
underlying
thing,
I'm,
calling
this
fine
largest,
smaller,
then
and
then
I'm
mutating
the
value.
So
this
value
that
it
gives
me
back
is
actually
a
reference
to
one
of
these
items
in
this
array.
That's
underlying
alright!
So
just
go
ahead
and
do
that
debug
run
this
without
debugging
and
it
should
give
me
a
value
here
pretty
soon.
B
Okay,
so
you'll
notice,
these
two
sequences
are
different
right,
so
the
underlying
value
is
1,
3,
7
15,
but
then
the
second
time
ever
there
was
one
3
7:30.
That's
because
I
had
a
reference
to
the
underlying
value
inside
of
there
so
sort
of
again,
not
the
sort
of
thing
that
you're
gonna
be
doing
in
everyday
f-sharp
programming.
But
if
you
are
in
a
situation
where
you
need
to
do
like
very
high
performance
work,
you've
literally
need
to
be
working
in
terms
of
pointers.
This
is
the
sort
of
stuff
that
you
can
do.
Gotcha.
B
In
a
safe
way
cool,
so
then
we
also
have
by
reflex
struts,
which
basically
it's
it's
an
attribute.
You
can
just
apply
to
an
f-sharp.
Struct
type
can
be
applied
to
struct
records,
discriminated
unions.
We
actually
have
a
bit
of
an
issue
with
the
years,
but
the
discriminated
unions
so
I
wouldn't
quite
use
it
right
now,
but
anyways.
What
it
allows
you
to
do
is
sort
of
say,
oh
well,
I
have
a
value
type
that
I've
defined
I
can
now
give
it
by
ref
like
semantics
right
right.
B
So
what
that
means
is
okay
cannot
be
allocated
within
another
allocated
type,
so
I
can't
have
a
class
that
then
has
one
of
these
structs
inside
of
it.
If
it's
a
by
reflex,
struct
right
so
I
can't
use
it
in
the
class
or
normal
struct.
Because
of
the
normal
structure,
you
can't
guarantee
that
it
won't
be
allocated
on
the
heap.
I
can't
do
it
in
a
non
struck,
directed
I
can't
do
it
in
the
non
struct
discriminated
Union.
I
cannot
use
it
as
the
type
of
a
record
or
a
discriminated
union
case.
B
It
cannot
be
captured
by
a
closure
construct
and
it
cannot
be
used
as
a
generic
type
parameter
and,
as
I
mentioned
before,
span
of
T
is
a
by
ref
like
struct.
So,
very
briefly,
we'll
just
see
what
that
means
here
here,
I
have
my
fun
little
struct
here
and
I
got
a
bunch
of
red
squiggles.
It's
unhappy,
ok,
the
reason
why
it's
unhappy
is
because
this
s
is
a
struct.
It's
just
a
struct.
There's,
no
guarantee
that
this
this
won't
be
allocated
on
the
heap
yet
span
of
T
is
a
read-only.
A
B
A
B
B
B
Can't
screw
up
basically
right:
okay,
we
also
have
read-only
structs
so
is
read-only
is
actually
interesting,
because
structs
and
s
sharp
are
basically
already
read-only
just
due
to
the
semantics,
the
f-sharp
language,
but
that's
only
something
that
other
f-sharp
callers
could
really
benefit
from.
As
far
as
c-sharp
was
concerned
and
Esha
obstruct
is
just
a
regular
old
struct.
A
B
B
With
f-sharp,
this
is
sort
of
already
been
the
case.
The
the
state
of
the
world
for
F
sharp
only
solutions
is
basically
the
same,
but
if
you
need
to
interoperate
with
some
newer
c-sharp
code
and
they're
expecting
read-only
structs,
you
can
do
this,
and
so,
as
an
example,
read-only
span
of
T,
is
they
read
only
by
reflect
struct
so.
B
You
could
create
your
own
read
only
span
like
my
fancy
read
only
span
if,
if
you're
up
for
the
challenge
and
and
you
could
do
that
as
well-
so
we
also
avoid
pointers
which,
which
are
great-
it's
an
untyped,
unmanaged
pointer
in
F
sharp
Kota.
This
is
basically
a
whatever
that,
wherever
you
want
it
to
be
sort
of
situation,
because
boy
pointers
in
C
or
whatever
they.
B
B
Exactly
and
so
we
have
some
native
point
of
five
functions
in
the
core
library.
You
can
convert
from
a
void
pointer
to
a
native
pointer
of
T,
and
you
can
convert
from
a
native
pointer
of
T
to
avoid
pointer
and
so
sort
of
the
difference.
There
is
that
one
is
typed
and
the
other
is
untyped,
so
you
could
say:
okay,
boy
pointer
is
just
some
stuff
yeah.
A
B
A
A
B
This
is
a
community
contribution
by
John,
Washington
Berkeley,
said:
remember
the
effort.
Thank
you.
People
really
love
this
feature
already,
so
we're
pretty
happy
about
it
and
it
simplifies
pattern
matching
and
Esther
okay,
and
so
it's
often
used
with
async
code
that
returns
in
a
serve
option.
So
I'll
show
what
that
looks
like.
B
A
B
B
B
Just
calls
try
parse
int
async
with
an
STR
string
that
gets
passed
in
and
then
it
just
binds
that
result
to
a
value
called
result.
But
results
is
not
an
int.
It's
that
end
option
so
I
need
to
know
a
pattern
match
on
that
result
and
do
something
in
this
case
printed
out
or
saying
not
an
int
depending
on
what
it
is.
Okay,
this
is
fine.
B
B
Okay
and
notice
that
it's
still
not
quite
happy
because
you
know
it's
saying:
oh
well,
I
got
an
async
event
option
rather
than
an
option
so
that
you
just
need
to
make
it
match
thing
and
all
of
a
sudden,
that's
happy
now,
and
so
what
this
does.
This
is
basically
just
syntax
sugar
for
what
you
previously.
A
B
B
So
he
said:
okay,
can
you
write
an
RFC
for
it
and
I
said
yeah
sure,
so
we
wrote
this
back
and
then
he
gave
us
a
pull
request
and
then
we
just
worked
with
him
on
the
four
requests
and
sort
of
helped
him
with
some
of
the
errors
and
stuff,
and
he
he
did
it
very
very
well,
and
then
we
merged
it
in
awesome.
Now
it's
in.
B
A
B
That
one
yeah
it's
a
fun
one.
Yes,
it's
just
nice
makes
me
I
like
when
things
are
cleaner.
Yes,
so
then
we
got
relaxation
in
your
code,
you
like
to
be
relaxed
right.
There
you
go
yeah
so
got
some
fancy
words
up
cast
with
yield
and
f-sharp
sequence
list
and
array.
Expressions
use
of
the
up
cast
operator
is
no
longer
needed
when
you
need
to
use
a
super
type
with
yield.
B
And
a
UI
programming
library,
for
it
called
L
mesh
that
has
a
particular
style
of
programming.
You
eyes
that
would
run
into
this
indentation
problem
all
the
time
and
so
just
to
show
you
what
this
looks
like
I
got
my
relaxations
file
here.
So
this
first
one
is
collections
and
sumption
relaxation,
so
I
got
so
X
is
an
obj
list,
so
string
is
an
object
right
and
similarly,
in
a
list
of
write
list
of
string
is
an
object.
B
B
Something
that
you
may
find
a
little
strange
is
the
fact
that
okay,
so
I
have
this
Open
bracket
here,
but
then
this,
instead
of
being
over
here,
it's
it's
just
it's
right
underneath
the
hello.
This
was
something
that
was
required
in
f-sharp
4.1,
and
so
people
would
write
a
lot
of
code
that
looked
like
this,
and
then
they
get
an
annotation
warning.
Yeah.
B
B
A
B
You
would
write
code
that
kind
of
look
like
that,
but
then
somewhere
in
there,
you
did
this
when
you
actually
needed
this
and
it
was.
It
was
really
difficult
to
track
down.
So
we
just
kind
of
got
rid
of
that,
so
that
should
make
some
people's
lives
easier,
especially
if
they're
doing
UI
programming
with
fable
cool.
B
B
It's
adding
value,
so
let's
just
change
this,
so
you
know
how
I
have
this
sum
and
none
I'll
just
make
this
value
sum
value.
None
and
now
it
is
an
int
V
option
rather
than
int
option.
You
notice
this
doesn't
compile
here,
because
I'm
expecting
an
option
instead
of
a
value
option
and
we'll
just
modify
it
and
there
we
go
it's
you
use
it.
The
exact
same
way
to
use
options.
Today,
it's
just
it's
a
value
type
and
so.
A
B
So
there
are
some
cases
depending
on
how
your
system
runs,
where
value
types
can
be
more
efficient.
Okay,
you
always
got
to
measure
that
all
right,
those
cases
do
exist.
They
are
real
and,
more
importantly,
this,
this
optional
type
is
also
used
under
the
covers
and
some
other
F
sharp
constructs,
such
as
a
sharp
active
patterns
and
F
sharp
active
patterns,
are
something
that
a
lot
of
people
use,
because
it's
a
really
really
nice
way
to
sort
of
express.
B
The
combination
is
sort
of
like
the
notion
of
a
function
that
you're
a
pattern
matching
over,
and
so
you
could
not
create
struct
versions
of
those
and
so
well.
You
still
can't
do
that
today,
but
this
is
the
first
step
in
building
that
out.
Okay,
so
this
is
something
that
sort
of
again
was
a
community
not
on
a
community
contribution,
but
a
community
idea,
and
we
had
a
lot
of
discussion
with
people
there
about
sort
of
like
why
this
should
exist.
What
some
of
the
benefits
are
or
what
some
of
the
drawbacks
are.
B
We
had
some
community
involvement
and
writing
the
spec
for
this,
and
so
then
it
was
really
easy
to
implement,
so
we
just
implemented
it,
but
so
in
future
F
sharp
language
versions.
You
can
expect
more
stuff
to
be
built
out
around
to
this,
so
that
we
really
sort
of
flesh
out
the
idea
of
full
F
sharp
programming
with
value
types
and
reference
types,
cool
yeah
and
we
got
better
acing
stack,
traces.
A
B
Makes
sense
so
in
the
before
time,
information
and
stack
traces
was
basically
not
really
usable,
okay,
I'm,
not
gonna,
sugarcoat
it
it
sucked
and
and
like
you,
would
not
get
your
user
code
in
the
stock
trace.
You
would
not
get
your
line
numbers
in
the
stack
trace
so
like.
What's
the
point
of
a
stack
trace.
B
A
B
B
B
Let's
demonstrate
that
so
we're
gonna,
so
I'm
gonna
create
an
array
of
function,
calls
okay.
So
this
is
another
thing
functions
or
first-class
values
in
F
sharp,
so
you
can
do
all
sorts
of
fun
stuff
like
this,
so
print
12.
This
is
this
is
gonna
work,
alright
print
13,
that's
gonna,
work
as
well
print
that
that's
not
gonna,
work,
okay,
okay
and
we'll
go
async
parallel
all
right,
so
we're
basically
going
to
parallel
eyes.
B
B
B
No,
but
people
should
actually
benefit
from
this.
They
should
enjoy
this.
Even
though
stack
trace
is
not
necessarily
the
most
sexy
demo
here.
So
we
got
this
unhandled
exception.
I'm
sure
plenty
of
people
have
seen
something
like
this
before
the
font
is
big
enough,
but
something
I
want
to
call
out
here
all
right.
So
we
got
the
system.
The
system,
format,
expression,
sorry
exception.
B
This
number
string
to
number
parsing
32
parts,
but
then
right
here
at
program,
dot,
try
parson
async
in
program,
dadafest
line,
7
right
and
then
there's
there's
some
stuff
in
there
that
we
kind
of
want
to
get
rid
of.
But,
like
you
know,
it
shows
program,
dot,
prints
at
line
12
program,
dot
main
and
line
18.
So
that's
it's.
It's
still
not
perfect.
We.
A
B
A
B
B
So
there's
some
additional
f-sharp
Beck
or
things
just
nice
little
goodie
bag.
We
got
these
func
convert
api's,
so
this
is
for
c-sharp
Interop.
If
you
want
to
interoperate
between
c-sharp
action
types
and
f-sharp
function
types,
you
can
do
this
func
convert
dot
from
action
and
front
convert,
sorry
func
convert
to
action
and
we
have
various
overloads
for
them
that
match
the
overloads
of
c-sharp
actions,
and
so
with
previous
f-sharp
4.1.
You
didn't
have
this,
and
so
you
had
to
kind
of
create
this
little
contraption
to
interoperate
between
you.
A
B
A
B
Yeah,
okay.
Similarly,
we
have
map
try
get
value.
This
is
it's
similar
to
try.
Parse
API
is
in
F,
sharp
it
takes
in
and
by
RAF
returns
a
bool.
We
convert
that
into
a
tuple
for
F
sharp
callers.
It's
it's
just
a
nice
quality
of
life
thing.
It
actually
allowed
us
to
clean
up
some
various
code
paths
on
the
compiler,
so
we
were
pretty
happy
about
that
and
some
other
members
in
the
community
we're
happy
too,
and
then
there
were
just
kind
of
a
swath
of
general
improvements
in
bug.
B
B
Stefan
fork
Minh
with
the
SD
trick,
who
are
members
of
our
community.
They
just
they're,
constantly
submitting
a
polar
quests
that
improve
everything
and
and,
like
you
know,
a
lot
of
stuff
that
they
submit
its,
not
big
stuff.
It's
just
making
one
tiny
little
thing
better
and
over
time
it
just
makes
your
whole
life
better,
because
all
these
little
nuances
that
you
may
not
be
may
have
disliked
over
time
or
just
now,
all
of
a
sudden
better
and.
A
A
All
they
get
new,
alright,
that's
all
the
new
stuff,
so
alright
yeah.
So
we
don't
actually
have
a
live
scene.
A
lot
of
questions
throw
by
here.
Like
hey,
you
know
it's
I
like
Sal
of
c-sharp,
but
like
I'm,
really
having
trouble
getting
started
with
f-sharp.
Like
you
know,
I
like
where
was
one
of
them
was
like
about
indentations.
A
B
A
B
A
B
I'll
actually
bring
up
one
of
them
right
here.
So
there's
this
blog
called
F
sharp
for
fun
and
profit.
It's
a
really
really
extensive
blog
by
Scott
will
ashen
and
yeah
our
community,
and
so
like
there's,
you
know,
there's
some
some
cool
stuff
here,
but
then
what's
what's
nice
here
is
there's
a
thirty
part
series
on
using
s,
sharp
and
kind
of
comparing
and
contrasting
with
c-sharp,
and
so,
as
I
was
building
the
thing
that
I
needed
in
this
case
a
parser.
A
B
B
A
B
A
B
Version
of
Visual
Studio
do
this
is
version
15.8,
latest
version,
and
so
under
that,
like
you
know,
there's
there's
some
templates
there.
We
got.
You
know
some
Donna,
coarse
stuff,
some
unit
test
projects.
You
can
create
an
HP
nut
corn
web
app,
if
you
like,
it
uses
an
LP
API,
but
what's
helpful
with
that
is,
if
you
understand
that
API
you
could
kind
of
work
with
that
with
a
sharp
object
programming
and
then
like
slowly
sort
of
work
in
functional
things.
As
you
go.
Okay,
you
know
Donna
standard
class
libraries.
A
B
B
Most
importantly,
I've
installed
the
ini
to
f-sharp
plugin.
You
can
see
it
has
over
a
million
downloads
Wow.
This
is
actually
a
100%
community
thing,
but
I've
been
saying
it's
it's
really.
It's
the
it's!
The
official
f-sharp
plugin
for
Visual
Studio
code.
The
f-sharp
community
has
basically
been
building
this
out
and
it
is
updated
like
crazy.
All
the
time
I
definitely
recommend
using
it,
and
so
there's
some
some
pretty
neat
stuff
there.
You
can
get
a
little
tree
view
with
this
little
I,
Knight
icon,
that
you
got
in
there
and
so
I
got
my
program.
B
A
B
We
have
that
same
output
of
1
3,
7,
15,
137
30,
it's
so
like
this.
It
it
has
that
four
point:
five
in
there,
it's
just
the
done
at
this
DK,
just
done
it
new.
Whatever
you
got
everything
you
need
in
there
cool,
and
so
this
I
definitely
recommend
iodide.
It's
it's
really
really
great.
It's
got
like
good
tooling,
like
you
know,
that's
sort
of
stuff
I
can
so.
A
B
B
A
B
A
B
B
A
Well
great
presentation,
Phillip
looks
like
want
to
see
more
training
material
done
by
you
alright,
so
you
gave
us
a
great
resource
to
get
started
a
couple
of
places
to
go
guys
right
here.
There
was
a
question
earlier
on
how
to
watch
all
of
these
sessions,
like
you
can
go
to
our
YouTube
visual
studio
channel
or
you
can
go
back
to
channel
9
you
can
go
watch
shows
anything
like
less.
We
want
to
tell
the
community
here
about
F
sharp
like
get
started
and
start
using
4
or
5
get.
B
Started
get
started,
give
it
a
shot,
just
just
create
a
basic
console.
App
says
hello
world.
If
you're,
if
you're,
not
an
F
chart
programmer
just
try
it
out,
it's
a
lot
of
fun.
You
know
the
syntax
is
vastly
different
from
C
sharp,
as
you
can
clearly
tell,
but
it
that
that
difference
in
syntax
really
really
grows
on
you,
especially
as
you
start
using
different
types
that
so
like.
So
like
an
example
that
we
have
on
the
website
here,
let's
see
if
I
can
blow
this
up.
B
Creating
a
type
and
pattern
matching
like
this
and
c-sharp
is
like
an
order
of
magnitude
more
code
than
it
would
be
in
F
sharp.
And
so,
if
you
value
that
sort
of
stuff,
you
want
to
give
it
a
go
sort
of
see
what
different
programming
is
like
then
I
highly
recommend
checking
it
out
and
because
it's
all
running
with
dotnet
core
and
available
in
Visual
Studio,
and
you
know
basically
any
tool
you
like.
It's
really
easy
to
get
started
with
all.