f# for functional enthusiasts

F# for Functional Enthusiasts

Jack Foxjackfoxy.com craftyThoughts

@foxyjackfox

Bibliographyjackfoxy.com/Fsharp_functional_enthusiasts_bibliography

Sample Codehttps://gist.github.com/jackfoxy/6679238

https://github.com/jackfoxy/CrockSolution

https://github.com/jackfoxy/TestSandbox

2012 annular eclipse observed by the author from Sugarloaf Peak, Lake Shasta

Type ProvidersMicrosoft.FSharp.Data.TypeProviders

DbmlFileEdmxFileODataServiceSqlDataConnectionSqlEntityConnectionWsdlService

FsharpxAppSettingsExcelGraphMachineManagementMathRegexXamlXrm

FSharp.DataApiaryCsvFreebaseJsonWorldBankXml

F# 3.0 Sample PackDGMLWordCsvDataStoreHadoop/Hive/HdfsHelloWorldManagementMiniCvsXrm

TsunamiRSS ReaderStart MenuNuGetTypeProvider *

S3TypeProvider *

FacebookTypeProvider *

DocumentTypeProvider *

* (samples inside Tsunami)

in the wild on GithubFunScriptRMatlabIKVM (Java)PythonPowerShell

strongly typed ≠ object oriented

Typed Clojure project on indiegogo.com

Parameterized Polymorphisma.k.a. Generics

let inline unsigned bitSize (zero : 'a) (one : 'a) =

let one' = one + zero let x' = one <<< (bitSize - 1) x' ||| one'

bitSize:int -> zero: ^a -> one: ^a -> ^a when ^a : (static member ( + ) : ^a * ^a -> ^a) and ^a : (static member ( <<< ) : ^a * int32 -> ^a) and ^a : (static member ( ||| ) : ^a * ^a -> ^a)

// Base Type Constraint

type Class1<'T when 'T :> System.Exception> …

// Interface Type Constraint

type Class2<'T when 'T :> System.IComparable> …

// Comparison constraint

type Class10<'T when 'T : comparison> …

// Member constraint with property

type Class6<'T when 'T : (member Property1 : int)> …

Constraints on Type Definitions

[<Measure>] type m // Distance, meters.

[<Measure>] type mile // Distance, miles.

[<Measure>] type s // Time, seconds.

[<Measure>] type h // Time, hours.

let distance1 = 100.0<m>let distance2 = 250.0<mile>

let speedMetersPerSec = distance1 / 10.0<s> // float<m/s>

let speedMPH = distance2 / 5.0<h> // float<mile/h>

let x = distance1 + distance2 //will not compile

Units of MeasureDesign Time Type Checking

So far…Type Providers: strongly typed external data

Strong typing and type inference 

Type constraints

Units of Measure

Next up…Nuts and bolts programming

Vector

Eager Rose Tree

Vector

54321

Construct Deconstruct

Initial

Last

[ ]

empty

;;

type JsonValue = | String of string | Number of decimal | Float of float | Object of Map<string, JsonValue> | Array of JsonValue[] | Boolean of bool | Null

JSON Parsing

Discriminated Union Type from FSharp.Data

JSON Parsing

Demo Crock Solution

FSI (REPL) compiles to assembly and executes

F# scripts

Fseye

Triple quoting

Red Black Tree Balancing

Source: https://wiki.rice.edu/confluence/download/attachments/2761212/Okasaki-Red-Black.pdf

a b

c

db ca d

a

a

b c

d

b c

d

a

c

b

d

Talk about reducing complexity!

type 'a t = Node of color * 'a * 'a t * 'a t | Leaf

let balance = function | Black, z, Node (Red, y, Node (Red, x, a, b), c), d | Black, z, Node (Red, x, a, Node (Red, y, b, c)), d | Black, x, a, Node (Red, z, Node (Red, y, b, c), d) | Black, x, a, Node (Red, y, b, Node (Red, z, c, d)) ->

Node (Red, y, Node (Black, x, a, b), Node (Black, z, c, d))

| x -> Node x Source: http://fsharpnews.blogspot.com/2010/07/f-vs-mathematica-red-black-trees.html

Computational ExpressionsOne syntactic sugar to rule them all

( monad, monoid, applicative functor )

