The HTTP protocol adheres to the functional programming paradigm. This talk looks at HTTP on .NET and illustrates how F# allows for a more direct correlation to the patterns of composition inherent in the design of HTTP.

1. The Functional Web

2. Ryan Riley
O Logos Bible Software
O Community for F#
O F# MVP
O OSS: FSharpx, Fracture, Frank
O @panesofglass

3. Outline
O The State of HTTP on .NET
O Composition Patterns in HTTP
O Identifying Problems
O Examining a Solution

4. The State of HTTP on .NET

5. Current Options
O http.sys
O HttpListener
O IIS (IHttpModule & IHttpHandler)
O Web Forms
O MVC
O WCF HTTP & Data Services

6. Future Options
O System.Net.Http (BETA)
O .NET 4.5
O Available on NuGet
O ASP.NET Web API (BETA)
O Builds on System.Net.Http
O Integrated with MVC 4

7. OSS Options
Frameworks Servers
O FubuMVC O Firefly (OWIN)
O MonoRail O Fracture (F#)
O NancyFx
O Kayak (OWIN)
O OpenRasta
O Manos de Mono
O OWIN/Gate
O ServiceStack.NET O Mono XSP
O WebSharper
O … and many more!

8. Composition Patterns in
HTTP

9. Component Parts
O Request/Response Lines
O Methods, URIs, Status Codes
O Headers
O General, Request, Response, Content
O Resources
O Representations
O Hypermedia

10. Simplest HTTP Application
HttpRequestMessage -> HttpResponseMessage

11. Resources
GET /item/1
+ POST /item/1
+ PUT /item/1
+ OPTIONS /item/1
=
Resource at / with GET, POST, PUT, &
OPTIONS

12. HTTP Applications
/
+ /items
+ /item/{itemId}
+ /help
=
Typical HTTP “application”

13. Content Negotiation
Client Accepts Server Supports
application/xml;q=0.9 application/json
application/json;q=0.8 text/plain
text/plain;q=0.5 text/html
application/json

14. Identifying Problems

15. HttpListener
O Low-level
O Defines the signature for a single application only
O HttpListenerContext provides a singleton; no
chance to intercept and chain behavior
O Routing requests requires custom handling;
typically by using imperative if-then-else
O No means of chaining or composing multiple
listeners

16. HttpListener
HttpListener.Start
("http://localhost:8082/", (fun (request, response) -> async {
match request.Url.LocalPath with
| "/post" ->
// Send message to the chat room
room.SendMessage(request.InputString)
response.Reply("OK")
| "/chat" ->
// Get messages from the chat room (asynchronously!)
let! text = room.AsyncGetContent()
response.Reply(text)
| s ->
// Handle an ordinary file request
let file =
root + (if s = "/" then "chat.html" else s.ToLower())
if File.Exists(file) then
let typ = contentTypes.[Path.GetExtension(file)]
response.Reply(typ, File.ReadAllBytes(file))
else
response.Reply(sprintf "File not found: %s" file) }),
cts.Token)

17. IHttpModule & IHttpHandler
O Low-level
O HttpContext has the same problems as
HttpListenerContext
O IHttpHandler could represent a Resource, but
method mapping is imperative
O IHttpModule provides a middleware layer for
routing or hosting multiple IHttpHandlers
O System.Web.Routing surfaces the routing
component

18. IHttpModule & IHttpHandler
interface IHttpModule
{
void Dispose();
void Init(HttpApplication context);
}
interface IHttpHandler
{
bool IsReusable { get; }
void ProcessRequest(HttpContext context);
}

19. ASP.NET Web Forms
O HTML composition via
MasterPages, Pages, and Controls
O Suffers many problems associated with
IHttpModule and IHttpHandler
O Evented model allows for interception
O No built-in support for other representations
O Pages loosely correlate to Resources
O Application composition and routing by file
path

20. ASP.NET MVC
O Suffers many problems associated with
IHttpModule and IHttpHandler
O Primarily HTML generation but allows for better
HTTP control
O Built-in support for handling Ajax requests
O ActionFilters allow for behavior composition at
different points:
Authorize, ActionExecuting, ActionExecuted, Resul
tExecuting, ResultExecuted

21. ASP.NET MVC, cont.
O Content Negotiation is still very manual
O ViewEngines and Serializers can be made to
render various representations
O ViewEngines offer representation composition
O Controllers ~ Resources, but not quite
O Areas and Routing allow for Nested
Resources, to a degree

22. Problem Summary
O Have:
O Limited interception for cross-cutting
concerns
O Representation composition
O Do not have:
O No easy resource composition
O No built-in content negotiation

23. Composition for Conneg
O Rendering
O Imperative if-then-else
O Serializers
O Location
O Within the specific method handler (common for
imperative)
O Top-level (common for serializers)
O Why not both?

24. Nested Resources
O Imperative if-then-else
O Routing
O MVC Areas offer another level
O What about more than one level?
O Rails – problem with deep URIs
O System.Web.Routing does everything at the
top-level, so tracking deeper resource trees is
difficult.

25. Examining a Solution

26. Function Composition
O Functional programming offers solutions
to these problems
O Filter
O Map
O Reduce

27. Frank
O F# DSL using System.Net.Http
O Headers composition
O Follows the natural composition of HTTP
O Frank Resources == HTTP Resources
O Define your own conventions!

28. Simplest HTTP Frank
Application
HttpRequestMessage -> HttpResponseMessage
HttpRequestMessage -> Async<HttpResponseMessage>

29. Define a Method Handler
// handler
let echo request = async {
let! body = request.Content.AsyncReadAsString()
return HttpResponseMessage.ReplyTo(request, body)
}
// method handler
get echo

30. Define a Resource
let helloworld request = async { … }
let echo request = async { … }
let resource = route “/” (get helloworld <|> post echo)

31. Define an Application
let todoListResource = route “/” (get todoList <|> …)
let todoItemResource = route “/item/{1}” (put …)
let app = merge [ todoListResource; todoItemResource ]

32. Leverage Conneg
val negotiateMediaType = formatters ->
HttpRequestMessage ->
string ->
Async<HttpResponseMessage>
let echo = negotiateMediaType formatters
<| fun request ->
request.Content.AsyncReadAsString())

33. WebSharper
O One language for both client and server
O Can leverage to cleanly separate parts
O Use WebSharper to generate code-on-
demand to send to the client
O Plays well with existing tools

34. Summary

35. Resources
O ASP.NET Web Forms in F#
O ASP.NET MVC in F#
O Figment DSL for MVC
O Frank DSL for Web API
O WebSharper
O Pit FW

36. Thank you!
O Please rate this talk:
http://speakerrate.com/talks/9293-the-
functional-web