►
From YouTube: F# Tooling Updates for Visual Studio 2017
Description
In this episode, Phillip Carter (@_cartermp) joins us again to give us an update on the F# tooling updates in Visual Studio 2017. Because F# is cross-platform, many of the changes made are available in all F# tooling, not just that in Visual Studio.
[01:18] - Getting F# support in Visual Studio 2017
[03:23] - Diving into the editor features
[11:00] - Scripting and brace completion
[20:16] - Code navigation
[21:35] - Show symbols in unopened namespaces
[23:41] - Experimental CodeLens for F# type annotations
[26:41] - Providing feedback on features
A
A
B
A
B
A
B
The
vs
installer
once
you
select
stuff
it
will
pop
up
something
that
looks
like
this,
where
you've
got
these
workloads,
so
there's
a
whole
bunch
of
stuff.
Try
not
to
get
too
caught
up
in
what
every
single
one
means
here.
The
two
important
ones
are
dotnet
desktop
development
and
asp.net
and
web
development.
This
will
give
you
a
whole
bunch
of
tools,
including
everything
that
you
need
for
F
sharp,
so
the
Donna
desktop
development.
There
is
also
an
additional
thing
you
may
want
to
select.
B
If
you
have
older,
F
sharp
style
projects
that
are
not
targeting
dotnet
core,
there
is
a
thing
here
called
an
individual
component
as
its
called
called
F
sharp
desktop
language
support.
All
this
does
is
bring
along
new
project
templates
that
create
older
style
projects,
they're
like
the
really
big
ones,
but
like
there's,
there's
a
lot
of
people
still
use
those,
and
so
you
can
select
that
that'll
bring
it
on.
A
B
B
C
B
You
have
that
all
installed.
Once
you
go
to
file
new
projects,
you
should
be
able
to
see
quite
a
few
options
under
f-sharp
there.
So,
like
I've
got
under
done
a
core
thing
like
you
know,
I've
got.
You
know
a
few
options
there.
I
can
create
some
unit
test
projects
if
I
like
I
can
create
a
web
app
if
I
like
I'm,
actually
not
gonna.
Do
that,
because
that
would
break
my
current
solution,
but
well
that
would
close
it
not
break
it.
Sorry,
but
once
once
you're
there
then
you're
sort
of
set.
B
Absolutely
so
what
I
did
is
I
went
and
I
I
went
ahead
and
I
cloned
the
F
sharp
dot
formatting
project,
which
is
a
big
community
project
out
there
that
lets.
You
do
a
whole
bunch
of
different
stuff.
It's
sort
of,
if
you
have
a
library-
and
you
want
to
you-
want
to
have
really
descriptive
comments.
That
sort
of
explain
like
how
you
should
use
this
library.
You.
A
A
B
Is
this
is
a
really
really
cool
project?
I
recommend
that
people
try
it
out
if
they're
interested
in
this
sort
of
thing
and
so
I
have
the
full
solution
open.
You
notice
on
the
I
move
this
over
onto
the
left
hand
side,
because
I
usually
prefer
it
that
way.
These
are
all
new
style
projects,
so
we
have
full
support
for
these,
so
you
know
you
can
edit
it
and
see
what's
in
there.
So
this
is,
you
know
the
much
nicer
project
file
format.
B
The
main
difference
between
this
and
c-sharp
is
that
with
f-sharp
you
specify
the
files
explicitly
rather
than
use
file
globbing,
because
file
ordering
is
or
yeah
it's
important
for
the
compiler.
So
but
yeah
you
got
all
these
and
so
we're
inside
the
markdown
parser.
Here
it's
kind
of
this
big
file
and
you
scroll
all
the
way
to
the
top
whole
lot
going
on
here,
but
I
think
I'm,
just
gonna
go
just
through
the
list
here,
as
we
go
through
this
yeah.
B
This
file
here
so
in
vs
2015,
there
was
sort
of
minimal
colorization
like
you
got
like
key
words
and
stuff,
but
then
everything
else
was
just
kind
of
like
black
text,
which
it's
fine.
Now
some
people
actually
prefer
that
and
you
can
actually
set
that
setting
to
be
that
way,
but
a
lot
of
people,
especially
those
who
had
been
doing
c-sharp
style
programming,
I've
gotten
used
to
semantic
colorization
right
so,
like
you
know,
types
being
able
to
be
colorized
as
like
teal,
for
example,
or
you
could
set
it
to
be
pink.
B
B
C
B
C
B
Okay,
so
you
notice
this
got
colorized
a
little
bit
differently.
It's
sort
of
this,
this
yellow
oranges
color.
It's
actually
a
bit
more
prominent
in
the
dark
theme
so
but
it'll
show
up
in
your
different
seeming
so
and
then
case
I'm,
just
creating
a
mutable
value
and
I'm
setting
it
and
that's
not
terrible.
B
F
sharp,
but
F
sharp
is
immutable
by
default,
and
so
it's
oftentimes
really
helpful
to
sort
of
see
like
at
a
glance
what
things
are
mutable
versus
what
things
are
not
mutable
based
off
of
colorization
sure
and
so
like,
as
as
you
go
through
and
actually
inspect
each
individual
value.
You
can
certainly
find
that
out
yourself,
but
it's
really
nice,
as
you're
just
kind
of
scanning
code,
to
sort
of
see
that
right
so.
A
B
B
Yeah,
so
no
hash
is
immutable
and
that's
why
it's
not
colored.
If
I
were
to
mutate,
this
that's
it
well.
If
I
were
to
say
that
it's
mutable,
then
it
immediately
changes
color
now
that
doesn't
necessarily
mean
that
it
is
being
changed,
but
it
means
that
it's
possible
of
being
changed.
Her
I
started
possible
to
be
changed
so
something
you
may
have
also
noticed
kind
of
this
left-hand
side.
Here's
there's
all
these
like
these.
These
dotted
lines
going
on.
There's
these
vertical
dotted
lines.
These
are
known
as
structured
guide
lines.
B
This
is
a
new
feature
that
shipped
in
vs
2017
and
it's
it's
all
based
off
of
you
know
the
actual
structure
of
the
code.
So,
like
you
know
these
I
can
I
can
use
outlining
in
this
case
and
sort
of
collapse.
Things
and
I
can
collapse
things
you
know
like
this
scope
is
inside
of
this
scope
that
we
see
here
so
this
this
function,
I
can
collapse.
B
B
Yeah,
so
this
this
can
actually
be
pretty
helpful
because
F
sharp
is
whitespace
significant,
and
so,
as
you
said,
so
it's
one
of
those
things
where
you
can.
You
can
usually
sort
of
notice
if
you
look
at
something
really
hard,
but
if
you're
just
kind
of
doing
a
quick
glance
at
something
seeing
this
vertical
line
sort
of
go
all
the
way
and
then
seeing
something
else,
and
that's
to
the
right
of
that
vertical
line
that
can
very
easily
sort
of
help.
You
like.
C
B
This
is
in
a
different
scope,
right
yeah.
So
then
we
also
have
speaking
of
colorization.
We
also
have
formats
trained,
colorization,
so
say:
I
wanted
to
print
out
this
value.
For
some
reason,
now
you
is
there
we
go
I'll
go
non-standard
value,
so
you
notice
that
the
the
actual
color
of
this
format,
specifier
inside
of
the
string,
is
different
right.
C
B
A
way
for
you
to
very
quickly
differentiate,
like
you
know,
we're
in
the
format
string.
Something
is
gonna,
be
so
that's
pretty
neat
nice
yeah
and
then
so
we
have
a
few
other
things
that
are
kind
of
cool,
which
you
probably
already
notice
like.
If
I
click
on
this
header
symbol,
you'll
notice
that
it
kind
of
highlights
the
other
things
inside
of
there,
that's
known
as
semantic
highlighting
it's
again
one
of
those
things.
B
That's
not
really
like
this
super
big
deal,
but
as
you
sort
of
click
things
you
can
see
kind
of
at
a
glance
where
it's
being
used.
Go
there,
it's
it's
one
of
those
things
that,
over
the
course
of
like
a
long
day
where
you're
just
looking
at
all
sorts
of
little
code.
It
really
helps
to
just
click
something
sort
of
see
where
it's
being
used
go
from
there
and
not
really
have
to
think
too
hard
about
where
the
thing
is
actually
being
used.
Sure
I'm.
C
B
C
B
Show
up
in
there
and
then
I
can
apply
those
changes,
and
this
works
across
the
solution.
So
it's
not
just
limited
to
a
single
file
right
and
similarly,
if
I
wanted
to
find
references,
I
could
just
do
shift
f12
here
and
then
it'll
bring
it
up
in
this
really
collapsed
window
that
I
have
here,
but
then
you
can
see.
This
is
the
city.
This
is
a
new
find
references
window
that
I
don't
know.
B
C-Sharp
and
VB
is,
and
you
can
you
can
sort
of
explore
things
like
that
as
well
right,
which
is
pretty
cool
another
one
that
we
have
is
breaks,
completion,
which
is
again
one
of
those
things.
That's
not
a
particularly
incredible
thing,
but
it's
it's
still.
It's
still
kind
of
nice.
You
know
if
I
want
to
define
like
a
little
inline
function.
There
I
could
say
that
you
know
that's
equal
to
or
not.
I
won't
do
that.
I
can
never
think
of
like
what
to
show
off
with
brace
completion.
B
Actually,
on
the
spot,
you
know
I,
think
I
know
what
I'll
do.
Okay,
I'll
create
a
new
script
file
here,
so
I
just
did
ctrl
n
and
this
script
file
is
just
kind
of
sitting
somewhere,
so
I'll
create
a
new
empty
class
that
doesn't
do
anything
important,
but
you'll
notice
that
as
I
typed
out
these-
and
that
was
actually
not
one
of
the
contacts
works
in.
But
this
is
a
context
which
actually
shows
up.
B
So
this
is
how
you
do
attributes
in
after
up
there
actually
two
characters.
So
if
I
want
to
do
this,
that's
not
an
actual
attribute
and
go
like
that.
That'll,
actually
work
and
I
can
say
that
that's
auto
open
which
this
would
actually
be
an
invalid
application
of
that
attribute.
But
you
know
I
can
go
from
there
from
so
there's
some
pretty
pretty
fun
stuff,
like
that.
Just
nice
little
quality
of
life
improvement
that
you
would
not
be
able
to
have
nvs
2015,
but
you
get
it
now
right.
B
Yeah
absolutely,
and
so
you
can
do
all
sorts
of
fun
stuff
so
sail
to
find
a
new
F,
sharp
type
here.
We'll
call
this
person
and
a
person
can
either
be
a
fillip
with
a
name
or
a
Cecil
with
a
name
right.
So
we're
the
only
two
types
of
people
that
can
exist.
I,
think
here
or
did
I
know
real,
can
never
type
and
think
and
talk
at
the
same
time
happens
to
all
of
us
right.
Okay,
so
I
have
a
new
type.
You
can
see
right
here.
B
Okay,
it's
Philip
of
string,
so
string,
it's
a
pretty
straightforward,
discriminated
union,
so
I'll
create
an
instance
of
one
of
those
I'll
go.
You
know,
Philip
is
Philip
and
give
myself
a
name
Philip.
That's
this
nice
redundant
code
here
and
we'll
do
that
with
with
Cecil
here,
but
instead
I
will,
let's,
let's
just
let's
just
do
that,
because
it's
pretty
common
for
me
to
miss
type,
something
like
that.
It's
and
immediately
you
get
a
compile
error
which
is
kind
of
cool,
but
a
little
light
bulb
popped
up.
I
go
there.
B
It
says
replace
with
Cecil
the
actual
version
of
it
so
like.
If
you
mistyped
something-
and
it's
and
it's
kind
of
close,
will
actually
detect
that
and
will
suggest
something
to
you
based
off
of
what
the
compiler
already
knows,
because
so
like
if
I
undo
this
you
know
sort
of
up
until
this
point,
the
compiler
has
already
figured
out
that
person.
You
know
there's
a
Cecil
class
in
here,
and
this
looks
like
it's
pretty
close
to
that.
So
that's
why
it
suggests
it
right
there
and.
B
Yeah,
this
is
based
on
whatever
the
compiler
knows
up
until
this
point
got
it
yeah
and
then
another
thing
that
you
may
have
noticed
is
that
Cecil
right
here
was
sort
of
grayed
out
I.
Guess
it's
not
quite
as
strong
of
a
color
as
Phillip,
because
logically
I'm
not
actually
using
it
I'm.
Using
this
thing
called
you
know,
CEC
see
like.
B
Well,
let's
just
call
it
squares
and
that's
you
know
we'll
just
go
we'll
have
an
in
line
last
year,
one
two
three
four:
five
and
we'll
pipe
that
into
list
map
fun
X
such
that
x
times,
X
cool,
so
you
may
have
been
thinking.
Well,
you
just
created
a
list
up
here.
Why
did
you
just
do
something
in
there?
Well,
that's
to
show
off,
like
all
of
these
are
sort
of
grayed
out
right
now,
because
they're
not
actually
being
used
by
something.
So
in
this
case
list
is
not
being
used
by
something.
B
So
the
compiler
knows
this
and
I
get
a
light,
bulb
suggestion
saying
like
hey,
it's
not
being
used.
Do
you
want
to
give
it
an
underscore,
as
a
name
is
sort
of
like
a
discard?
Oh
okay,
because
sometimes
it
is
valid
and
I've
sharp
code
to
sort
of
do
something
that
produces
a
value.
But
you
don't
really
care
what
the
value
is.
You're,
not
using
it.
At
this
point
in
time
and.
B
C
B
C
B
You
don't
need
to
do.
The
ceremony
of
a
whole
class
implement
this
interface
to
create
an
instance
of
the
class
like
you.
Can
you
just
do
this?
It's
really
helpful
for
unit
testing,
so
I'll
create
an
Aimable
instance
and
then
I'm
going
to
use
this
syntax
for
object.
Expressions
and
I'll
go
new
I
nameable
with
and
all
of
a
sudden
I
get
another
light
bulb
popping
up
right
here.
Okay
and
it
says,
implement
interface,
so
I
can
actually
choose
to
have
this
implemented
in
line
here
and.
C
B
B
B
Now
indeed,
I
could
I
could
do
this.
I
could
go
nameable
dot
get
name,
but
you
know
it's
a
little
nicer
to
do
in
the
editor.
Another
cool
thing
that
you
can
have
when
you're
scripting
with
f-sharp
is
scripting
is
sort
of
like
this
ad
hoc
sort
of
like
this
is
just
an
F
sharp
script.
What
it
actually
does
is,
when
you
send
it
to
f-sharp
interactive,
is
a
little.
It
basically
produces
a
script
file
in
there.
B
B
Well,
no,
the
syntax
is
still
sort
of
the
same
but
like
what
you
reference
and
like
sort
of
the
context
that
exists
in
there's
a
lot
more
free
there.
So
what
you
can
do
is
you
can
actually
load
additional
files,
such
as
additional
script
files,
so
notice
that
I,
just
typed
string
there
and
all
of
a
sudden
I
have
access
to
stuff.
That's
on
my
machine.
I
can
actually.
A
B
C
B
B
A
B
B
B
Let's
see
if
I
got
this
right
here,
so
you
may
have
noticed
that
if
I
hover
over
something
you
know,
yeah
I
get
the
colors,
but
there's
some
stuff,
that's
kind
of
underlying
it's
kind
of
weird.
You
mean
normally
I,
don't
see
that
if
you're
in
c-sharp
well,
that's
because
you
can
actually
click
on
it
and
it
will
go
to
definition.
Oh.
C
B
C
B
C
B
Clicking
you
can
basically
do
it
all,
which
is
pretty
sweet,
nice
yeah
and
then,
as
you
probably
noticed,
either
in
this
video
or
certainly
other
videos-
is
there's
just
Auto
completion
as
you
as
you're
typing
right.
So
a
type
name
and
I
get
nameable
kind
of
right
off
the
bat
there.
Nothing
too
fancy
to
talk
about
they're.
Just
you
get
completion,
as
you
type
there's,
actually
an
option
to
turn
it
on
here,
there's
a
few
more
options
that
are
that
are
kind
of
interesting.
B
B
Go
I'll
go,
let
D
equals
dates
and
all
of
a
sudden
I
got
all
these
things
that
are
from
other
namespaces
that
I
haven't
actually
opened
yet
so
I
have
date/time
right.
I
have
not
opened
the
system
namespace.
So
when
I
hit
that
up
at
the
top,
this
actually
stuck
the
system
namespace
up
there.
Oh
yeah,
it's
it's
a
pretty
it's
a
pretty
neat
feature
now:
I
haven't
turned
it
off,
because
this
sorry
I
have
it
turned
off,
because
I
usually
prefer
to
not
have
too
much
of
that
stuff
and
my
completion
list.
B
C
B
Can
absolutely
configure
it
that
way
so
you'll
notice
now
I
deleted
the
system,
namespace
declaration
and
that's
gone
well.
I
get
another
light
bulb
and
it
says:
hey.
Would
you
like
to
open
system,
or
do
you
like
to
make
it
be
system
date/time?
You
can
have
that
option
there.
So
I'm
gonna
have
it
be
system
daytime
and
then
I'll
go
inside
here
and
I
will
go
under
code
fixes,
simplify
names.
So
if
I
go
simplify,
name
analysis,
we
actually
have
this
one
turned
off
because
it
can
be
rather
expensive.
B
I
think
it's
trying
to
go
through
the
whole
project
right
now.
So
this
is
something
that
some
people
like
to
have
on,
but
what
it
would
normally
do
is
allow
you
to
remove
the
qualification
Oh,
Khan
I.
Usually
this
so
that's
off
by
default.
I
usually
do
keep
it
off
because
it
can
be
rather
expensive.
But
if
you
want
to
do
that,
you
can
run
that
there.
B
That's
inside
of
code
fixes
yeah
inside
of
code
fixes,
so
we
have
a
few
of
these
that
are
turned
on
by
default.
If
you
don't
like
the
light
bulbs
coming
out
here
for
any
reason
or
another,
you
can
always
just
go
ahead
and
turn
them
all
off
got
it
which
is
kind
of
sweet,
and
then
we
have
another
one.
This
is
more
of
an
experimental
feature,
so
it's
it's!
It's
pretty
sweet.
Let's
see
we'll
use
colors
and
annotations
okay.
B
B
B
I'd
have
to
change
that
somewhere,
but
what's
important
here
is
so
you
see
these
little
things
that
look
like
comments
up
at
the
top
here.
Well,
this
is
actually
sort
of
like
a
fake
comment,
but
this
is
actually
using
some
type
inference
in
this
case.
Right
so
I
can
I
can
go.
Let's
F
X
is
equal
to
X
is
list
dot.
Some.
C
C
B
B
A
B
This
is
really
helpful
for
especially
newcomers
if
they're
typing
code,
and
they
want
to
see
like
what
the
types
of
things
actually
are
sure.
So
this
is
something
that
we're
hoping
to
flesh
out
over
time
and
then
eventually,
turn
on
by
defaults
may
be
well
sort
of
see.
It's
something.
We're
gonna
experiment
with
get
some
feedback
on
sort
of
do
that
sort
of
thing.
B
But
this
again
is
also
something
that
may
be
very
helpful
for
data
science,
where
codes,
because
you
may
have
a
lot
of
people
who
are
new
to
F,
sharp
and
functional
programming,
but
want
to
reap
the
benefits
of
F,
be
strong
types
that
sort
of
stuff.
So
little
tools
like
this
can
sort
of
help
that
out
sometimes.
B
C
B
It
with
individual
studio,
there's
the
send
feedback
tool
with
report,
a
problem,
and
this
thing
will
pop
up
and
loads
a
whole
bunch
of
different
stuff.
But
it
can.
You
can
optionally
collect
all
sorts
of
diagnostic
information
if
you
want
to,
if
you
want
to
send
it,
if
you
search
for
something
that
sort
of
brings
up
existing
issues
to
sort
of
see,
if,
if
the
thing
that
you're
reporting
is
also
like,
that
looks
like
I'm
not
signed
in
so
I
needed
to
do
that.
This
way
difficult
for
me,
especially.
B
That's
one
option
and
then
the
other
option
is:
if
you
go
to
Microsoft
Visual
F
sharp.
So
we
have
a
repository
here.
This
is
where
all
the
stuff
is
open-source,
and
so
you
just
go
to
the
issues.
Link
go
ahead,
create
a
new
issue.
You
can
get
feedback,
you
can
report
a
bug
you
can.
You
know
maybe
suggest
that
something
should
be
done
so,
like
you
know,
if
you
want
to
look
it
here
and
you
go,
you
know
a
feature
request.
Something
like
that.
C
B
C
B
Really
don't
like
that,
then
you
can
come
on
here
and
sort
of
explain
to
us.
Why
and-
and
we
can
have
a
discussion
about
it
and
sort
of
maybe
see
if
there's
a
way
to
make
the
options
you
know
more
discoverable.
Maybe
if
there's
a
way
you
know,
maybe
we
decide.
Okay,
yeah
I
mean
you
know.
We
should
actually
turn
this
one
off
by
default.
That's
we
like
to
have
the
sorts
of
conversations
with
people
sure.
A
Of
the
asp
you
know
workload
as
well
and
then
also
to
make
sure
that
we
send
some
feedback
back,
whether
it's
through
github
or
through
that
send
feedback
inside
of
Visual
Studio.
And
that's
it
absolutely
awesome.
Thank
you.
So
much
for
coming
up
and
I
really
appreciate
it.
Yeah,
and
this
has
been
another
episode
of
the
are.net
show,
and
we
had
fun
talking
to
us
about
some
of
the
new
tooling
inside
of
Visual
Studio
for
f-sharp.