seq {for n in 1..10 do yield n yield n * 2} seq {for n in 1..10 do yield (n, n * 2)}

Sequence Generators

Computational ExpressionsRecursive Generators

let rec listFiles dir = seq { yield! Directory.GetFiles(dir)

for subdir in Directory.GetDirectories(dir) do

yield! listFiles subdir } let musicFiles = listFiles "E:\music" |> List.ofSeq

Computational ExpressionsQuery Expressions

let htmlPage = query { for content in db.tbContentLib do

where (content.companyID.Value > 0 and content.isHtml) join template in db.tbTemplate on (content.templateID.Value = template.templateID) select (content.styleID, template.title, template.body) }

Computational ExpressionsQuery Expressions (Freebase)

let topBooksWithNameContaining (s:string) =

query { for book in data.``Arts and Entertainment``.Books.Books do

where (book.Name.ApproximatelyMatches s)

take 10

select book.Name }

Asynclet someBinding =

async {let! x = … // asynchronous binding

let y = … // synchronous binding

let! z = … // another asynchronous binding

do! … // asynchronous execution

return z // return something (or not)}

Agentsa.k.a. Mailbox Processor

Message passing

Actor Model

Erlang-like processing

{m}braceCloud Computing (beta)

[<Cloud>]let calculatePi (iterations : bigint) (digits : int) : ICloud<string> = cloud { let! workers = Cloud.GetWorkerCount() let workers = bigint (2 * workers)...

let runWorker iterations = cloud { return monteCarloPiWorker iterations } let! results = ... |> Cloud.Parallel...

return getDigits a b |> ... }

Quotations

let ``Vector<Vector<'T>>, windowSeq``() =

test<@ [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10;] =

([0; 1; 2; 3; 4; 5; 6; 7; 8; 9; ] |> Vector.windowSeq 3 |> Vector.flatten |> List.ofSeq) @>

Now we’ve seen…ML-style pattern matching

Syntactic sugar over common FP abstractions

Async and friends

Quotations

Next: Community-Driven DevelopmentFsharp.org

Some “core” projects

Dev environments

Fsharp.orgF# Foundation

Owns resources relating to F# including:

the domain fsharp.org

the github.com/fsharp community organization

the fsharporg twitter account

Seeks to:

promote the adoption of F#

expand the relevance and importance of F# skills and knowledge

expand the range of technologies which can interoperate with F#

expand the range of platforms where F# can be used

facilitate the ongoing development of F#-related technology and resources

FAKE

DSL implementation of build automation system

Full use of F# language

Access to any and all libraries

Develop with powerful debuggers and IDEs

Literate Programming

FSharp.Formatting

Funscript

Javascript and Single Page Apps

JQuery and Javascript DOM APIs

TypeScript TypeProvider

Mini Web Server

Websharper

Fully composeable client-server web development.

#websharper on irc.freenode.net

GPU ProcessAlea.cuBase

Complete commercial solution to develop highly optimized CUDA accelerated GPU applications from F# quotations by QuantAlea.

Advantages of functional composition and rapid prototyping

Don’t have a NVIDIA card?

Try Brahma.Fsharp F# quotations to OpenCL translation

Testing Options

FsUnit – native F# functional syntax across test tools

FsCheck – QuickCheck for F#

TickSpec – lightweight, but fully featured Gherkin BDD

Canopy – lightweight F# syntax for web-client Selenium testing

Unquote – step-by-step F# expression evaluations

Development AlternativesTsunami IDE (beta)

Visual Studio 2010, 2012, 2013 (free Express edition)

Xamarin Studio -- iOS, Android, Mac, Mono, .NET(free edition limits project size)

Emacs

Vim

SublimeText

IKVM lets Java and .NET Get Along!

Java from .NET, .NET from Java

JVM bytecode IL instruction native JIT(not a bunch of wrappers) 

10+ years of development effort

Actively supported

Powers Mono

Extremely few edge incompatibilities

Questions?

F# Programminghttp://en.wikibooks.org/wiki/F_Sharp_Programming

A Course of F# Studyhttp://jackfoxy.com/a-course-of-fsharp-study

A directory of useful pageshttp://fsharpforfunandprofit.com/site-contents

Learning F#