►
Description
Meeting link: https://www.meetup.com/jaxdug/events/msctdpyccgblb/
In this session, we will cover setting up an F# API with Griaffe and F#. As we explore this topic, we'll cover the pros and cons of this approach, demonstrate how unit testing applies in this environment, and run a short demo.
Speaker: Andrew Carver - A Jacksonville native and code enthusiast, Andrew Carver is a software developer who loves the challenge of finding practical ways to apply the latest technologies to solve real-world problems in business solutions. In his free time, Drew runs Jacksonville Front End Development, a local meetup that provides a platform for developers to discuss and learn about the latest front-end trends in the industry.
This session is run by the the JaxDug user group (https://www.meetup.com/jaxdug/) that hosts meetups in Jacksonville, FL.
B
All
right
awesome,
thank
you!
So
much
yep.
I
really
appreciate
the
invite.
So
all
right,
hopefully
you
guys,
are
seeing
my
screen
here
all
right
and
present
there
we
go
so
yep.
So
for
those
who
I
I
know
many
people
in
jacksonville,
but
for
those
who
haven't
met
me,
I'm
andrew
carver
go
by
drew.
So
I
really
appreciate
the
opportunity
to
speak
today.
So
I'm
a
lead
software
developer
over
at
b-line.
B
All
right,
so
yep
and,
as
I
mentioned
so
today,
we'll
be
looking
at
drafts
specifically.
So
I'm
kind
of
I'm
going
to
go
over
that
framework
show
what
it
is,
what
it
does
and
go
over
some
of
the
concepts
there,
I'm
kind
of
going
to
go
over
a
little
bit
of
a
demo
overview,
so
kind
of
created
a
business
problem.
It's
kind
of
practical,
a
little
bit
fun
to
go
over
and
go
over
that
a
bit.
B
What
we're
gonna
solve
today
and
then
we'll
get
into
the
code
and
a
demo
so
we'll
actually
see
it
working,
I'm
gonna.
Take
you
all
the
way
through
deploying
a
function
up
in
azure
and
we'll
see
it
work
in
the
cloud,
so
should
be
fun,
so
all
right
yep.
So
what
is
giraffe
so
giraffe,
as
I've
mentioned
previously,
it's
just
a
functional
microwave
framework
for
building
with
rich
web
applications.
That's
the
the
slogan
on
their
site.
B
B
B
My
whole
intent
with
this
talk
here
was
to
provide
a
bit
more
of
a
pragmatic,
take
on
it,
because
I
feel
a
lot
of
talks
get
very
lost
in
the
weeds
of
all
the
coolness
that
fsharp
can
offer
or
a
functional
language
can
offer
and
to
people
that
may
come
from
oh
backgrounds
or
may
just
be
getting
started
in
programming.
It
can
look
very
intimidating,
see
all
sorts
of
wacky
operators.
B
You
know
all
sorts
of
weird
names
and
weird
terms
that
they've
never
heard
before,
and
it
can
just
be
very
unaccessible,
I
think
intimidating
for
people
to
get
their
their
foot
in
the
door.
So
to
speak.
So
with
this
talk,
I
wanted
to
kind
of
provide
a
very
fun
demo
that
can
show
a
practical
use
case
for
functional
programming.
B
It's
something
that
you
could
easily
throw
into
an
azure
function
at
home,
or
you
know,
map
service
plan,
docker
container
whatever
and
and
play
with
so,
and
so
please
feel
free
to
provide
feedback
during
this
with
the
comment
feature
just
to
you
know,
guide
me
on
on
how
I
can
explain
things
better
to
achieve
that,
so
all
right.
So
what?
Where
does
traffic
sell?
B
One
I've
definitely
mentioned
functional
many
times
thus
far
so
functional,
in
my
opinion,
is
a
strength
and
with
that
comes
declarative
routing.
So
what
I
mean,
what
do
I
mean
by
declarative
routing,
so
declarative
is
a
a
way
of
coding
is
the
opposite
of
imperative.
So,
instead
of
we're
saying
how
to
do
something,
we're
saying
just
saying
simply
saying
what
needs
to
happen.
B
So
if
you
think
of
a
declarative
language,
a
good
one
that
people
may
not
have
known
is
declarative
of,
but
are
used
to
sql
in
sql,
I'm
not
telling
it
how
to
pull
things
out
of
tables.
I'm
just
saying
show
me
the
you
know
student
records
where
the
gpa
is
greater
than
five
or
four
yeah
four.
You
know,
maybe,
if
you're
a
really
good
student
you
know,
but
but
yeah.
B
So
that's
that's
kind
of
the
idea,
so
we're
just
declaring
what
we
want
to
see
and
then
the
magic
underneath
of
the
functional
language
makes
it
happen.
It's
kind
of
a
way
of
thinking
about
it.
So
it's
just
a
different
way
of
thinking
about
a
problem
and
we'll
see
how
giraffe
exposes
that
in
f
sharp
another
thing
that
I
think
this
is
just
kind
of
a
personal
opinion
about
giraffe.
Here
has
really
good
model
validation.
B
What
I
mean
by
that
is,
if
you've
ever
used
the
s
printf
function
in
f,
sharp.
It
has
very
nice
little
syntax,
and
don't
worry,
we'll
see
this
as
I
get
into
the
code
in
a
second,
but
it
has
a
very
friendly
way
of
pulling
route
parameters
out.
That,
I
think,
is,
is
pretty
cool,
so
I
think
that's
a
that's.
B
A
cool
feature
is
native
task
support,
so
this
may
be
something
if
you're
not
used
to
f
sharp
you
kind
of
raise
your
eyebrows
and
be
like
well
what
task
support
so
f
sharp
has
its
own
take
on
asynchronous
programming
by
the
async
type,
so
they've
come
up
with
their
own
type.
That
sometimes
gets
a
little
tricky
when
you're,
integrating
with
c-sharp
code
or
libraries
that
use
the
task
of
t-type
that
you
may
be
used
to
in
a
c-sharp
world.
B
So
this
just
kind
of
bridges
the
gap
there's
all
that's
going
on
there,
so
it's
just
making
it
friendlier
to
work
with
that.
So,
but
we'll
see
how
that
it's
really
not
something.
You
have
to
keep
in
mind,
it
just
works
yep
and
then
the
the
built-in
model
validation,
I
think,
is
a
really
cool
feature
all
right.
B
So
some
of
the
benefits
that
I
think
giraffe
really
highlights
in
web
programming.
So
I
think
it
really
dovetails
nicely
with
a
railway-oriented
programming
model
if
you've
never
heard
that
term,
there's
a
really
good
blog
here,
f,
sharp
for
fun
and
profit.
I
highly
encourage
anybody.
Who's,
not
read
scott
washington's
work.
B
To
give
it
a
give
it
a
click
or
a
visit
or
google
search,
it's
it's
an
awesome
site
and
he
has
very
pragmatic,
non-uh
deep
in
the
weeds
of
category
theory,
ways
of
explaining
pragmatic
business
application,
explanations
for
functional
programming
and
f
sharp
he's
a
big
f,
sharp
advocate.
I
I've
fallen
in
love
with
his
way
of
explaining
problems.
It's
helped
me
being
not
a
I'll
admit,
I'm
not
a
math
guy
in
school,
so
anytime
anybody
breaks
out
the
the
you
know,
the
category
theory
and
the
lambda
calculus.
B
Usually
I
start
to
wonder:
okay,
well,
you
know
that's.
I
usually
solve
business
problems,
so
I
think
he
does
a
very
good
job
at
explaining
in
an
accessible
way
how
functional
principles
can
make
your
business
problems
solve
them
in
a
much
better
way,
so
yep
and
I'll
just
briefly
go
over
to
the
site
here,
just
to
kind
of
give
you
a
demo
of
of
what
his
blog
looks
like.
I
highly
encourage
it,
though
so
railroad
new
programming.
B
He
has
a
really
nice
diagram
here
that
he
kind
of
explains.
So
we
can
see
this
is
the
happy
path.
So
what
we
would
describe
in
programming
is
the
the
happy
path,
the
one
that
we
hope
our
code
stays
on
most
of
the
time,
but
we
always
know
that
you
know
things
happen.
No
references
happen
thanks
things
like
that
happen,
and
so
you
may
end
up
on
the
sad
path
and
that's
that
right
that
rail
going
off
to
the
bottom
here.
B
B
You
know
you
know
503,
you
know
401,
you
know
those
those
pass,
and
that
would
be
the
sad
path
here
or
you
know,
yeah
and
and
even
in
the
code
of
different
layers
like
you
can
see
here,
so
he
has
a
validation
error.
He
has
a
update,
db
error,
these
all
kind
of
go
on
to
that
other
side.
Rail
of
something's
gone
wrong
and
we
need
to
kind
of
eject.
B
You
know
and
hit
the
abort
button
on
this
request
and
let
the
user
know
that
whatever
he
was
trying
to
get
accomplished
didn't
happen.
It
can't
happen.
So
that's
that's
kind
of
what
this
this
model
achieves
and
we
can
see
in
giraffe
as
as
a
framework,
it's
very
friendly
to
the
style
of
programming.
So
I
think
this
is
a
very
powerful
way
of
programming.
B
There's
obviously
a
lot
more
to
this,
that
scott
veloson
explores
here
and
that
we
could
explore
today,
but
just
kind
of
keeping
it
surface
level
for
now,
but
all
right,
moving
on
along
so
and
here's
another
diagram
more
specific
to
giraffe
itself.
So
this
is
kind
of
the
railway
oriented
model
without
the
sad
path
represented,
but
you
can
see
the
composition.
B
So
thinking
back
to
that
diagram
that
I
just
showed
from
scott
wallach's
website,
we
have
a
compositional
nature,
that's
happening
to
all
of
those
tracks,
so
you
could
see
how
they
all
kind
of
merge
together
into
one
and
giraffe
is
modeling
that
as
well
here.
So
it
has
a
concept
that
it
calls
http
handlers
and
you
can
see
these
little
handlers
they're
almost
like
kind
of
like
middlewares.
You
can
think
about
where
they
just
kind
of
glue
onto
the
next
guy
and
they
handle
different
specific
things.
B
So
that's
filtering
down
the
request
here
a
bit
and
then
we're
going
to
determine
whether
the
route
matches
my
particular
route
a
specific
route
and
then
we're
going
to
compose
on
to
another
handler
and
then
add
the
response
body.
So
maybe
they
were
asking
for
you
know
students,
you
know,
writing
an
api
for
a
school,
so
it
composes
all
of
these
together
and
all
these
little
functions
are
basically
little
tiny
pieces
of
single
responsibility
in
the
chain
of
of
completing
this.
B
This
request
here
and
then
we
return
back
to
the
user.
The
result,
so,
hopefully
that's
making
some
sense,
but
that's
that's
kind
of
the
idea
behind
giraffe's
way
of
modeling
this
yep
and
here's
a
some
text
explaining
it
a
little
bit
further
but
yep.
So
it
takes
an
http
context,
object
and
then
it
handles
it,
and
then
we
end
up
with
a
response
and
it's
just
one
big
chain
of
them
that
goes
through
all
right,
moving
all
along
so
project
overview.
B
So
it's
it's
been
a
learning
experience
for
me,
so
I
have
never
played
the
series,
but
my
wife
loves
the
series
so
yup,
so
we
played
this
together,
so
I
was
introduced
to
this
game
and
the
mechanics
of
it.
So,
as
you
can
see,
my
wife
has
had
influence
on
on
the
slide
as
well.
So
we
got
the
cute
little
figurine
here
at
the
bottom,
but
it
got
me
kind
of
thinking
about
this.
B
So
when
I
sat
down
to
this
talk,
I
just
thought
it'd
be
a
fun
thing.
I
don't
know
if
anybody
else
has
played
this
game
or
not,
but
there
was
one
little
part
of
the
game
that
made
me
think
about
this.
So
so
there's
this
part
of
the
game
where
you
purchase
turnips.
So
you
can
see
this
this
character
here.
I
I
don't
know
the
name
of
the
character,
but
my
wife
definitely
would
but
these
little
turnips
up
here
at
the
top.
B
A
B
B
My
wife
got
very
competitive,
looking
into
all
the
the
possible
explanations
for
this
algorithm,
but
the
the
one
interesting
feature
was
that
the
more
people
to
play
this
game-
I'm
guessing
this
is
a
part
of
my
wife's
decision
making
and
providing
me
with
a
copy
of
the
game
is
that
you
can
visit
other
players,
games
and
sell
turnips.
So
say
I
have
a
a
good
rate
going
for
the
day
for
these
turnips.
My
wife
could
visit
my
island
and
use
it
to
purchase
those
turnips
so
yep.
B
So
that's
kind
of
the
idea
so
and
the
in-game
currency
here
is
called
bells.
I
don't
know
what
the
significance
is.
There's
coins
but
that's
kind
of
the
general
idea
for
this
business
problem,
so
yeah
so
we'll
get
into
this,
but
I've
basically
written
a
an
api
that
allows
players
to
essentially
save
their
rates
for
the
week.
The
idea
being
that
we
could
put
some
front
end
in
front
of
this
and
then
your
players
could
go
on
and
post.
B
So
that's
what
we'll
be
exploring
so
without
further
ado.
I
will
get
into
the
code
so
hold
my
vs
code
here.
So
we
will
get
started
over
here,
so
I'll
say
up
front,
so
this
is
written
as
an
azure
function.
I
did
this
purely
for
fun,
but
I
suspect
that
this
is
probably
not
the
ideal
use
case
for
azure
functions.
You
typically
would
probably
break
this
out
into
its
own
app
service
plan.
If
you
were
to
host
the
since
azure
functions,
allow
you
to
define
http
triggers
for
unique
routes.
B
You
probably
want
to
break
this
up
in
f
sharp.
If
you
did.
I
did
this
purely
as
an
exploratory
exercise,
but
I'm
just
announcing
that
up
front.
So
probably
if
you
were
doing
this
for
in
a
production
environment,
you
would
want
to
put
this
in
an
app
service
plan
and
scale
it
that
way,
but
I
wanted
to
play
with
giraffe
and
you
know
just
just
to
kind
of
as
an
exploration
side
project.
B
So
this
isn't
an
azure
functional,
but
the
benefit
is
that
we'll
get
to
see
how
easy
azure
functions
are
to
deploy
so
yep
with
that
being
said,
we'll
get
into
the
code
here
so
for
those
that
are
curious
about
azure
functions
themselves,
so
it
can
be
a
little
tricky
to
set
up
something
like
this.
This
is
how
you
would
set
it
up
in
in
f
sharp.
B
B
So,
and
that
may
be
a
great
topic
for
another
talk
and
scott
washington
is
a
great
resource
for
that
on
pure
functions.
Referential
transparency,
those
are
kind
of
the
terms
that
are
thrown
around
in
a
functional
sense,
but
f,
sharp
helps
you
a
lot
with
that
with
this
tool,
so
where
it's
providing
me
the
the
result
of
each
type
resulting
type
on
each
line
of
code
or
in
this
case,
a
function
so
all
right,
so
let's
get
into
where
the
routing
is
happening.
So
here
you
can
see.
B
I
have
my
app
so
remember
how
I
was
saying
that
it
was
declarative.
So
the
declarative
part
here
you
can
see
is
this
piece
here
now.
This
may
look
very
different
than
what
you're
used
to
writing
if
you've
written
c
sharp
web
api
controllers.
So
I'm
not
inheriting
from
anything
and
this
an
object,
oriented
I'm
simply
composing
together,
http
handlers,
as
I
was
mentioning
before
so
we
can
see
here.
This
is
my
api
and
and
you'll
notice
that
I
have
these.
B
So
these,
like
these,
these
icons
that
are
being
rendered
here
are
just
kind
of
the
enhancements
just
to
make
my
code
look
a
little
prettier,
but
what's
really
what
these
symbols
are
I'll
type
out
here,
you
can
see
it
work.
So
this
is
a
a
pipe
operator,
so
you
see
it
changed
to
a
triangle,
so
it
automatically
kind
of
corrects
it
and
makes
it
it
look
a
little
different.
B
This
operator
right
here
is
commonly
referred
to
as
the
fish
operator,
because
it
looks
a
little
bit
like
a
fish,
so
we
can
see
it
here,
yeah
and
then
that's
that's
what
it
actually
is
right
here,
so
you
can
see
it's
the
the
greater
than
equal
greater
than
piping
it
along.
So
here
it
basically
serves
to
compose
together,
http
handlers,
and
that's
one
interesting
thing
about
f
sharp
here
is
that
you
can
actually
define
these
operators
as
functions
themselves.
B
So
if
I
hover
over
it,
this
is
coming
from
giraffe.
So
giraffe
has
defined
this
operator
here
and
we
can
see
here.
The
type
signature
of
it
so
whenever
in
functional
programming,
is
very
common
to
look
at
the
types
and
drive
your
code
through
the
types
and
the
way
to
read
this.
For
those
who
haven't
read
code
like
this
before
the
the
way
to
read
this
is
to
read
this
as
a
function
that
takes
in
these
arguments
and
the
this
is
the
return
type.
B
So
at
the
very
far
side,
if
you
ever
see
parens
in
this
case,
it's
just
wrapping
this,
but
if
you
saw
if,
for
example,
if
we
saw
parens
around
this
type
here,
that
would
mean
it's
returning
a
function
at
the
end
of
it
here.
So
it's
a
grouping
so
so
that
that's
kind
of
a
little
bit
of
a
marker
just
to
kind
of
help
people
get
used
to
what
this
reads
like
so
and
I've.
B
I
know
I've
covered
a
lot
so
feel
free.
If
there's
any
lines
of
code
here
or
anything
as
I
was
mentioning
with
the
the
chat
feature,
please
feel
free
to
post
it
and
I'll
do
my
best
to
answer
it.
So
whole
intent
is
just
to
kind
of
help.
People
make
f
sharp
a
little
bit
more
accessible
to
people,
so
please
feel
free
to
do
that.
B
B
So
it's
just
an
array
of
of
handlers
here,
it'll
match
the
first
one
that
it
hits
so
that's
kind
of
how
this
works.
So
we
see
here
down
at
the
bottom.
You
know
not
found
I
could
could
measure
out
there.
So
that's
how
draft
works.
I
will
say
for
those
who
haven't
coded
an
f
sharp
before
too
it
is
well,
it's
probably
obviously
this
one,
but
it's
a
white
space
delimited
language.
B
So
there
aren't
any
curly
braces,
aren't
many
semicolons,
so
it's
very
different,
so
you
will
get
compile
errors
if
you
code
in
it
for
improperly
indented
code,
I
will
say,
as
a
personal
opinion
coding
in
f
sharp.
I
found
the
tooling
around
f
sharp,
to
be
very
welcoming
for
new
developers
that
aren't
used
to
that.
It's
the
proper
indication.
B
I
believe
the
air
itself
will
actually
tell
you
if
you
have
improper
indentation
or
it
suspects
that
so
it's
a
lot
friendlier,
I
think,
than
some
languages
where
you
just
get
red
squiggles
everywhere,
and
you
wonder
where
you
went
wrong,
so
very,
very
helpful
there
so
moving
on
along
here.
So
we'll
take
this
route,
for
example.
So
this
is
just
to
add
what
I
refer
to
as
an
exchange
so
going
back
to
our
business
problem
here
with
the
exchanges,
the
animal
crossing
exchanges.
B
So
I
I
came
up
with
the
name
exchange.
It
represents
a
particular
week
in
which
players
are
playing,
so
we
have
exchanges,
and
then
we
have
markets
and
the
market
contains
a
individual
players
score
for
the
week,
so
they're
their
purchase
price
and
then
the
prices
for
each
day
for
the
the
turnips
that
they're
offered.
So
that's
where
the
markets
are
stored
and
then
the
exchange
is
simply
a
a
week
for
all
players
to
participate
in.
B
So
that
was
kind
of
how
I
modeled
this
business
problem
here
and
that's
the
nomenclature
I
went
with
for
this,
so
a
little
bit
of
ddd
fixed
in
here
too.
So
that
would
be
our
aggregate
right
here,
so
so
moving
on
along.
So
this
route
here
will
just
match
api
exchanges,
you'll
notice.
I
have
this
little
warpler
function
here
and
actually
I
believe
this
will
be
even
more
helpful
if
I
tab
over
here
and
we
move
over
to
draft's
documentation.
So
this
is
where
draft
the
draft
documentation
lives
draftwiki.
B
They
actually
do.
I
think,
a
very
good
job
at
documenting
their
their
code
here
so
feel
free.
If
you,
if
you
play
around
with
this,
to
give
it
a
look,
I
found
it
to
be
kind
of
helpful.
This
is
explaining
here
the
the
compose
operator
that
we
just
saw
so
the
the
fish
operator
yeah.
I
think
he
he
gives
a
shout
out
here,
so
we
can
see
it
used
down
here.
B
This
is
just
another
use
case
showing
the
compositional
nature
of
it,
and
that's
very
common
in
functional
programming
for
those
who
haven't
done
functional
programming
before
so,
you
can
take
functions
and
then
just
glue
them
together.
Just
like
we
saw
with
the
railway
example
and
arrive
at
a
function
that
solves
a
much
bigger
problem.
So
it's
like
the
composition
of
his
parts,
solving
the
problem,
so
yeah
there's
no
limit
to
many.
How
many
you
can
glue
together
here.
B
B
So
we
want
in
this
example.
You
can
see
here,
like
you
know,
if
I
was
to
return
the
time.
I
probably
would
want
a
time
and
point
to
get
the
time
every
time,
rather
than
just
the
first
time.
So
that's
what
it's
doing
here.
So
it's
just
a
it's
referred
to
as
a
thunk
nfp,
but
we're
essentially
just
wrapping
it
with
another
function
to
make
sure
that
it's
run
every
time
through
this
warbler
function
here,
http
handler
so
moving
on
along.
B
Very
good
didn't
want
to
miss
any
questions
so
yep
moving
on
along
here
so
yep-
and
this
is
just
an
inline
lambda
function
so
for
those
in
javascript
or
in
c
sharp.
This
is
just
a
lambda.
That's
how
f
sharp
writes
them,
so
we
just
have
fun
underscore
represents
the
absence
of
an
argument
here
that
we're
going
to
ignore
it's
just
kind
of
a
shorthand.
B
So
we're
just
saying
I
don't
care
about
the
parameter,
that's
passed
in
normally
and
just
wish
to
execute
this
function
for
the
result
so
moving
on
down
here.
So
we
can
see
some
other
routes,
so
obviously
we're
going
to
need
to
take
in
a
resource
driven
fashion,
an
exchange
id
obviously
to
return
a
particular
exchange.
So
if
I'm
interested
in
a
particular
week
for
players,
imagine
the
ui
that
I
was
referring
to
a
second
ago.
So
we
build
out
this
this
ui
here
and
an
individual
player
changes
to
a
particular
week.
B
Then
maybe
the
current
week
to
see
okay.
What
was
you
know?
What's
the
market
look
or
the
exchange
look
like
today?
That's
what
this
route
would
support
here,
you'll
notice
that
this
looks
kind
of
similar
and
different
if
you've
used
c
sharp.
So
this
percent
s
here
is
actually
a
specific
convention
that
f
sharp
uses
and
this
router
function
takes
advantage
of
it.
This
will
actually
extract
out
and
tokenize
this
particular
part.
So
if
you
use
like
react
routing,
I
believe
they
use
colon.
B
This
is
actually
a
part
of
the
language
here,
so
yeah
we
just
basically
get
all
that
cleanness
for
free.
So
this
just
takes
out
the
exchange
id
here
out
of
the
out
of
this
part
of
the
route
and
then
passes
it
straight
in
here
so
yep.
So
we
get
our
exchange
yep
and
then
yep.
These
as
well
are
very
similar.
This.
Actually,
if
you
might
ask
the
the
next
question,
what
happens
if
I
have
multiple
right?
B
Well,
this
it
just
essentially
gets
merged
into
a
tuple,
so
tuples
are
very
common
to
work
with
in
fp
as
well
provides
a
very
handy
way
of
just
providing
multiple
values
here,
so
we
just
destructure.
So
this
is
destructuring
right
here
in
fsharp,
so
we
bought
the
exchange
id.
We
pull
out
the
username,
and
then
we
just
pass
it
on
along
so
very,
very
clean
in
my
opinion
and
yep,
and
there
you
there,
you
go
there,
you
have
it.
B
So
that's
our
whole
api
here
from
from
a
high
level
routing
perspective,
so
we
can
kind
of
ignore
this
piece
here.
I
have
that
up
in
github.
This
is
just
wiring
up
the
function
app
into
giraffe,
so
a
bunch
of
boilerplate
code
here
so
we'll
let
that
be
for
now,
but
let's
jump
into
one
of
the
handlers
here,
just
to
see
what
that
looks
like
so
we'll
go
with
git
exchanges
here,
click
on
this.
So
actually,
let's
start
up
here.
This
will
this
be
a
little
less
overwhelming
so
you'll
notice.
B
Here
I
have
this-
create
exchange
builder
function
up
here.
You
may
ask
yourself
what's
going
on
here,
and
why
am
I
doing
this?
So
the
reason
I'm
doing
this
is
because
this
is
a
functional
strategy
pattern
so
you'll
see
here.
I
actually
have
this
dependency
or
a
signature
matching
this
exact
signature
up
here.
B
So
if
we
scroll
to
the
right
here,
we'll
notice
that
these
types
actually
line
up
here
and
that's
on
purpose
so
in
functional
programming,
functional
strategy
pattern,
which
simply
just
as
you
probably
guessed
it
use
functions
to
to
solve
this
problem
here,
so
this
makes
it
very
easy
to
unit
test
as
well
that
we'll
see
in
a
second.
So
I
have
a
full
test
harness
built
out
for
this,
we'll
see
how
easy
it
is
to
to
create
unit
tests,
so
we
won't
actually
have
to
use
a
mock
or
stub
library.
B
We
just
use
functions
again,
as
you
guessed
it
so
yep,
but
that's
exactly
what
this
is
doing
and
this
this.
This
is
the
part
where
we
call
our
database.
We
are
using
this
operator
here.
This
is
a
pipe
operator
in
fsharp,
so
it's
going
to
take
the
value
of
this
expression
over
here
and
push
it
into
this
one.
So
here
we
are
getting
the
exchange,
we're
getting
the
collection
here.
B
So
this
is
the
collection,
so
I'm
using
as
our
database
and
then
we
are
pushing
that
into
this
function
here.
So
that's
what
that
line
of
code
is
doing
moving
on
down.
So
this
is
the
general
function.
Syntax.
I
broke
this
up
on
purpose.
I
could
put
all
these
arguments
up
here
as
we
were
looking
at
previously.
So
if
I
look
at
this
function
here,
we'll
just
see,
if
sharp
doesn't
make
any
distinction
between
them,
it
just
shows
that
this
is
a
function
that
takes
this
argument.
B
B
So
I
broke
this
out
on
the
next
line
just
for
readability,
but
just
wanted
to
toss
that
out
there
in
case
anybody
was
curious
so
and
all
this
code
is
on
github.
I
have
it
on
the
last
slide.
So
if
anybody
wants
to
download
it
play
with
it
critique
it,
what
not
feel
free
to
do
so
so
yep
moving
on
along
here.
B
So
this
is
the
task
I
was
referring
to
for
native
integration
with
with
tas.
So
this
is
known
as
a
computation
expression.
It's
f
sharp's
way
of
handling
asynchronous
code,
so
we
can
see
here.
I
have
let
bindings
here,
but
I
have
this
operator
at
the
very
end.
This
is
basically
the
equivalent
of
an
await.
So
if
you
use
c-sharp
or
javascript
promises,
you'll
use
an
await
to
await
a
promise
or
a
wait
to
await
a
task
same
idea
for
this
block
of
code.
B
Here
I
any
time
I
use
this
exclamation
point,
I'm
awaiting
the
result,
so
it
changes,
and
we
can
actually
see
that
here.
If
I,
if
I
remove
this
here
so
it'll
yeah
well,
my
code
will
blow
up
but
it'll
also
say
task
of
of
t
now.
So
if
I
undo
it
now,
I
get
something
I
can
work
with.
So
that's
what's
going
on
there,
so
hopefully
that
clears
it
up
a
bit.
B
So
this
this
particular
function
right
here
this
handler
it's
just
creating
an
exchange,
so
this
is
kind
of
the
starting
point
for
the
api.
If
you
will
so
this
is
where
we'll
create
a
week,
the
player
will
come
in
they're,
going
to
create
a
week
and
and
get
started
posting
their
scores
for
the
week
of
their
prices.
B
So
you
can
see
we
have
to
get
the
week
that
the
user
is
trying
to
create
somehow
out
of
this,
and
as
I
was
mentioning
earlier,
this
is
the
syntax
they
use
for
grabbing
the
model
out
of
it.
So
just
context
has
a
native
little
function
here:
buying
json
async
and
we
just
hand
it
a
model
here
that
we
create
in
fsharp
and
it
pulls
it
in
for
us
and
we'll
validate
it.
So
you
will
notice
here
and
I'll
explain
this
here
as
well.
B
B
So
I'm
moving
on
along
here.
So
here
we
create
the
exchange
grab.
The
week
start
date
for
the
user
from
the
user,
and
then
you
can
also
use
the
exclamation
point
on
the
return
statement,
and
we
do
here
as
well,
because
this
is
also
a
task
right
here.
This
expression,
this
is
f
sharp's
pattern,
matching
syntax
if
you've
not
used
f,
sharp
before
it's
very
clean,
so
match
result
with.
You
may
notice
that
c
sharp
just
had
that
introduced
and
they
use
switch
statements.
B
The
f
sharp
uses
this
match
syntax.
I
tend
to
prefer
this
one,
but
you
don't
teach
their
own
and
then
for
all
javascript
obviously
doesn't
have
any
so
we'll
laugh
at
that,
so
but
yep,
so
that
that
explains
that
handler
there.
Hopefully
it's
just
making
some
sense
but
yep,
and
then
we
return
so
I'll.
Talk
I'll
speak
to
these
results
here.
So
giraffe
exposes
these
handlers
as
well.
These
are
also
http
handlers
created
conflict,
all
the
popular
ones.
B
You
know,
obviously,
you
use
for
status
codes
they're
all
nicely
wrapped
up
into
the
micro
framework.
So
I
can
simply
just
say,
created
handed
a
item
here
and
then
these
two
functions
this
it
works
just
like
a
middleware,
so
this
continues
on
the
http
handler
chain
here
this.
This
ensures
the
continuation
of
it
so
or
we
can
represent
an
error.
So
hopefully
this
is
starting
to
make
some
sense
to
people
that
may
not
have.
If
this
is
new
to
you.
B
So
really
you
can
see
the
railway
oriented
programming
approach
starting
to
surface
here,
so
we
can
see
I'm
getting
a
result
back.
We
can
see
it's
this
result
type
and
I
match
against
it
and
I
may
get
a
result
of
okay
or
I
may
get
one
of
error.
So
this
is
where
the
two
pass
yep
and
you
see
f
sharp,
actually
has
very
good.
I
think
documentation
and
kind
of
hand
holding
with
this.
So
you
can
see
what's
going
on
here,
so
I
I
think
this
makes
your
handlers
here.
B
Look
very
clean.
It's
easy
to
see.
What's
going
on
here
and
yep,
it's
just
a
simple,
very
oriented
program,
so
it
makes
it
as
easy.
As
that
slide
looks
so
we
just
have
the
two
tracks
there
that
are
that
are
happening
so
yep.
That's
that's
that.
So
this
is
the
create
route
here,
so
we're
moving
on
along
here.
Let's
create
market
route,
so
you'll
notice
too
another
common
thing
with
functional
programming
type
unions.
B
So
these
are
some
types,
so
I
believe
scott
wilsham
refers
them
as
choice
types,
but
essentially
it's
just
a
union.
What
this
means
is,
if
you
are
used
to
inheritance,
that
would
be
a
product
type,
so
I'm
taking
types
from
the
parent
and
then
kind
of
adding
them.
So
the
child
is
everything
that
the
parent
has
and
also
this
other
stuff
union
type
is
useful
or
a
choice.
Type
to
borrow
his
language
is
a
way
of
representing
things
that
may
not
actually
share
share
properties
but
share
a
logical
idea.
B
B
None
of
those
types
actually
line
up
in
any
way
of
sharing
any
common
properties,
but
they
have
a
logical
idea
and
that
maybe
I
have
a
business
requirement
at
some
point
to
I
have
to
have
a
user
with
at
least
one
contact
method
in
the
system.
So
a
union
a
choice
type
would
be
a
great
way
to
bottle
that
because
I
can
just
put
them
all
together
and
then
create
a
business
rule
and
pattern
match
against
it
like,
like.
B
We
see
here
and
say:
well,
you
gotta
have
one
so
that,
hopefully,
that
that
clears
that
up
a
bit.
So
we
can
see
here
this
function
here
very
similar
approach
here
that
I've
taken
and
I'm
matching
against
the
result
coming
back
from
this
function
here
and
I'm
modeling
all
of
the
cases
underneath
that
could
happen.
So
we
we
could
have
this
go
successful.
I
could
say
I
couldn't
find
your
week.
B
It's
not
been
created
yet
or
we
could
have
something
terrible
happen
and
then
give
the
the
wonderful,
descriptive
and
internal
error
occurred,
that
we
commonly
show
to
people.
So
hopefully
this
the
this
is
making
sense.
I
the
indentation
too,
here
I
I
tend
to
like
this
approach
here.
I
think
it
helps
readability,
but
it's
just
a
stylistic
choice
so
moving
on
along
here
through
the
handlers.
So
this
particular
one
will
get
an
individual
exchange.
B
B
If
so,
I
have
some
bad
requests
logic
in
here
that
we
use
so
in
case
so
yep,
so
just
dovetailing
together
here.
So
all
of
the
validations
speaking
of
this,
this
line
of
code
here
so
I'll
just
point
out
this
operator
here.
This
was
honestly.
The
scariest
part
of
functional
programming
to
me
was
the
operators,
because
I
think
c
sharp
is
very
one
thing
it
shines
in
is
that
it's
very
verbose
in
some
ways
as
far
as
how
code
is
written,
so
it's
easy
for
people
to
read.
B
F,
sharp
and
other
functional
languages
tend
to
rely
a
lot
on
operators,
so
speaking
from
experience
with
bad
experiences
with
math,
because
I'm
not
a
math
guy,
I
think
it
can
be
very
difficult,
sometimes
to
see
code
like
this
and
and
feel
intimidated,
just
because
you
don't
know
what
it
means.
So
I
mean
this
looks
like
wingdings
to
anybody
that
doesn't
understand
what
it
means.
So,
if
you're
ever
programming,
f,
sharp
and
you're
curious
what
it
means
you
can
hover
over
it
and
then
get
this.
B
This
type
information
as
I've
been
speaking
to
now,
you
may
hover
over
it
and
then
think
this
didn't
help
me
at
all
this.
This
looks
like
greek
and
it
feel
even
worse,
so
never
fear
I'll
explain
what
this
means
here.
So
the
apostrophe
here
in
f
sharp
just
stands
for
generic,
so
this
could
be
any
type.
What
this
operator
is
doing
here.
What
it's
demonstrating
is.
This
is
a
way
to
compose
two
functions
together,
so
we're
gluing
them
together.
B
So
if
a
goes
to
b
and
b
goes
to
c,
then
I
have
a
function
that
goes
from
a
to
c.
So
that's
all
that
that
means-
and
it
gets
easier,
the
more
you
work
with
it.
So
from
from
personal
experience,
so
stick
with
it,
you
know
and
you
you
know
it
gets
much
easier,
but
we
can
see
here
so
it's
very
common
in
the
f,
sharp
and
in
functional
programming
to
code
this
way.
B
So
I
can
just
easily
in
one
line
compose
together
a
larger
function
in
one
big
expression
and
then
toss
it
into
this
bind
function
here
and
I've
solved
my
problem,
so
yeah
very,
very
cool
stuff.
So
hopefully
this
is
making
some
some
sense,
but
just
trying
to
kind
of
highlight
some
of
the
things
that
may
intimidate
those
that
haven't
worked
with
f
sharp
before
so
moving
on
along
here.
So
we
have
our
update
handler.
So
this
is
if
somebody
wants
to
add
their
scores.
B
So
I
provided
this
route
to
to
update
your
your
prices.
So
we
can
see
up
here
and
I'll
speak
to
this
in
a
second
in
the
models
here,
but
I
represent
this
as
nullable,
so
this
is
the
way
that
we
can
get
around
serializing,
since
we
can't
use
an
immutable
model
for
that.
So
if
we
use
the
nullable
of
t
here,
f
sharp
has
another
way
and
you'll
notice
that
I'm
transforming
things
I'll
speak
to
that
in
a
second.
B
It
has
a
very
elegant
way
of
modeling
options
that
you
may
actually
in
c
sharp
nine.
They
started
to
kind
of
move
that
way
with
the
non-nullable
reference
types
but
yep
moving
on
along
here
so
yep,
and
this
is
very
similar
code
to
what
we've
seen
in
the
others
yeah.
I
will
focus
on
the
models
now.
So
this
is
actually
a
great
transition
point
and
again
I'll
say
it
again
feel
free
to
surface
questions.
B
If
you
see
something
that
you've
not
seen
before,
you
have
a
question
I'll
do
my
best
to
answer
it.
So
please
feel
free
to
interrupt
me
at
any
point
so
notice.
I
have
the
spells
here,
I'm
just
doing
a
simple
type
alias.
So
this
is
a
common
thing
if
you've
ever
coded
in
typescript's
common
convention
typescript
ii,
it's
a
great
way
since
in
functional
programming
we
rely
on
types.
B
A
lot
well,
integer
doesn't
tell
me
a
lot
of
information,
but
if
I
aliase
it
to
something
that
does
give
me
a
little
bit
more
information,
it's
easy
to
do
so,
and
it
makes
my
code
more
descriptive.
So
here
I
alia
said:
there's
some
other
tricks.
You
can
do
even
deeper
than
this
units
of
measure
and
such
an
f
sharp.
I
won't
get
into
that
here,
but
but
they're
there
so,
but
main
idea
here
being
don't
feel,
don't
be
afraid
to
leverage
this
feature.
B
B
B
B
So
this
is
a
f-sharp
feature
that
allows
you
to
basically
wrap
a
property
that
could
or
could
not
be
absent
and
I'm
being
specific
roommate
language
there,
because
in
c
sharp
traditionally
in
an
object,
oriented
use
null,
but
null
kind
of
creates
a
problem.
The
problem
is
that
null
isn't
always
specified
with
a
particular
function.
B
So
if
you
have
a
particular
function
that
returns
null
it'll,
just
look
like
this
in
c
sharp.
So
it's
it's
left
to
the
consumer
of
that
function
or
method
in
an
object-oriented
model
to
know
that
you
can
return
null
so
in
functional
programming,
it's
common
to
wrap
types
with
other
types.
So
here
I
have
it
a
cover
the
intelligence
here.
But
if
I
hover
over
another
property
here,
I
may
get
it,
but
it's
basically
an
option
of
t.
B
So
in
the
same
way,
you
have
a
nullable
t
here,
it's
an
option
of
t.
It
results
to
two
concrete
things.
It
could
be
a
sum
or
it
could
be
a
none,
but
it's
explicit.
So
if
you
see
an
endpoint
in
it
in
fsharp
that
returns
an
option,
it's
it's
imperative
on
you
and
you
actually
cannot
access
the
underlying
value
without
handling
both
cases,
to
kind
of
go
back
to
the
railway-oriented
approach
that
we
were
talking
about
a
second
ago.
This
enforces
that
and
that's
a
piece
of
that.
B
So
this
makes
our
code
much
safer
because
I
could
easily
code
something
like
this
and
then
hand
this
to
somebody.
Somebody
else-
and
they
would
understand-
oh
drew
sometimes
has
something
to
return
to
me
and
sometimes
not
so
just
a
handy
tool
in
your
tool
belt
when
you're
programming
f
sharp-
and
you
may
have
noticed
the
result-
type
that
I
hovered
over
earlier-
that
handles
the
okay
and
error-
that's
very
similar
to
option.
B
The
only
key
difference
is
that
the
error
case
can
also
hold
something
else,
so
I
could
put
like
an
error
message,
for
example
in
it
and
return
it
so
just
to
capture
some
information
about
there,
but
same
idea,
so
hopefully
that
kind
of
demystifies
that
a
bit-
and
we
have
these
nice
little
friendly
transformations
here-
that
I
can
leverage
here
so
moving
on
along
here.
So
a
couple
more
utilities
here
that
I've
written
so
this
just
parses
the
date
here.
B
One
nice
feature
about
f
sharp-
is
that
out
parameters
get
put
into
a
tuple.
So
here
I
can
pattern
match
so
normally
I
was
always
kind
of
felt
clunky
to
be
in
c-sharp.
I
think
they've
cleaned
it
up
a
little
bit,
but
I
really
like
the
fact
that
I
can
just
pattern
match
here
and
just
say
in
the
case.
I
get
true
and
par
state
capture
that
in
what
we
call
the
closure
and
then
put
that
into
a
sum
here
and
transform
it.
B
So
now
I
have
a
little
handy
utility
function
here
that
takes
a
string
and
returns
me
as
we
were
just
a
second
saying
a
second
ago.
This
is
actually
a
perfect
transition,
an
option
of
t
option
of
date
time
so
my
code
consuming
this
will
have
to
handle
both
cases,
whether
it's
there
or
not.
So
query
string
utility
here
very
similar
thing,
so
yep
all
right.
B
B
Actually,
you
know
what
I
believe:
okay,
that's
our
tests.
I
think
it's
already
running.
Yes,
okay,
good!
I'm
glad
I
didn't
try
to
start
it
twice.
That
would
give
me
a
funny
funny
year,
pour
it
in
use.
So
let
me
stop
this
here,
really
quick!
Well,
I
can
leave
it
running.
This
is
funk
start.
So
if
you
run
funk
start
I'll
just
type
that
out
over
here
and
leave
this
going,
but
funk
start.
B
This
starts
an
azure
function,
so
it's
always
required
so
just
download
the
azure
core
tools
and
or
azure
function,
runtime.
I
believe
it
is.
It's
called
you'll
know
it
and
you
see
it
but
yep.
Just
simple
tool
here
allows
us
to
start
up
a
function
and
we
can
run
it
locally.
So
before
we
deploy
to
the
cloud,
we
can
see
the
function
running
so
we'll
go
over
here,
we'll
give
it
a
give
it
a
test.
So
let's
go
ahead
and
grab
some
exchanges
here.
B
B
B
All
right
there
we
go
two
one
created
so
came
through
yep,
so
it's
all
up
and
running,
so
I
won't
bore
everybody
with
going
through
every
single
endpoint,
but
this
is
kind
of
the
general
idea.
We
can
see
what
this
looks
like
being
serialized
back,
so
it's
all
up
and
running,
so
we're
good
to
go
there.
So
you
may
say
this
is
great
what
about
unit
testing,
so
we
got
all
the
types
and
everything
lining
up,
but
what
about
unit
tests?
What
does
this
look
like
so
unit
tests
here?
B
So
so
I'm
using
x
unit
and
if
we
close
this
here
so
this
is
what
a
unit
test
looks
like
for
this,
so
we
can
see
here.
I've
I've
had
these
functions
that
I've
named
mock
here.
So,
as
I
was
mentioning
previously
the
functional
strategy
pattern-
and
actually
I
believe
I
have
a
nice
little
handy
link
here-
I've
included
at
the
end
of
the
slides
here.
This
has
helped
me
a
lot
which
is
kind
of
thinking
differently
and
and
just
a
different
way
of
approaching
a
problem.
B
I
guess
it's
a
good
way
of
putting
it
so
oh
has
a
particular
way
of
handling
this
problem.
This
is
a
functional
strategy
pattern.
Scott
wallace
has
a
wonderful
blog
post
here
and
he
has
in
several
talks
great
descriptions
and
walkthroughs
of
how
to
approach
this
problem
functionally.
But
this
is
the
general
idea
and
I've
linked
this
at
the
at
the
end,
so
in
case
you're
curious
about
reading
up
on
it.
But
that's
exactly
what
this
is
here.
B
B
So
if
we
come
over
here,
we'll
see
that
all
it
takes
to
test
my
code
here.
So
that's
usually
whenever
you're
modeling
a
problem
here,
that's
the
tricky
part
right.
Is
you
know?
How
do
I
abstract
away
the
database
because
I
obviously
don't
want
to
integration
test
my
app
every
time
I
run
the
test
harness.
B
So
how
do
I
put
a
dummy
value
in
there,
but
then
they
treat
everything
else
the
same
here
and
that's
exactly
how
you
do
it
in
this
case
here.
So
we
just
run
our
handler.
We
get
a
result
back
and
then,
in
this
case
we're
actually
running
it
all
the
way
through
draft.
So
we
will
actually
get
the
actual
payload
that
the
user
sees.
So
it
does
all
throughout
everything,
except
for
the
database
part.
B
B
So
these
are
all
testing
yep,
happy,
past
sad
path
and
it's
easy
to
to
mock
the
sad
path
here,
because
we
can
just
simply
yep
just
invent
a
a
terrible
error
and
then
return
it
back.
So
we
don't.
We
don't
have
to
worry
about.
You
know
how
to
how
to
stage
that
air
yeah
it's
just
part
of
the
mock,
so
there
we
go
so
it
moving
on
along
here
and
I'll
pause
again
here
for
a
little
bit
of
coffee.
B
B
B
B
So
I'm
just
going
through
all
the
tests
here,
just
to
show
no
there's
nothing
up
my
sleeve
so
yep.
We
can
even
test
query
stream
parameters
here.
So
I
I
have
a
route
testing,
query
stream
parameters.
So
when
you
get
exchanges
you
can
filter
by
week,
so
we
can
obviously
access
a
particular
week,
but
if
we
want
to
look
for
a
week,
so
that
was
one
use
case.
B
I
also
solved
here
as
part
of
the
api,
so
maybe
somebody's
coming
in
they're
looking
for
a
particular
week
that
they
want
to
you
know
by
the
by
the
week
value
by
calendar
picker.
So
that
would
probably
be
the
primary
case
that
somebody
would
use
so
that
that's
supported
so
yep.
So
overall,
that's
all
there
is
to
it.
So
let's
go
ahead
and
give
it
a
run
here
and
until
I've
already
given
it
a
run
before
the
demo
just
to
make
sure,
but
we'll
give
it
another
one.
B
Just
just
for
just
for
fun.
There
we
go
yep.
So
you
see
all
13
of
our
tests
pass
so
you're
good
to
go
there
so
yep
and
that's
all
there
is
to
it
so
yep
fully
fully.
You
know.
Unit
tested
from
you
know,
with
the
exception
of
the
database,
so
very
easy
to
write
in
a
functional
way.
So
this
is
yep
just
a
functional
approach
to
unit
testing
here
in
mocking
that
dependency
with
a
functional
strategy
pattern,
so
cool
stuff,
so
yep
all
right,
all
right.
B
So
now
we
get
to
move
to
the
fun
part
of
putting
this
into
azure.
So
I
will
go
ahead
and
give
a
little
bit
of
a
brief
overview
about
how
this
whole
thing
works
here
in
case,
anybody
at
home
wants
to
try
this.
You
know,
or
anybody
wants
to
play
around
the
cloud.
So
here
I
have
mongodb
compass,
it's
a
great
tool
that
mogu
provides
for
free.
If
you
need
to
interact
the
cluster,
so
you
can
see
here,
I
saved
my
credentials.
B
You'll
get
a
little
bit
different
experience
you
download
for
the
first
time,
but
you
may
be
asking
what
database
I'm
connecting
to
that
doesn't
look
like
a
local
database,
and
that
would
be
true,
so
I
am
using
mongodb
atlas,
so
you
can
actually
so
function
apps
as
your
last,
I
checked
you
get
a
million,
I
think
executions
or
something
something
crazy
for
free
every
month.
I
believe-
and
here
you
can
see
starting
it
free.
B
So
if
you
want
to
play
in
the
cloud,
if
you
want
to
have
fun
and
play
with
some
of
these
tools,
don't
feel
intimidated
that
it's
it's
a
pricing
or
anything
like
that.
It's
easy
to
pick
up
these
tools
just
give
it
a
shot.
You
have
nothing
to
lose,
so
it's
tons
of
fun.
So
it's
a
great
learning
experience.
B
B
So
yep
but
yeah
I've
created
a
little
user
down
here
and
you'll
notice.
Here
I
have
a
very
large
amount
of
ip
addresses
here
that
took
a
bit
to
add.
I
will
walk
through
what
you
need
to
add
here,
but
the
primary
reason
for
this
is
because
it's
secure
by
default,
and
so
you
have
to
whitelist
every
single
ip
that
you
want
to
to
connect
to
your
database
for
security
purposes.
B
So
I
had
to
add
all
of
my
function
app,
I
ips
the
possible
ones
I
could
come
from
in
order
to
talk
to
it.
So
that's
what
that
is!
So
all
right.
So
if
we
connect
to
the
cluster
here,
just
to
kind
of
poke
around
a
little
bit
see
we'll
see
what
we
got.
This
is
the
experience,
the
tool
here
so
going
into
the
stock
exchange
database.
This
is
a
bit
of
refactoring.
B
I
need
to
do,
but
I
I
came
up
with
a
better
name
of
exchange
as
the
as
the
aggregate
I
called
it
market
it
doesn't
have
as
much
of
a
ring
to
it
marketweeks.
So
I
changed
my
mind
on
that.
So
classic
developer
thing
so,
but
these
are
the
exchanges
here
so,
but
we
can
see
all
our
data
here,
so
the
exchange
that
we
just
created
week
of
march
28th
so
empty
markets
array
here,
but
we
can
see
the
week
is-
is
present
here
and
it's
inserted
into
the
database.
B
So
all
right,
so
you
may
ask
yourself
if
you've
never
worked
with
azure
before
how
do
I
get
this
function
into
the
cloud
and
there's
many
different
ways
of
doing
it?
You
could
set
up
a
pipeline
azure
pipeline
if
you
really
want
to
like
set
it
up
to
repo,
but
if
you're
just
playing
around
with
this
and
just
trying
to
have
fun
and
and
just
kind
of
explore,
there's
this
handy
azure
tool
or
extension
that
you
can
add
to
vs
code
you'll
notice.
B
B
B
I
will
actually
mention
f
f-sharp,
at
least
I
don't
recall
specifically
which
feature
it
is
or
if
it's
just
f
sharp
in
general,
but
3-1
is
important
to
the
code
that
I'm
I'm
running
on,
and
that
is
what
my
fs
proj
is
set
to.
So
if
you
download
my
example
play
with
it,
dot
net
three
one
so
so
we'll
go
to
review
and
create
here.
So
this
is
the
whole
experience
here.
B
B
C
C
B
B
Is
that
and
it's
very
good
at
that,
especially
with
the
effect
that
type
providers
feature
where
you
both
types
in
from
a
type
provider
but
but
yeah.
I
I
want
to
show
it
as
a
api
to
here
just
so
that
way,
since
it's
always
kind
of
relegated,
I
think
to
like
that
tool
context,
or
something
like
that.
So
it's
it's
also,
I
think
very
good
for
business
purposes,
but
yeah.
So
not
not
yet.
I
guess
for
me
by
answering.
B
B
B
So
the
best
thing
I
think
one
of
the
best
features
of
f
sharp,
is
its
ability
to
as
a
as
scott
walsh
walks
through
here.
He
essentially
creates
a
statically
typed
state
machines
in
in
code,
so
I
think
for
business
purposes
like
he
has
here
and
I've
actually,
so
this
is
kind
of
barred
from
a
talk
I
gave
on
typescript.
So
this
isn't
the
only
language
you
could
necessarily
implement
this
in,
but
I
think
compared
to
c
sharp,
where
it
is
not
a
function.
B
First,
language
and
it
doesn't
have
things
like
some
types
code
like
this-
is
very
awkward
to
write.
So,
like
your
questions,
addressing,
I
think
things
like
this
especially
stuff
like
this
right
here
where
business
requirements
I
feel
like
there
are
a
lot
of
things
that
corporations
chase
right
now,
specifically
with
unit
tests.
B
You
know
static
analysis
and
stuff
like
that,
and
I
think
here
with
static
types
I
mean
I
can
think
of
nothing
better,
because
you
know
tests
get
slow
stuff
like
that,
but
having
the
compiler
itself
enforcing
business
rules
and
encoding
them
into
it
into
your
code
base,
I
mean
everybody
has
to
get
the
code
to
compile
to
deploy
to
fraud.
So
I
think
the
practice
of
this
itself
makes
your
code
so
much
safer,
so
I
I'm
definitely
sold
on
that
specifically
with
apis.
B
B
I've
been
leading
a
book,
a
club
there
where
we've
been
going
through
it,
but
I'm
convinced
that
this
is
great
for
apis,
because
that's
all
apis
are
transformations
with
concrete
states
state
machines,
so
you
can
gain
if
you
can
let
the
compiler
do
the
heavy
lifting
of
ensuring
that
your
transformations
line
up,
because
I
I
tend
to
find
that's
the
the
hardest
part
about
web
development
is
integrations
and
accounting
for
all
of
the
states
that
can
happen
with
them.
I
I
think,
that's
a
I.
B
B
B
Even
these
pattern
matches
here
so
as
a
general
practice,
I'm
kind
of
just
barely,
I
think,
leveraging
it
here,
because
it's
a
very
simple
project,
but
here
essentially
I'm
getting
a
type
back
from
this.
This
update
market
repository
so
a
common
pattern
that
I
find
really
good
in
functional
programming,
with
f
sharp
in
general,
as
I
can
model
the
return
types
here
and
like
you're,
saying
in
a
c
sharp
world.
B
So
c
sharp
just
expects
you
to
try
to
try
catch,
so
you've
got
to
kind
of
know
what
the
other
guy
wrote
and
what
what
to
catch
under
you
know
from
his
function
in
java,
they
get
very
verbose
with
it
and
put
the
the
throw
syntax
into
the
the
function.
Signature
itself,
I
feel,
like
f,
sharp
itself
and
other
functional
languages,
do
a
great
job
at
solving
that
problem
for
good,
because
they
simply
just
encapsulate
types.
So
I
can
simply
say
like
right
here
I
could
say
well
the
update
operation
itself.
B
B
It's
forced
to
match
against
it,
so
I
have
to
handle
every
single
case-
that's
possible
here,
so
so
I'm
I'm
basically
forcing
the
consumer.
So
if
I
like,
like
your
question,
is
very
well
worded
totally
set
up
perfectly
for
this
case
here.
So
if
I
was
to
write
the
database
handler
and
have
some
other
developer
pick
up
the
other
piece,
I
would
feel
confident
with
f
sharp,
knowing
that
he
would
have
to
match
against
this
expression
here.
I
could
toss
this
over
to
him
and
he
would
know
okay.
B
Well,
I
got
a
match
against
this
and
when
it's
successful
I
get
this
type
here,
but
I
also
have
to
handle
these
other
two
cases
explicitly
and
account
for
them.
So
I
think
it
helps
clarity
of
the
code,
so
you
don't
have
errors
lurking
under
under
the
covers,
specifically
with
io.
I
think
that's
like
a
very
hard
part
of
programming
io,
and
it
also
helps,
I
think,
with
refactorability,
so
jumping
back
into
the
the
repository
here.
B
So
whenever
say
we
have
another
state,
I
need
to
add,
so
I
could
simply
add
it
in
here
and
it
compiles
here.
But
if
I
go,
my
tooling
here
is
a
little
slow
here,
but
it'll
actually
catch
up
if
I
recompile
it
and
it'll
yell
at
me,
because
I'm
not
exhaustively
matching
this
this
expression
here
so
so
that's
also
helpful
too.
B
C
That
question
prompted
another
question,
which
is
usually
how
questions
work,
the
the
thing
that
I
see
that's
missing
there
is.
I
like
the
idea
that
you
can.
You
can
define
some
context
around
your
types
right,
which
is
what
you're
doing
you
have
that
higher
level.
You
know
saying
these
are
the
things
that
I
expect.
The
problem
is:
is
that
when
you're
working
with
external
apis,
you
know
what
you
expect,
may
not
be
what
you
get
so
you
can.
C
You
can
have
this
definition
that
you
you
arrive
at
and
say
well,
this
is
what
I
expect
and
then
you
know
joe
blow.
Api
person
decides
they're
going
to
change
that
out
from
underneath
you
and
now
things
don't
line
up
anymore.
So
what
is
that?
How
does
f
sharp
handle
those
types
of
situations
when
you
know
what
you've
defined
as
your
expectations
around
your
type,
no
longer
hold?
True.
B
Yeah,
that's
a
that's
a
great
question,
yep
and
and
yeah
and
the
modeling
piece
of
it.
So
off
the
cuff.
My
response
to
that.
If
I
was
to
to
write
this
in
f
sharp,
so
I
think
that's
a
great
candidate
for
you
know
for
those
for
the
previous
question
so
that
that's
this
is
where
the
warning
comes
in
so
f
sharps.
You
know
giving
me
a
bit
of
nudge
that
I'm
not
exhaustively
type
checked
here
to
your
question
there.
B
B
So
this
is
a
little
bit
convoluted.
This
is
just
some
code
I
was
playing
with,
but
there's
this
result
type
within
f
sharp
here
see
if
I
can
find
a
better
use
case.
Here's
here's
one
result
of
t.
So
that's
a
that's
an
excellent
question
and
I
I
think
the
the
best
answer
to
that
in
a
functional
sense
is
to
wrap
it
with
a
type.
B
So
if
I'm
unsure
that
this
other
api
could
change,
it's
always
best
to
plan
for
failure,
so
it
could,
it
could
work
or
I
could
get
a
string.
You
know
error
message
back
and
then
model
it
that
way,
you're
correct
in
that
and
that's
a
very
good
point
and
that
it's
not
a
silver
bullet
in
the
sense
that,
with
like
without
an
integration
test
or
something
actually
running
that
end
point.
If
joe
blow
over
there
decides
to
not
not,
you
know,
throw
a
third
curve
ball.
B
Our
way,
there's
no
way
the
compiler
will
know
about
it,
because
it's
not
a
type,
but
our
consuming
system
here
can
kind
of
defensively
act
against
it
in
the
sense
that
we
could
say.
Okay,
well
joe
decides
to
throw
us
a
curveball
that
day
I
need
to
you
know.
Obviously
this
is
a
different
context,
but
I
you
know,
I
need
to
wrap
it
with
a
type.
So
I
model
it
as
I
don't
you
know
it
could
fail.
Joe
could
have
a
bad
day.
You
know
so
that
would
be
my
thinking
about
it.
B
Okay,
I
believe
haskell
does
that
that
way
too,
so
they
they
take
it
to
the
nines
with
the
iomonet
and
all
that,
but
even
with
them.
I
think
that
it's
possible
to
have
so
they
have
a
couple
of
functions.
To
my
knowledge
that
pull
straight
from
the
from
a
from
a
file,
I
believe,
and
it
can
it
could
still
bomb
so
or
a
parson
integer.
That's
what
it
is.
B
So
if
it
could,
if
you
don't
hand
it
an
integer,
they
provide
it
for
convenience
if
you're
doing
like
a
quick
one-liner,
but
it's
kind
of
you
know
frowned
on
so
because
you
know
it's
it's
unsafe,
so
yeah
it's
so
they
would
probably
say
it's
not
modeled
correctly,
because
you,
you
always
have
to
model
the
sad
path.
So
yep,
okay,
so
I
I
it
is
a
great
question,
great
question:
is
it
yeah,
like
all
things
with
all
tools
like
you?
Can
you
know
the
the
way
I
see
it
is?
B
If,
if
you
you
know
just
like
even
even
an
object-oriented
sense,
I
think
this
is
kind
of
some
overlap
like
if
you,
if
you
don't
use
the
tool
correctly
or
you
don't
account
for
all
the
cases,
there's
still
only
so
much
it
can
help
you
before.
You
know,
if
you
don't
model
the
you
know,
if
the
problem
isn't
modeled
correctly
from
the
start,
then
it
can.
You
can
still
have
bad
effects
happen
from
it.
So
you
know
but
yeah.
This
is
a
great
question.
B
Man
you're
totally
speaking
my
language.
So
that's
awesome,
yeah
and
I
I'd
highly
yeah.
I
think
I
posted
this
in
the
chat.
This
is
a
very
much
more
complex
solution
that
well,
yes,
a
much
more
real
world
and
complex
solution
that
scott
washington
represents
where
he
takes
this
a
little
bit
further,
and
I
think,
if
you're
curious
about
this-
and
my
talk
has
spurred
some
curiosity-
this
is
a
great
place
to
to
have.
B
It
explained
a
little
bit
deeper,
a
little
bit
more
concrete
outside
of
a
fun
little
animal
crossing
example
where
we
could
take
a
business
problem
and
represent
it.
He
also
has,
in
his
book
a
good
example
of
a
shopping,
cart
and
modeling
that
as
a
state
machine
itself,
so
it's
types
transitioning,
so
obviously,
in
an
object
or
in
a
sense
you
can't
have.
B
I
can't,
for
example,
check
out
with
an
empty
shopping,
cart
right,
so
I
can't
jump
the
state
machine
from
empty
cart
to
to
check
out
and
pay
for
it.
So
he
has
a
model,
says
the
state
diagram
and
then
uses
the
types
themselves.
So
transitions
happen
with
functions
themselves
and
it
it
only
allows
you
to
move
to
the
proper
state
within
the
tight
system
itself.
So
all
of
the
type
signatures,
for
example,
the
checkout
function,
will
only
take
a
a
shopping.
B
So
and
actually
there
was
a
really
good
talk,
I'll
link
it
after
I'll
have
to
look
up
the
the
author
again,
but
at
recent
conf.
So
I've
been
doing
a
little
bit
just
to
kind
of
the
rails
a
little
bit
here.
So
there's
a
new
language
out
of
facebook.
This
is
front
end,
but
they've
actually
kind
of
had
some
issues
with
typescript
in
terms
of
how
slow
it
can
be
because
they're
facebook
and
they
have
tons
of
code.
B
So
so
they've
naturally
written
their
own
new
language.
This
has
a
lot
of
the
same
concepts.
I've
just
touched
on
with
f
sharp
and
they
adopt
the
same
principles.
But
if
you
look
at
their
type
section
here,
they
also
actually
are
bringing
these
concepts
to
the
front
end.
So
you'll
see
all
the
arguments
about
how
they
model
their
problems
on
the
front
end,
because
the
front
end
has
very
similar
problems
in
terms
of
it
yeah.
So
he'll
they'll
talk
about
yeah
that
looks
very
familiar
to
the
shark
code.
B
I
just
showed
so
oh
yeah
result
of
you
know
so,
as
michael
may
was
just
very
well
pointing
out.
You
know
always
modeling
the
sad
path,
diligently
accounting
for
errors
and
and
they
model
it
here,
but
they're
taking
that
same
concept
and
applying
it
to
the
front
end
so
I'll
see.
If
I
can
get
that
linked
to
the
post
of
this
or
put
on
the
youtube
comments,
the
talk
that
I'm
referring
to.
B
B
I
think
interacting
with
results
rather
than
side
effects,
helps
a
lot
too
because
you
can
gain
that
assurance
so
hopefully
that
that's
making
some
sense
but
I'll
link
that
that
talk
afterwards
but
yeah.
That's
excellent,
excellent
question,
so
yep
yep
and
yeah
rescript
here,
if
anybody's
curious,
a
lot
of
fun
to
code
in
on
the
front
end.
So
if
you're
you're
in
react,
you'll
love
free
script,
so
all
right
I'll.
B
It's
a
mixture.
I've
done
a
bit
of
front
end.
Did
it
back
in
so
I've
done
a
little
bit
of
ujs
recently.
So
I
used
to
be
a
big
react
guy
at
the
last
two
jobs
and
typescript,
I've
done
a
bit
of
ugs
at
b-line
since
being
back
at
b-line,
a
bit
of
node
and
yep.
So
it's
been
a
combination
of
those
two
and
a
lot
of
kubernetes.
B
That's
that's
a
great
question,
and
yes,
absolutely
so,
obviously
to
varying
degrees
and
yeah,
so
specifically
with
typescript
and
I'm
glad
she
brought
it
up.
So
when
I
was
so
my
last
job,
we
we,
it
was
a
insurance
context,
so
I
actually
modeled.
So
this
is
just
a
little
code
snippet
I
wrote,
but
you
can
actually
model
this
exact
same
problem
as
as
we're
doing
an
f
with
f
sharp
in
typescript.
B
It's
a
little
bit
more
verbose,
but
you
can
absolutely
achieve
the
same
thing.
You
get
type
safety,
so
here
we
have
our
state
machine
rendered.
So
you
know
if
the
user
is
filling
out
a
signup
form
I'll
scroll
down
to
the
bottom
here,
so
people
can
see
it
in
action
here
so
pass
the
code
snippets
there
we
go
yep
so
yeah,
so
this
is
using.
So
this
is
the
redux
dev
tools
over
here
on
the
right
and
then
we
have
a
little
signup
form.
So
this
is
a
great.
B
I
think
in
this
case
it's
a
good
business
use
case
common
thing.
I
need
a
user
to
sign
up
and
I
need
to
make
sure
that
they're
they
have
a
first
name,
a
last
name
and
a
valid
email
address,
that's
not
empty.
You
know
so,
and
I
need
to
provide
some
errors
to
the
user
along
the
way.
So
you
can
see
here
in
the
bottom,
so
redux
itself
is
in
fact
just
a
big
state
machine.
B
I've
had
to
write
my
own
function
since
typescript
doesn't
have
pattern
matching,
so
I
had
to
create
my
own
match
function
here,
but
it
reads
very
similarly
just
more
curly
braces
but
the
same
general
idea
and
it
can
be
done
and
achieved
and
we
just
map
over
to
jsx,
but
this
allows
the
view
itself
to
match
against
the
possible
cases
from
the
redux
store.
So
you
can
gain
that
type
safety
that
you
wouldn't
have
otherwise
having
programmed
in
react
and
redux
without
typescript
and
with
typescript.
B
I
definitely
prefer
with
typescript
just
because
there's
so
many
times
where
you
I
would
grab,
I
forget
what
the
property
was
named
and
stuff
like
that
or
or
what
state
you
know.
Obviously,
a
lot
of
reducers,
I
think,
tend
to
have
boolean
values
and
stuff
like
that,
like
you
were
just
saying
so
like
a
lot
of
primitive
obsession,
you
know
modeling,
you
know,
objects
and
then
just
flipping
flags
like
it's
common
in
oo.
So
this
in
this
case
we
use
the
types
to
drive
the
the
view
here.
B
B
Obviously,
I
think
a
node
without
typescript
you
can
use
javascript's
map
functions
and
stuff
to
achieve
functional
structures,
but
I
I
you
won't
get
the
type
safety
without
typescript,
but
if
you
introduce,
if
you
convince
people
to
use
typescript,
I
had
a
had
a
great
time
with
it.
My
last
job
we
implemented
typescript.
All
the
way,
through
our
front
end,
so
I
actually
got
the
chance
to
get
in
on
the
project
early.
B
So
I
was
the
lead
developer
over
there
and
I
introduced
to
the
team
typescript
and
they
learned
to,
I
think
like
it
by
the
end
of
it.
So
it
was.
It
was
a
great
experience
and
our
code
base
was
a
lot
easier
to
refactor
because
of
it
so
yeah.
So
hopefully,
hopefully,
I've
answered
the
question
decently,
but
that
that's
been
my
experience.
B
And
I
am
looking
at
the
time
here,
so
I
don't
want
to
keep
people
too
long,
I'm
not
sure
how
long
the
talk
was
slated
for,
but
I
can
wait
for
questions
so
I
go
through
here
for
this
last
little
part
here.
So
now
we
deployed
this
resource,
so
in
azure
here
we
can
toss
this
up
here
into
our
azure
cloud
here.
B
B
Stuff
all
right-
and
it's
that
easy,
so
if
you've
never
for
those
who
haven't
dabbled
in
azure
at
all,
I
know
for
me
whenever
I
went
to
a
lot
of
talks
with
it:
oh
yes
or
azure.
For
a
long
time.
I
see
somebody
showing
me
all
these
cool
things
in
the
cloud,
and
so
I
got
you
know
it
could
be
a
little
intimidating
with
azure
is
that
it
they've
made
it
very
accessible
for
function
apps.
B
B
D
B
B
B
B
All
right,
so
we
can
see
here
that
we
got
our
function
all
deployed
up
up
and
running
here.
I'm
gonna
grab
the
function
url.
So
this
this
should
look
familiar.
So
this
looks
a
lot
like
the
route
that
I
set
up.
So
that's
good
to
go.
Now
I
will
say
the
caveat:
is
I've
not
added
the
configuration
for
my
database,
so
we
are
probably
not
going
to
get
a
good
result
here
and
I
am
completely
new
at
streaming.
So
I
do
not
want
to
paste
my
connection
string.
B
So
when
you
deploy
this,
I
will
offer
a
fair
warning
that
well
go
to
go
to
the
function
app
over
here
and
add
your
connection
string
in
and
it's
under
properties
or
configuration.
I
believe
right
over
here,
so
you
just
toss
your
connection
string
in
and
you're
good
to
go,
but
yeah
so
yep,
but
well
you
know
what
I'll
just
make
a
new
one,
so
well:
okay,
nevermind,
oh
yep,
that
that's
the
general
gist
of
it,
give
it
a
shot
all.
B
B
B
B
B
B
C
Enter
while
we're
waiting,
if
you
use
the
so
you
can
run
function
apps
within
vs
code,
all
you
have
to
do
is
install
the
storage
emulator
and
you
can
run
them
directly
within
vs
code.
Yeah,
it's
pretty
nice!
You
just
have
to
you
have
to
install
like.
I
said
you
have
to
stop
install
the
azure
storage
emulator
and
then
and
then
you
can
just
have
five
debug
locally.
B
C
The
one
thing
I
like
about
azure
functions
is
the
you
know
the
triggers.
They
have
honestly
one
of
the
triggers.
I've
used
a
lot
lately
believe
it
or
not,
is
just
the
timer
trigger
which,
if
you
need
something
to
run
on
a
schedule,
I
mean
it's
perfect
for
that
sort
of
thing,
but
they
have
a
whole
collection
of
triggers
that
you
can
have
your
your
function
run
on
http
and
you
know,
messages
coming
in
a
service,
bus,
cue
and
all
kinds
of
stuff.
B
Gotcha
yeah
yeah,
it's
it's!
It's
pretty
wild
they're
yeah,
the
a
bit
of
stuff
I've
done
with
yeah
yeah
with
them.
It
has
been
great
and
yeah
logic
gap
stuff,
like
that.
It's
it's
so
easy
to
just
you
know,
put
them
together
so
yeah
for
anybody.
That's
not
not
dabbled
in
azure
or
done
anything
cloud.
I
should
say
it's
it's!
It's
a
lot
of
fun,
so
very,
very
good
points.
So
I've
run
into
this
right
here.
B
So
if
you
get
this,
when
you
try
to
run
my
code
here,
this
is
coming
from
because
I'm
guessing
I
was
hoping
that
the
list
of
ip
addresses
was
static.
It
looks
like
it's
not
so
I'm
going
to
do
the
super
secure
open
to
everything
briefly
for
the
demo
here.
This
should
deploy
mongodb.
So
this
is
a
good
I
guess
troubleshooting
tutorial
as
well.
So
all
of
these
did
not
save
me
apparently
from
the
security,
which
I
guess
is
a
good
thing,
but
that's
what's
going
on
there.
B
B
B
Hey
look
at
that
all
right
yep!
So
that's!
That's
all
that's
going
on
there.
So
there
is
a
way
to
grab
the
eyepiece
outbound
eyepiece.
I
believe
it's
under
azure,
storage
or
sorry
resource
explorer
and
you
have
to
if
you,
google,
it
outbound
ips
for
function.
Apps
you'll
see
a
microsoft
tutorial
and
they'll
walk
you
through.
Where
it
is
it's
a
little
bit
to
get
to.
You
got
to
go
through
their
json
records
of
your
function.
B
C
B
It's
actually
it's
been
a
mixture,
so
the
last
two
jobs
I've
had
have
been
a
mixture,
but
it's
been
more
75
25.
I
think
you
know
three,
three
three
quarters
of
it
was
front
end
and
then
25
was
back
in.
I
was
just
kind
of
pitching
as
needed.
I
found
there's
a
huge
gap
of
of
people
that
are
good
at
front
end
tech,
like
react,
redux
and
stuff
like
that,
so
that
was
kind
of
the
hat.
B
I
I
had
to
wear
to
help
get
it
off
the
ground,
but
but
with
the
type
script
you
could
you
could
easily
that
I
just
did
the
same
thing
that
we
we
just
went
through
with
f
sharp
and
you
could
transition
that
that
same
pattern
over
between
the
two
but
yup,
so
yeah
b-line
has
been
about,
let's
say,
probably
well
actually,
so
I've
actually
been
doing
a
lot
of
infrastructure.
Honestly,
that's
been
the
majority.
If
I
had
to
so
it's
like
another
category.
B
I've
been
kind
of
introduced
to
with
kubernetes,
so
they
have
a
kubernetes
cluster
they've
set
up
and
had
to
learn
kubernetes
manifest.
So
it's
been
a
been
a
fun
exercise.
So
I
know
there's
a
lot
of
kubernetes
jokes
out
there
about
learn,
kubernetes
and
500
steps
or
500
easy
steps.
I
think
there's
a
book
out
there
like
that.
So
that's
been
my.
I
think
it's
true.
B
That's
a
great
question:
it
could,
I
think
not
that
I
know
of.
I
guess
this
is
the
right
answer,
but
so
I
think
yeah,
but
that
could
that
could
totally
change
I've
and
I
think
you
could
apply
it.
Excuse
me.
I
think
it
can
be
applied
to
so
many
different
areas
so
like
with
wave
apis
azure
functions
here.
So
I
think
it's
a
great
great
thing.
B
B
You
know
a
way
of
getting
people
used
to
some
functional
ideas.
I
actually
had
a
lot
of
success
with
that
at
my
last
job
we
used
a
framework
called
fpts
and
it's
written
by
this
italian
rock
climber
guy
who's,
a
math
wizard.
So
if
you
be
warned
if
you
read
his
blog
it
most
of
it
goes
way
over
my
head,
and
these
are
his
inspirations,
so
take
that
with
the
with
with
the
caution
it
deserves.
B
But
but
the
overall
use
of
this
library
is
great
in
terms
of
it
has
option
it
has
either
and
they're
all
written
in
typescript.
So
you
gain
all
the
type
safety
of
these.
What
are
type
classes
in
haskell,
adapted
to
typescript,
and
I've
had
great
success
with
people
being
introduced
to
you
know
these
patterns,
so
it's
kind
of
dressing
it
up
in
a
different
way.
It
helped
me
get
past
some
of
that.
B
I
personally
have
enjoyed
working
with
it
inside
projects
and
stuff
like
this,
but
I
think
sometimes,
when
you
drop
it,
you
know
on
people
you're
like
I
don't
want
to
learn
a
new
language
stuff
like
that
this
looks
scary,
but
if
you
say
typescript
and
then
you
do
some
functional
concepts
with
it,
you
know
it's
kind
of
like
I
guess
when
parents,
you
know
put
you
know
like
they
dress
up.
Vegetables
is
something
else.
It's
the
same
idea.
B
B
Yeah,
I
think,
f,
sharp
kind
of
has
the
the
one
the
one
thing
about
it
is.
I
think
you
have
to
get
that
group
consensus
and
team
consensus
going
as
far
as
people
feeling
comfortable
with
working
with
it
and
everybody
on
the
team
on
board
and
management
on
board,
because
it's
not
as
popular
as
c
sharp.
So
from
a
pragmatic
standpoint,
the
replacing
or
adding
new
f
sharp
developers
may
be
a
harder
sell
than
you
know
typescript.
B
So
I'm
a
bit
vanilla,
but
I
love
ps
code,
so
I
I
use
vs
code
for
typescript
and
use
it
for
I've
fallen
in
love
with
it.
I've
tried
I've
briefly
used
emacs
or
I
think
it
was
vsp
or
space
code
space
max.
I
say
space
code
because
I
use
the
the
extension
for
the
emulate
space
max
and
in
a
vs
code,
but
I've
since
I've
got
that
extension.
So
I
have
that
going
so
I
can
navigate
around.
B
A
B
Yep
yeah,
that's
exactly.
We
actually
had
some
developers
that
were
oh,
I,
like
this
other
editor
and
then
they
you
know
they
filled
with
it
for
like
a
day
and
then
they
came
to
me
and
it
was
yeah
exactly.
She
was
very,
very
much
much
anguish
and
then
I
was
just
like
it.
Just
it's
all
vs
code
and
it
just
worked.
So
I
so
they
you
know
it
may
not
have
been
their
favorite
editor,
but
they,
you
know,
it
is
credit.
It
works
right
out
of
the
box,
so
I've
and
I've
enjoyed
it.
B
A
B
I'll
catch
him
yep,
I
think
I
think
michael
mann
may
have
mentioned
that
a
bit
ago-
yep
not
not
currently,
so
not
in
any
for
like
production
sense
like
I
just
demoed,
so
maybe
for
transformations
and
stuff
like
transforming
like
json
files
and
stuff
like
that
right,
but
yeah
for
for
an
api.
I
don't
think
any
of
our
apis
are
yet
written
in
fsharp.
But
who
knows.
B
Yeah,
this
definitely
is
still
predominantly,
I
think,
c-sharp
in
the
dot-net
world,
so
yeah
and
with
the
way
things
are
going
I've.
You
know
I
kind
of
find
it
funny
in
a
sense
like
c-sharp
introducing
record
types,
you
know
so
they're
kind
of
borrowing.
I
think
a
lot
of
sharp
nine
non-rollable
reference
types
record
types.
So
a
lot
of
the
stuff
yeah
pattern,
matching
enhancement,
so
who
knows
maybe
c
sharp
and
that
sharp
will
merge
forces
at
some
point.
B
Starting
to
it's,
so
you
know
who
knows,
I
guess
that
that's
actually
probably
you
know
to
michael
men's
last
question
about
coding
in
you
know,
even
these
features
right
here
if
you're,
if
you're
in
c-sharp
and
stuff
these
concepts
are
probably
a
welcome.
You
know
thing
to
you
because
they're
starting
to
mainstream
it
into
the
language
itself,
so
yeah
yeah.
A
Awesome
cool
and
thanks
for
mike
for
tracking
you
down
and
bringing
you
in
so
the
session
will
be
available
for
view
later
it's
been
recorded
so
we'll
post.
That
link
is
actually
we
won't
post
a
link,
it's
the
youtube
link,
so
you
can
go
back
and
watch
it
afterwards,
anytime.
You
want
so
awesome.
Well,
thank
you
and
we
will
hopefully
see
you
next
month.
All
right
awesome
sounds
good.
Thank
you
guys.
Thanks.