Download - What The F#
What The F#?
A beginners guide to F#ing around with F#
Who started F#ing?
• Functional programming has been around since 1956, starting with Information Processing Language, and popularized with Lisp
• F# started by Microsoft Research in 2005, as an implementation of OCaml
What the F# would I use it for?
• Used for scientific modelling, math, AI research, financial institutions, graphic design, CPU design, compiler programming, telecom engineers, etc.
• Targeted for heavy number crunching, abstract symbolic processing, or theorem proving
• That being said, could totally be used for CRUD, web dev, GUI, games, and general-purpose programming
What F#ing good is it?
• All those cool things in imperative programming, like generics, type inference, list comprehension, and anonymous types?
ALL CAME FROM FUNCTIONAL PROGRAMMING
F#ing Functions, how do they work?
• syntax:
– let function-name parameter parameter = function-body
• let sum x y = x + y
• “sum” is a symbol that points to the function body
• Execution:
– let result = sum 1 2 //result 1 + 2
What the F# is an Immutable Value?
• Every value in F# is immutable – it will not change after being declared
• This allows for values to be passed around without worrying if a function is going to change it– Data can be processed multi-threaded without having
to worry about locks or race conditions
• Functions that return objects actually return entirely new objects cloned from what was passed in
How the F# does it know what type to use?
• Type Inference!
• let increment x = x + 1
– you’re adding ints and returning an int
• let add x y = x + y
– you’re adding two values of the same type and returning that type
F#ing Function Signatures
• let increment x = x + 1
• increment’s type is “int -> int”
– We take an int, and return an int
• let sum x y = x + y
• sum‘s type is “int -> int -> int”
– We take two ints, and return an int
• Functions always return one value
I’m about to blow your F#ing mind
• let sum x y = x + y
• int -> int -> int
• … is actually …
• int -> (int -> int) :-o
• EVERY FUNCTION ALWAYS TAKES ONE PARAMTER AND RETURNS ONE VALUE!
Hold on to your F#ing seat
• let sum x y = x + y
– int -> (int -> int)
• Calling “sum 5” RETURNS A FUNCTION
– of type “int -> int”
• let half-function = sum 5
• let result = half-function 10
• RESULT EQUALS 15!!!
F# beef stew, this is Currying
• The ability to take larger functions and use specific pieces of them
• let sum x y = x + y
• let increment = sum 1
• Now we can increment whatever the F# we want!
How to F# up an argument
• Because functions are values, they can be passed around like arguments
• let sumResult x y operation =
(operation x) + (operation y)
• let square x = x * x
• let sumOfSquares = sumResult 2 3 square
– sumOfSquares == 13!
F#ing complicated types
• let sumResult x y op = (op x) + (op y)
• Type: int -> int -> (int -> int) -> int
• But really…
– int -> (int -> ((int -> int) -> int))
• let alwaysWorkWithOneAndTwo =
sumResult 1 2
• Type: (int -> int) -> int
Anonymous F#ing
• let sumResult x y operation =
(operation x) + (operation y)
• let sumOfDoubles =
sumResult 1 2 (fun x -> x + x)
– sumOfDoubles = 6!