>> In this episode of the ON.NET show,
we're going to have Phillip Carter joining us again,
and he's going to tell us all about building
web applications with the F# programming language.
>> Hi, my name is Cecil Phillip,
and welcome to another episode of the ON.NET show,
and today I have with me Phillip Carter.
How are you doing Phillip?
>> Hey, how is it going? I'm doing pretty well.
>> Doing pretty good, man. So, you're
here today to talk to us a little bit about F#,
and not only just F# but,
F# Web Development, right?
>> Yeah, exactly. So, last time I was here,
I talked a little bit about some of
the new stuff that's coming along for
F# like language wise and showed some of
the stuff in the tools specifically for Visual Studio,
but there's a lot more than just F# inside of
Visual Studio, and in particular,
F# on .NET Core, has a lot
of options for doing web based programming,
especially for web APIs,
and I personally think it's a really great fit for that.
So, I wanted to go over some
of the different options that you have available.
>> Sure, sounds pretty good.
And you have some slides
too that you want us to take a look at very quickly.
>> Yeah, absolutely.
So, there is numerous options
for web programming with F# and .NET Core.
I think you can even just do a console app
that has HTTP listener,
and just listens on import or something like that.
But, there is sort of five main ones I think,
there's ASP.NET Core MVC,
which any C# ASP.NET
programmer should understand already, basically,
there's Giraffe, which is sort of like- So,
ASP.NET Core is like more of a low level thing,
and MVC is a framework on top of it.
Well, Giraffe is like
a functional library on top of that lower level thing.
So, it's very similar to MVC,
but it's functional instead of object oriented.
And it's actually derived from Suave,
which I'll talk about as well which is on- its,
Suave is something that came before all of this.
Saturn is another option,
it's a relatively new one,
and it's actually built on top of Giraffe,
and basically Giraffe is more kind of a lightweight,
build only what you need sort of thing.
Whereas, Saturn is like
okay we've got batteries included,
We got all sorts of different stuff for you if
you want a bit more of an opinionated way to do things.
>> So it sounds like pretty much based on whatever
your programming style is or whatever
your particular need happens to be,
I could just say hey give me like
this little lightweight thing
that I could use to build my application, or hey,
maybe I need some more pieces,
I need scaffolding, I need database migration,
and some of these other things that I
can pick another framework,
will have those things already wired up for me,
so it makes a little bit easier for me to get going.
>> Exactly. Then we have Suave,
which I mentioned before.
It's been around for quite a while,
and it has a particular syntax
to building your API routes,
that was actually used by Giraffe,
and so I'll show kind of what that looks like.
And then there's Freya, which
is a really interesting one that's,
it's a purely functional web framework,
so it's, well more functional,
if you will, but it uses some more advanced concepts.
The sort of model the HTTP abstraction,
pipelined sort of stuff and so like if you want
to get really functional Freya is the one for you.
So, I kind of want to go through each of
these a little bit and sort of just talk like,
which ones you might
want to choose and that sort of stuff.
>> That's cool, so which one do you want
to talk about first?
>> Yeah.
>> So we got good ASP.NET Core MVC.
So, it's in the box, with VS 2017,
and the Data Code SDK,
you just type ".NET new" at
the command line, it's already there.
There's a few options there available.
It's fundamentally
an object oriented programming framework.
So, if you're interested
in learning functional programming,
doing this is not
necessarily a way to learn functional programming.
However, if you want to have
functional programming put on
top of something that you're already familiar with,
in particular if you're C#
and object oriented programmer,
then this might actually be a really good option for you.
Because, you can wire up APIs
exactly the same way that you would do it in C#,
and then you can
connect that to like a functional library,
just like a core thing
that executes all of your logic and then
it just calls into stuff
that you're already familiar with.
>> I think the thing with that too,
is that you know, if I'm already a ASP.NET Core
C# Developer,
I could always look at some of
the things that I'm used to doing,
and I could look at it in the F Sharp way of doing it,
and it kind of helps me translate
back and forth between the two, right?
>> Yeah.
>> I'm not necessarily worried about,
hey let me learn this API, per se.
I'm also not thinking about,
like how do I translate between different languages.
I wanted to learn what's the F# in a way of doing.
>> Exactly. That's kind of the way that I look at it,
unlike you know, F# fundamentally,
has all the object oriented features that you want,
but it is a functional first language.
So, we basically say, "Hey,
object oriented is great for solving particular problems,
functional is great for solving particular problems."
We have a set of defaults in the language that
are meant for functional programming,
but you can opt into
object oriented programming depending on the situation.
And so one of the situations might be,
I'm a C# ASP.NET Developer,
I know I'm interested in functional,
but I don't know what it's all about.
Let me apply some stuff that I know,
so I can get something going,
and then just kind of slowly start to learn functional.
So, the point where maybe I could even
transition away from the old stuff,
if I feel like that makes sense to me.
>> Got you.
>> Yeah.
>> So for the F# and MVC stuff,
are there templates already available for Visual Studio,
Visuals Studio Code that can help me get started with?
>> Absolutely. How about I swipe on over,
and show you what it looks like?
>> Let's do it.
>> So, I've put up file, new project already,
because I'm terrible with mouse pad and I'm just
going to like it's going to be embarrassing
if I try to select this menu.
You'll notice under the Visual F# Node here,
there's a thing called "Web",
there's a thing called ".NET Core".
You'll be able to see that in either those two places,
this ASP.NET Core Web Application.
So, we'll call this FunTimes,
because we're having a fun time,
and I blew up the font on Visual Studio.
So, this in particular looks funny.
But I have Tonic chord 2.1,
Installed on my machine.
I'm not going to enable docker
support because I don't have it running,
but I can enable that as well.
All that would do is just scaffold like a Docker
compose file and Docker Yammer file, things like that.
So, anyways, you get that nice little start page.
It's going to restore some packages,
like any old .NET Core thing do.
We have basically three files
here that should be the most familiar,
this program.fs, which hopefully know what that does,
Startup.fs, where we'll do a little bit of work.
This is very similar to the C# startup.cs,
except it's written in F#,
and there is Configure Services,
Configure Member Overload that sort of stuff that's
all- it's the same thing just written in F#.
Then we have this values controller,
which is just our values.
So, you'll notice in this Get,
we have this static array of values,
and then we have this other Get
that has this value "value".
Let's do something a little bit
better and try to factor this out,
treat this values thing as if it were like a database.
>> Got you.
>> We'll pretend that it's a database,
because that's for FunTimes.
So, I'm just going to go to add new item on
your Source File, call this ItemsService.
>> ItemsService sounds good.
>> Yeah. Name doesn't matter too much.
I'm just going to make this namespace,
so we have a difference between F#,
as we have modules and names spaces.
Modules are kind of more for
Communicating things between F# sources.
They are fundamentally just like namespaces,
therefore holding code,
organizing code, things like that.
They can also hold values, whereas namespaces cannot.
Whereas, name- and so
I'm just going with the namespace right now,
because I generally like to have
top level namespaces instead of top level modules,
but you can do whatever you want, really.
So, the way that ASP.NET works,
is if you want to do something,
you've basically got to use dependency injection.
Like, if you want to do it the right way.
So, lets teach you how to do it the right way,
but just in C#.
Right. So, we know we going to have to need
an interface and that's something
that implements that interface.
So let's start with the interface.
We'll call that, IValuesService.
Okay. And this is a type,
like there is no interface here,
this is just a type, and I'll go "member GetAllValues"
and I'm not going to
actually write like the body of this thing,
I'm just going to say this is from "units
to string array" because if we look at,
in this values controller here,
we have an array of strings.
So, we want to just have a string right there.
>> Right. So my C# brain,
as I'm looking at this, what I'm
seeing is that you have defined an interface,
and I have some function called
GetAllValues that takes no parameters,
but returns an array of strings, all right?
>> Yeah.
>> Okay. This will be a string. Oh right.
I need to go abstract,
because I'm inside of an interface,
because I'm live coding, I'm just forgetting on the fly.
So, here we have an interface.
If I hover over the Tool Tip in here you can see this is
type IValuesService and it has two members
an abstract member, this is GetAllValues,
given a unit which is nothing,
that's same thing is void, give me a string array,
and then there's get value which given an int,
gives me a string, which matches
what value controllers doing here.
Give in an int, give me a string.
So, let's go ahead and implement this interface.
So, we'll go, we'll just call it ValueService.
So, to implement it,
I'm going to have to go interface,
IValuesService with,
and notice how I did this double underscore thing.
I could go this dot,
I could go x dot,
I could name it whatever I want.
That's if I want to refer to the actual this,
I need to give it a name,
but because I'm not going to do that,
I can just go with the double underscore,
which is basically a way of saying,"Hey,
this is a member, it's defined on this type,
but I don't really care what the name of it is,
because I don't need to access something on myself."
>> Got it.
>> So, we go GetAllValues.
That's right. We need an actual set of values,
so we'll just take this out.
>> Or just borrow some values from the other one?
>> Exactly. This is our values database,
which I don't know
if you would actually want to
do that in real code, but, you know.
Okay, so-
>> Is values database now,
I guess a field or a property?
>> Yes.
So, this is just a letdown value inside of a class.
So, we have these let bindings which are very
similar to a var except there are immutable.
But they can also be defined inside of classes.
And when they're defined
inside of classes they're private.
So, I'm not going to be able to access this outside,
like when I've instantiated a value service,
I'm not going to be able to go.valuesDB.
>> Yeah.
>> It's just hidden by default. So, this is
just like a nice convenience for-
>> For how you could scope some of your values.
>> Yeah, exactly. It's similar to a field.
So, you noticed I still have a compiler error
because I haven't implemented GetValue.
So, I'm going to go ahead and do that.
GetValue takes an int.
So, we'll call that index,
and we'll give it a type annotation of int,
which is actually optional but
I'm choosing to do that anyways.
>> Okay.
>> So, we'll take values.
So, basically, depending on what's passed in,
we may not necessarily have a guarantee
that this is going to exist inside of this database.
So, we want to be able to
deal with the fact that that might
not exist but still be able to handle it gracefully.
>> Okay.
>> So, I'll go let results equal valuesDB,
and I'm going to use this pipe operator.
This is similar like PowerShell pipes or Unix pipes.
I'm going to pipe this into a function,
and this function is going to be called Array.tryitem.
I'm just going to pass an index as my index.
So, if you hover over "tryitem",
tries to find the nth element in the array,
returns none if index is negative,
or if the input array does not
contain enough elements, right?
So, if I hover over a result,
you'll see that it's not a string but it's
a string option, right?
But the signature of GetValue is a string.
So, I need to find a way to convert
this string option into a string.
Well, this is where the magic of F# starts to appear.
I'm now forced to deal with the fact
that I may not actually have what I'm looking for, right?
So, I can do pattern matching and I can have Some value.
I'm basically saying F results is a Some,
meaning, there's something there,
there's actually a value,
then, we'll just return that value.
But if it doesn't exist,
I need to do something with that.
Oh no, means we didn't have it.
So now, I'm fully implementing
IValuesService but I've
also dealt with the fact this ValuesDB,
I mean, you could imagine it
could come from somewhere else.
It may not have a thing that matches a particular index,
or index might also be a more complicated concept
than just an int, right?
But the concept of, "hey,
find me a thing at this location,
somewhere in this remote source
that I have," well it may not exist.
So, we need to deal with that in some way.
F# optional in dealing with those and
pattern matching are a great way to do that.
>> Nice.
>> So the next step.
We haven't done anything of values control
yet because we need to go into
startup because this is where
we need to actually wire up the interface.
>> Right.
>> So, now, we're going instead
to the configure of services.
>> Yeah.
>> That's inside our startup. Then, that's
where we're going to tap into
the Iservice collection and we're going to add
something to the DI framework.
>> Yeah, exactly.
>> So, I'm going to have to open my values.
What did I even name this thing.
Oh, item service.
>> Item service.
>> I thought I named that value service.
Well, naming it's always fun.
>> So, we go "services.AddTransients"
and we'll go "IValuesService."
There we go, and we're going to pipe this into ignore.
So, this is something
that you notice you don't have to do in C# but
you have to do that in F# because
configure services returns a unit,
meaning nothing, but add
transients returns an IService collection.
>> Yeah.
>> And C#, that just gets implicitly discarded.
But in F# it doesn't
because we're very strict about the whole.
Hey, if you're calling a thing that returns a thing.
>> You want to do something.
>> Yeah, you should do something with it.
Now, if you literally want to do nothing with it,
then, you can put it into the ignore function.
The Ignore function just says, "Oh,
you gave me a thing." Cool. Moving on.
So, now that we've hooked that up in there,
we now need to do the final thing,
or we'll go into the actual values controller,
and we'll go service,
I guess that's what I'm going to name it,
open ItemService and this will be IValuesService.
Okay. So, I now have an actual IValuesService
that the DI framework is going to throw in here.
So, in this case, we'll go
let values equals service.GetAllValues,
and right here, we'll go let
value is equal to service.GetValue.
And we're going to pass in.
>> That ID?
>> This thing called ID as the index there.
You notice in the little hover
tooltips I can go to definition and stuff like that.
Just a nice fun little thing that was
contributed by one of our open source community members.
>> Oh, nice.
>> So, I figured I'd call that out there.
So, let's just go ahead and run this real quick.
So, for people that have been following along, I mean,
this is just kind of standard ASP.NET stuff,
there was no crazy stuff that I had to do to get F# to be
working with the way that it would work with C#.
That's really the point, right?
We want this to be something that
people can use. So, were okay.
So, API values,
value1 and value2, it's what you would expect.
So, we'll go one that will give me that.
We'll go 5,000.
Oh no, looks like it's working.
>> Right.
>> So, what you can imagine I could do is,
maybe this item service is actually
a much more complicated unit while I could
create perhaps different projects,
and then, I could reference that project
from here, and then,
just call into it there, and that project could
be in an all F# projects.
Then, I could write all of this stuff with like
accessing a datasource and maybe doing some logic on it.
I could do that all in F# but I can opt
into that because now that I have stuff wired up,
if I'm familiar with C# and object
on your programming ASP.NET MVC,
I can just do this and say, okay, now,
I'm going to factor this out,
get a bit more functional
and see where that goes from there.
And that's kind of what I think the real value of this
is for people especially if they're
trying to learn functional programming.
>> Right. You know what I really
love about that point that you made is,
I can have a solution which
essentially is a collection of projects,
and I can have some of those problems might be F#,
they might be C#,
and I could mix them all together to create my solution.
So, depending on what I want to do,
I can pick the right language for the job, naturally.
>> Yeah, exactly.
But speaking of picking the right language for the job,
let's talk a little bit about
some more stuff that we have.
>> Sure.
>> Because it's not just about ASP.NET MVC.
There is a cornucopia, if you will,
of things that you can do with F# on .NET Core.
So, let's start about Giraffe a little bit.
So, Giraffe. Well, first of all,
it's got a very different logo.
>> Okay.
>> That's really cool. I love this logo.
It's super cool. It's got
the little lambda in the shape of the giraffe and stuff.
>> Nice.
>> Yeah, that was really well put together.
So, this is kind of at its heart.
I like to think of it as it's functional ASP.NET Core.
So, whereas ASP.NET Core MVC
is ASP.NET Core MVC but it's object oriented ASP.
NET core. This is functionally
ASP.NET Core, so it's a little different.
It's also it's more lightweight.
It's so like whereas MVC is a framework,
it's very opinionated in
the way you have to do things, right?
Like I have to wire up the DI if I want to use stuff.
This is much more of a library,
it's a bit more lightweight, it
feels a bit more low level when you're using it.
That appeals to a certain crowd of people,
and so that's part of the reason why I
love this because I'm
actually one of those kinds of people.
I like having real direct control
over each and every little thing.
>> I'm assuming with that you probably
get a lot better performance, maybe.
>> It depends on the workload.
I think between NBC
and Giraffe they're about the same overall,
but there might be a little.
I haven't looked at recent benchmarks,
but I know that when there were
benchmarks six or seven months ago,
they were basically the same in
terms of perf like module,
maybe a couple of requests
per second or something like that.
>> Got it.
>> So, this uses what's known as
Kleisli composition to define the API routes.
So, few functional programmers out there
and specifically those who like category theory.
I just said Kleisli composition.
That's what this uses. I hope you're listening.
Anyways, what this actually
means for the rest of us is that,
it's a really convenient way to do stuff,
and it uses fun little operators that look like arrows,
and those arrows conceptually are like, "Oh,
the thing on the left goes into the thing on the right".
It's actually, in my opinion, very easy to learn,
where you can learn the mathematical underpinnings later,
and just have some nice syntax
to work with in the meantime.
So, I think this one's recommended for people,
if you already have functional programming
experience or at least a little bit,
and you're not familiar with .NET,
or .NET Core, ASP.NET Core, or something like that,
or maybe you are, but you've
never really explored F# before,
then this is definitely a good one to
try out because it's much more functional.
So, I want to show you
a little bit about what that means.
>> Cool. Let's take a look at it.
>> Yeah. Okay.
>> I see you're already doing
this one on a different OS, right.
You're doing that now on your Mac.
>> Right. Of course, I am. So, if
I wanted to get started with this,
I already have all the template installed,
giraffe.template.
Yes, something like that. You could just
google how to do it or something.
But, basically, you do .netnew-i,
or --install.
This one install a new template
such that when you type 'dotnet new',
you'll be met with a thing,
a Giraffe Web App.
It'll say, okay, Harold,
the short name is Giraffe,
the language is F#,
and here are some tags.
So, I'll go to 'dotnet new giraffe -h',
it'll show me some options.
So, there's a dash uppercase V for a view engine.
There's a few things that it will let me do.
I can use just the defaults that it has,
I can use Razer which is actually
ASP.NET NBC Razor pages.
Well not the Razer pages text,
but it's Razor templates actually thrown in there.
It basically builds a little basic UI or I
can.Liquid which is an open source alternative to that.
Or I can go with none where basically if I just want to
have a web API and that's what I'm going to use.
So, there's IncludesTests,
there's a thing called UsePaket.
Paket is an alternative dependency manager to NuGet.
It uses NuGet like the backend,
but it resolves packages a little differently,
has a lock file that specifies
all your dependencies that you check into
source code, that sort of stuff.
So, these are all options for you.
You can play around with it in
your spare time and check it out.
But, we'll go dotnet new giraffe -V none,
and let's put that into,
we'll call that giraffe fun.
>> You had to do a new, right? Dotnet new.
>> Yeah. I am wonderful at typing on command. Okay.
>> It'd be cool if they just had
a dotnet giraffe command.
We should submit that on PR.
>> That would be cool. Okay. So, there's SRC.
Cool, actually.
Yeah. Okay. See if
I open code at least this give me what I want.
Yes it probably should here. All right.
So, it's done a design time
Builds so it's actually built
to deal on that sort of stuff.
You notice there's this paket.references file,
this came from paket where we'll store some packages.
So, few things here, programme.fs,
models.fs, httphandler.fs.
This models.fs, is just to saying,
hey this is a type, it's got message.
It is what's called and then it has a thing called text,
and this is basically going to model what we
want to put into HTTP pipeline as a response.
So, then you can have an F# type,
in this case, a record type.
You can basically have a strongly typed representation
of what you want the output to be,
and then it will understand how
to handle that under the covers.
>> Okay. Let me ask you one thing about that.
>> Yeah.
>> So, I see there's a models file that's in there.
So, is this framework somewhat convention based?
So, do I have to put all my models in that models file?
>> Oh, no. You could put this in any file that you want.
The main thing is that it's under a name,
space giraffefun.models and so where it's actually used,
you'll notice that we're
opening the giraffefun.models namespace.
So, that's where there's
this slight response and we have
these little brackets right here,
that's creating one of these models,
an instance of it called response,
and then it's taking that text there.
So, what I want to do very briefly is just walk through.
There's a bunch of stuff right
here that you can just kind of ignore.
I mean, when you build a real Giraffe App,
you'll have to learn this, but this is
just wiring up to ASP.NET Core.
It's actually doing stuff very
similar to how ASP.NET NBC does it.
It's just, I mean it's basically just,
the goal of it is to take an error handler, in this case,
if there's an actual exception that's thrown
and give it 500.
Then, this thing that they call Web App which is where
your actual Web API routes are going to live.
Another thing that I want to call out
here, so this is pretty fun.
Notice how I click this tab.
This is the "I Not" tab.
I'm actually using a plugin here called I Not F#.
This is the official F# plugin
for the Little Studio Code.
It turns it into a full fledged IDE.
See, there's this handlegethello function right there.
I'm going to say, "Command" and then click and
it will go to definition right in there.
There's all sorts of
really cool pieces of functionality this has.
I really recommend people who are doing
stuff with VS code on a Mac or anywhere really,
definitely check this out.
It's a really great alternative to Visual Studio.
>> Is that particular just for web developer
with F# or just F# development in general?
>> This for anything. I personally use both.
So, I use this in Little Studio.
My main solution, well,
it's the F# solution itself.
It's a really big one. That one's in Visual Studio.
But, anything that's sort of lightweight stuff,
I always do it in VS code first,
and I do all of my F# scripting in VS code.
So, F# has a scripting mode where you
can create F# script files and then you can
execute them in a thing called F#
interactive which is
just an interactive rappel basically.
So, I prefer VS code for scripting,
just because scripting is more of a lightweight sort of
thing and I like having a lightweight editor for that.
>> Sure. That makes sense.
>> Yeah. I reckon
even if you're a heavy Visual Studio user,
you should definitely check this out, and use both.
You may find that you like one for a particular task.
So, I recommend people definitely do that.
Let's explain a little bit about what this
is doing because this is
very different especially if you're familiar
with C# in [inaudible].
So, we have a function, it's called WebApp,
and WebApp signature is given in HttpFunc,
which is an abstraction that lives inside of the
actual, the library itself,
and given in ASP.NET Core.HTTP.HTTPContext which is
an ASP.NET Core abstraction produced in HttpFunc result.
So, it's important to know the signature,
but in terms of how you
actually write code that does this,
like new API, that sort of stuff,
you don't really have to understand all of this,
but it's definitely worth
understanding that there's a particular signature here,
because that's how you actually plug into things.
So, it's a thing called webApp,
and webApp is comprised of a function called Choose,
and Choose is comprised of well,
in this case it's just an F# list.
This whole thing right here is actually a list,
and it's a list of two items.
One is called a subRoute,
and subRoute takes in
"/api" or whatever you want to call it.
You can define routes underneath it,
and then at the very bottom it takes
a thing called setStatusCode.
setStatusCode is a function, you say okay,
it's going to be 404, and then
remember how I mentioned those arrows?
Is the Kleisli arrow, and is basically saying, "Okay,
put the setStatusCode 404" basically say,
''I want to compose this with
a function that is called
text,'' and text will take a thing saying,
''Not found" so that when there is
the equivalent of a 404 that would
happen in ASP.NET Core,
it'll just say, ''Not Found,'' as its response.
>> So, that's a quick little helper in that,
that will return just the text but it will set
the headers and the status codes and whatever else I
need to have set just
using that little function, that's it.
>> Exactly. If you wanted to have it be more than just,
"Not Found", you could actually plug
in your own function right here.
Because text itself is
just the thing that takes a string.
It takes in a thing called "Next" which is
an HttpFunc and it produces
HTTP context objects and it produces HttpFunc result.
So, it takes a whole bunch of stuff.
Basically this text has a particular signature.
If you write a different function
that has that same signature,
you can plug that function into here and then you
can have a custom 404 handler.
>> Great.
>> But so, that model of there's a particular signature,
I'm going to create a function that has
that same signature and do something else with it.
That's how you implement functionality with Giraffe.
So, we'll notice that inside of the sub routes,
sub route itself has
a whole bunch of like this is
nested choose is going on right here.
There's a choose and then
this choose is comprised of this thing called Get.
Choose is basically a way of saying,
well an incoming request is
going to have a particular shape to it.
It's /API/Hello.
This is basically the wave in coding.
If you find that route called hello, call this handler.
If you don't find it,
maybe it was something else,
maybe there was a different get,
maybe you defined your own routes called Hello
XML and you wanted to call HandleGetHelloButXML.
This doesn't exist right now but like maybe
that was the actual slash.
Well, this basically walk through
the choose the list and say okay, does it match this?
No. Does it match this?
Yes. Okay. If it doesn't find it,
then it just falls out to the next scope.
>> Got you.
>> Then, once it can't find anything, it will go,
"Hey 404 not found,
you gave me something I didn't understand."
That's the flow with this thing.
So, it's a little bit of alien syntax
but as you start to write it it makes so much sense.
So, I have this HandleGetHelloButXML.
So, if we go to handle get hello,
we look at where that's defined.
That's defined in HttpHandlers.fs.
So, that's just a function right there.
Well, let's create another function in here instead
of a module called HTTP handlers.
So, that right there.
Interesting that they went with this decision
to go with a Lambda expression to define it.
You don't actually have to do that.
So, we'll go HttpFunc that will
define that as one of the input parameters and then
the other one will be a context.
So, that will be a HTTP context.
Okay. So, this is going to be our function here,
and we're going to make it a task.
This is actually a TPL task because under
the covers HTPP.NET Core works with
async await and tasks and all that stuff,
this is just a nice syntax for being able to define that.
So, we'll go response
and we'll define a new one of these,
you can define it however you want.
I'm going to use
a slightly different syntax than what we had there.
We want it to be a text because if we
look at the shape of response under models,
this right here it's a message just has text right there.
So, we'll do that, we'll go text equals,
"Hello world, from Giraffe, but in XML."
Okay. Now, we basically want to return out of this task.
So, basically this is a feature
called computation expressions in F#.
You can model a lot of complex stuff
but I won't really be getting into that.
It's fundamentally a nice syntax for being able
to write code that executes in a particular context.
>> Got it.
>> Not just the necessarily the main executing thread.
So, this is a task based context.
So, I need to do return to get out of
that context or this thing called
Return bang and that just depends on the signature.
If I do return, that means I have a value,
that is a form task.
It actually has the task type,
I just need to return that out.
But if I will have another value that I want to pass into
another function that will then produce
a task that I then want to have return out,
Then I can just do return bang.
So, you notice this is using return bang at the bottom.
That's because JSON itself actually returns
the thing that I need.
>> That's like almost F#s way of
handling continuations a little bit?
>> Yes, this is very similar to that. Yes.
>> Okay.
>> So, instead of using the JSON function,
I'll use the XML function because this is
a helper that Giraffe has there
and will just go XML response next context.
Notice that XML need the thing and
then it needs the next function
which we've already got right here.
Then, it needs the contacts
which we already have or here we
just pass that in, now it compiles.
So, you notice right here,
I don't have the red squiggles anymore,
I can go to definition right there because
this is just awesome editor tooling which is just editor,
what F# is all about in
addition to being a full functional programming language.
So, we'll go .netwatchrun.
Probably I should have done that from the beginning.
So, I could show it executing
both of the modify but whatever.
>> That's fine.
>> Okay, cool. So, this
is going to be an localhost 5,000.
Okay, localhost 5,000.
There we go not found because I didn't specify error.
So, we know the error handler works there.
We'll go API hello
and now I have some JSON which is nice.
"Hello world, from Giraffe".
What do we name this?
We named It "Hello XML?"
Yes "Hello XML." Here we go.
Hello world, from Giraffe but an XML."
>> Nice.
>> So, what's really interesting about this is,
if I wanted to add a new routes,
you just go here, you go route.
>> Specify the route and just add a function.
>> Hey there, yeah. That's what
functional programming is all about.
If you want a new capability,
just add a new function and just compose
that function with whatever the thing is you're building.
So, it's that easy because it's
just a function I can do anything I want in here.
I could execute some business logic,
I could do a complex computation,
I could hit a database, I could
do anything, it doesn't matter.
Because all I need to do is make sure that
it fits this particular signature.
That it's a function that's task-based,
it's got a next function,
it's got to call an issue to be
context and everything inside the body of this.
However I fill out this response doesn't matter.
So, that's why it's so easy to make
web APIs like this because it's super flexible.
>> Right.
>> So, yeah I really
love Giraffe and that flexible model.
How I mentioned Suave came before Giraffe.
This is where it truly borrowed from Suave
because Suave pioneered this not just the syntax.
They didn't just party near the fact that
there's this thing called get this,
Kleisli cognitive, this choose function.
If you write Suave Code, it
looks similar to this as well.
But this entire model of just,
"Hey I have a function" It's a really beautiful object.
>> It's a nice line.
>> Anyway, that's the heart of Giraffe Programming,
and you can do both JSON and XML if you want.
>> That looks pretty good. So, I know
we're running really low on time.
So, one thing I wanted to ask you about,
if I want to get started with using
Giraffe or even just web programming in
general with F# what are some of the places you
think I can go to get some of that information?
>> Absolutely. So, first of all,
if you already have .NET Core installed on your machine,
then you already have
what you need which is which is good.
But search engines have a lot of information.
Like if you just type in F# Giraffe for example,
you'll end up like on a Github page
that have everything you need.
There's the same thing with Saturn,
Suave, Freya, all that stuff.
They all have excellent get started guides.
I recommend everybody check out all of
them not just one particular one just because
each has a particular thing
that they may speak to you personally as a developer.
Yeah, we're also going to be adding
some documentation for this in our official docs.
So, if you just look for the F# docs,
we are going to add that too.
We just finished up a few of the things there.
So, that hasn't made it final yet.
>> Nice, pretty cool. Again, regardless of
whether I'm using Visual Studio or Visual Studio code,
whether I'm on Windows or on Mac or Linux.
>> Yeah.
>> I could still get these templates,
I can run them on my machine and I could
start web development with them to?
>> Yeah, absolutely.
>> Cool, awesome. Hey, thank you so
much for being on the show man, I really appreciate it.
>> Yeah, no problem.
>> We just learned all about creating Web applications
with F# on this episode of the ON.NET show.
For more infomation >> Pete Davidson confirms engagement to Ariana Grande on 'Tonight Show' | American Today – 10... - Duration: 1:28. 
For more infomation >> Volkswagen Tiguan 1.4 TSI | 4motion | navi | clima | 100% dealer - Duration: 1:07. 
For more infomation >> [러시아 월드컵] 이근호, 프랑스vs페루전 단독 해설 도전… 이광용 캐스터와 콤비 - Health tips - Duration: 5:48. 
For more infomation >> Volkswagen up! 1.0 60pk 3-DRS Move Up! | Executive pakket | Climatic - Duration: 1:10. 
For more infomation >> 9 natuurlijke manieren voor het verminderen van rugpijn - Duration: 3:47. 
For more infomation >> [러시아 월드컵] 덴마크vs호주 예상 라인업 공개… "지상파 중계 없어요" 김빠지네 - Health tips - Duration: 3:01. 
For more infomation >> Kia cee'd 1.6 GDI 135PK ComfortPlusLine Nav. - Duration: 1:07. 
For more infomation >> Volkswagen Golf 1.2 TSI Cabrio | clima | cruise | 18 inch | leder - Duration: 1:07. 
For more infomation >> FRAN DRESCHER: "DIE NANNY" KOMMT ZURÜCK! - Duration: 2:46. 
For more infomation >> Как бесплатно набрать просмотры на видео 2018 - Duration: 11:59. 
For more infomation >> 辽宁号等40艘战舰军演 美专家：4架轰炸机就能全摧毁 - Duration: 8:19. 
For more infomation >> 蔡英文發推慰問安倍卻不用中文 但安倍用中文回復 - Duration: 8:35. 
For more infomation >> 南海告急！美军三大航母突然闯入，贸易战特朗普没占上便宜又来挑衅辽宁号了 - Duration: 2:21. 
For more infomation >> 得知《手機2》正常推進中，剛看完《手機》的我竟莫名有些期待 - Duration: 3:56. 
For more infomation >> 晚清最悲壮的英雄，足足被砍了20多刀才断气，死前说16个霸气的字 - Duration: 2:21. 
For more infomation >> 관람객들이 담배 라이터 던져주고 '골초'로 만든 '동물원 침팬지'? - Duration: 4:01. 
For more infomation >> Hydrance Intense Siero Idratante: come idratare la pelle h24*! - Duration: 0:32. 
For more infomation >> 방산(防産)강국 폴란드가 K9 수입한 사연 | korean army 24h - Duration: 14:02. 
For more infomation >> E3 2018 : LES JEUX QUE JE VEUX !!! [ASSASSIN'S CREED ODYSSEY / FALLOUT 76] - Duration: 4:50. 
For more infomation >> EN DIRECT. Danemark - Australie (1-1): l'arbitre siffle la fin de la première période - Duration: 4:20. 
For more infomation >> 진짜 '명품'으로 환골탈태한 K-55 자주포 | korean army 24h - Duration: 13:18. 
For more infomation >> La 'crisis' de doña Letizia y Felipe - Duration: 6:56. 
For more infomation >> Mercedes-Benz CLK-Klasse Cabrio 200 K. Elegance NIEUWE APK! - Duration: 1:08. 
For more infomation >> Salman khan Shahrukh khan and Aamir khan in a school | FactIndia - Duration: 4:37. 
For more infomation >> ✔✔ 남친이 결혼한다는 사실을 SNS 통해 알았습니다" ♥ 뉴스 속보 - Duration: 3:17. 
very nice blogs!!! i have to learning for lot of information for this sites...Sharing for wonderful information.
ReplyDeleteWeb Designing Company in Bangalore | Web Design Company Bangalore