This document discusses using F# for iOS app development with Xamarin. It provides testimonials about increased productivity and performance using F#. Key features of F# discussed include discriminated unions, immutability, pattern matching, and option types. It compares F# to Swift, highlighting advantages of F# like type providers and units of measure. It also outlines reasons for using the cross-platform Xamarin framework for iOS development.

1. T W I T T E R : @ R A C H E L R E E S E
B L O G : R A C H E L R E E . S E
G I T H U B : R A C H E L R E E S E
iOS App Development with
Xamarin and F#

2. Why F#?

3. “
”
Y A N C U I
L E A D S E R V E R E N G I N E E R , G A M E S Y S ( S O U R C E )
F#…offers us an order of magnitude
increase in productivity and allows one
developer to perform the work…of a
team of dedicated developers on an
existing Java-based solution...
F# Testimonials

4. “
”
D A R R E N P L A T T
A M Y R I S B I O T E C H N O L O G Y ( S O U R C E )
The UI work is especially gratifying,
because state of the art for a lot of
genomic data display is still PNG images
embedded in JavaScript and with F# I can
render half a million data points on a web
page without jumping through hoops.
F# Testimonials

5. StartNewGame <| GetNewGameBoard()
F# Fundamentals
|>
Significant whitespace
Immutable by default
//names is tuple of (name, id)
Array.Parallel.partition (fun g -> ids.Contains(snd g)) names
|> fst
|> Array.toList
[1..10]
|> List.filter (fun x -> x % 2 = 0)
|> List.map (fun x -> x + 3)
|> List.sum
operaHouses //(Name, Current Productions) for each opera house
|> Array.map (fun (x,y) -> x, y |> Seq.toArray))
|> Array.filter (fun (x,y) -> y.Length > 0)

6. Quote of the Week blog post
Option Types
F# Fundamentals

7. F# C#
type Transport =
| Car of Make:string * Model:string
| Bus of Route:int
| Bicycle
public abstract class Transport{ }
public abstract class Car : Transport {
public string Make { get; private set; }
public string Model { get; private set; }
public Car (string make, string model) {
this.Make = make;
this.Model = model;
}
}
public abstract class Bus : Transport {
public int Route { get; private set; }
public Bus (int route) {
this.Route = route;
}
}
public class Bicycle: Transport { }
...
F# Fundamentals: Concise Code with DUs

8. F# Fundamentals: Pattern Matching
type Transport =
| Car of Make:string * Model:string
| Bus of Route:int
| Bicycle
let getThereVia (transport:Transport) =
match transport with
| Car (make,model) -> ()
| Bus route -> ()

9. Several reasons why you should learn F#
Discriminated unions
Immutable by default
Pattern matching
Option type
Custom operators
REPL

10. F# vs. Swift
‘Enums’Discriminated unions
Constant or VariableImmutable by default
Enhanced switchPattern matching
OptionalsOption type
Custom operatorsCustom operators
REPLREPL

11. No type providers
Lacks full type
inference
No units of
measure
Requires “return”
Still void, no unit
No parallelism &
async!
Single platform Young language
No easy cloning
syntax for
structures (e.g.
records)
Literal data
structures are only
list and dict
Simpler garbage
collection process
Active Patterns
But Swift is still missing out

12. TYPE PROVIDERS!
UNITS OF MEASURE!
Why F#?

13. Some existing
type providers.
See here for a full list.
Minesweeper Azure
Choose your
own
adventure
Matla
b RSS
XAML Rock, Paper,
Scissors Oracle MVVMCross SignalR
FunScript
R File System Python Regex
CSV World Bank SQLite Don Syme XML
Squirrels LINQ
IKV
M
MS
Dynamics
CRM
Freebase
JSON SQL Server
SQL Server
with EF
powershell Dates
Hadoo
p
OData WSDL Apiary Facebook

14. Get data
from
Hadoop
SQL Server
SQLite
RSS
Freebase
Oracle
CSV
OData
World Bank
JSON
Process
with
Matlab
Powershell
Regex
R
SignalR
Python
LINQ
Visualize
with
F#
Matlab
R
Get creative.

15. Why Xamarin?
Fully
Native
Cross
Platform

16. iOS Fundamentals: AppDelegate

17. iOS Fundamentals: ViewController

18. Minesweeper

19. T W I T T E R : @ R A C H E L R E E S E
B L O G : R A C H E L R E E . S E
G I T H U B : R A C H E L R E E S E
iOS App Development with
Xamarin and F#