SlideShare a Scribd company logo
embrace the paradigm
REASONABLE CODE WITH F#
ABOUT ME
SECTION: OVERVIEW
Help the human
SYNTAX
int euler1(int max) {
var total = 0;
for(var n=1; n<max; n++) {
if(n % 3 == 0 || n % 5 == 0){
total += n;
}
}
return total;
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#
SYNTAX – VS LINQ
int euler1(int max) {
return Enumerable.Range(1, max - 1)
.Where(n => n % 3 == 0 || n % 5 == 0)
.Sum();
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#
TYPE INFERENCE
int x = 3;
long y = 4;
var z = x + y; // = 7
C# let x = 3
let y:int64 = 4L
x + y
F#
The type 'int64' does not
match the type 'int'
AUTOMATIC GENERALIZATION
val firstInGroup :
g:('a -> 'b) -> list:seq<'a> -> seq<'b * 'a> when 'b : equality
public IEnumerable<Tuple<U,T>> firstInGroup<T,U>
(Func<T,U> g, IEnumerable<T> list) {
return list.GroupBy(g)
.Select(grp => new Tuple<U, T>(grp.Key, grp.First()));
}
C#
let firstInGroup g list =
list
|> Seq.groupBy g
|> Seq.map (fun (key,items) -> key, Seq.head items)
F#
GENERALIZE THIS!
int add<T>(T x, T y) where T: op_addition {
return x + y;
}
C#
let add x y = x + y
add 3 4
add 4.2 5.1
F# let inline add x y = x + y
add 3 4
add 4.2 5.1
add "hello" "World"
F#
IMMUTABILITY
Eliminate unintended side effects
Sets you up for multi-core programming
Debugging is easier
Testability is higher
Intended side effects are necessary
Performance
IMMUTABILITY - EXAMPLE
Example from “Inside F#” blog
let actions = List.init 5 (fun i -> fun() -> i*2)
for act in actions do
printf "%d " (act())
F#
List<Func<int>> actions = new List<Func<int>>();
for (int i = 0; i < 5; ++i) {
actions.Add( () => i * 2 );
}
foreach (var act in actions) {
Console.WriteLine( act() );
}
C#
The mutable variable 'i' is used in an invalid way.
Mutable variables cannot be captured by closures.
Consider eliminating this use of mutation or using a
heap-allocated mutable reference cell via 'ref' and '!'.
OVERVIEW
1.Human readable
2.Reusability
3.Sensible defaults
FUNCTIONS AND FUNCTIONAL TYPES
Which problem would you rather focus on?
a) Where the code should live
b) What the code should do
COMPOSITION VS INHERITANCE
Is-a relationship that extends the base class
Very high coupling
Subclasses may not need all functionality from base class
Subclass has to be aware of the base class’s implementation
Ninject StructureMap
Castle WindsorUnity
Interface-dependent
FUNCTION COMPOSITION
Pipeline Operator: |>
Return value of first function becomes the last parameter of second function
Forward Composition Operator: >>
Create new functions that are sequences of existing functions
webUrl
|> downloadPage |> extractMetaInfo |> categorizeResource
F#
let categorizeUrl =
downloadPage >> extractMetaInfo >> categorizeResource
let categorizeEmail =
parseEmail >> extractDetail >> categorizeResource
categorizeUrl webUrl
categorizeEmail email
F#
FUNCTION COMPOSITION
Partial Application
Create new functions by supplying some of the arguments to an existing function
let MSBuild properties (outputPath:string) (targets:string) =
//Do some msbuild stuff
let MSBuildDebug = MSBuild ["Configuration","Debug"]
let MSBuildRelease = MSBuild ["Configuration","Release"]
F#
* From FAKE
PATTERN MATCHING
let data = ("Cleveland", 390000)
let city, population = data
F#
let x = 9
match x with
| num when num < 10 -> printfn "Less than ten"
| _ -> printfn "Greater than or equal to ten"
F#
DISCRIMINATED UNIONS
type Shape =
| Square of int
| Rectangle of float*float
| Circle of float
F#
let getArea shape =
match shape with
| Square side -> float(side * side)
| Rectangle(w,h) -> w * h
| Circle r -> System.Math.PI * r * r
F#
let sq = Square 7
let rect = Rectangle 2.2 3.3
let cir = Circle 3.4
F#
OPTION TYPE
type Option<‘T> =
| None
| Some of ‘T
F#
OBJECT MODELING
* From F# Deep Dives
type MarkdownDocument = list<MarkdownBlock>
and MarkdownBlock =
| Heading of int * MarkdownSpans
| Paragraph of MarkdownSpans
| CodeBlock of list<string>
and MarkdownSpans = list<MarkdownSpan>
and MarkdownSpan =
| Literal of string
| InlineCode of string
| Strong of MarkdownSpans
| Emphasis of MarkdownSpans
| Hyperlink of MarkdownSpans * string
F#
FUNCTIONS AND FUNCTIONAL TYPES
1.Think small, build big
2.Model
3.Flow
COMPILER CHECKED CORRECTNESS
Step 1: Create types
Step 2: Lean on the compiler
UNITS OF MEASURE
unitsOfMeasure.fsx(11,19): error FS0001: Type mismatch. Expecting a
int<mi> []
but given a
int<km> []
The unit of measure 'mi' does not match the unit of measure 'km'
[<Measure>]
type mi
[<Measure>]
type km
// define some values
let mike = [| 6<mi>; 9<mi>; 5<mi>; 18<mi> |]
let chris = [| 3<km>; 5<km>; 2<km>; 8<km> |]
let totalDistance = (Array.append mike chris) |> Array.sum
F#
UNITS OF MEASURE
enum DistanceUnit {
Miles,
Kilometers
}
class Run {
private float distance;
private DistanceUnit unit;
public Run(float distance, DistanceUnit unit){
this.distance = distance;
this.unit = unit;
}
}
C#
EXHAUSTIVE PATTERN MATCHING
//Model
module Person =
type T = Person of string
let create name =
if String.IsNullOrWhiteSpace(name) then None
else Some(Person name)
let value (Person p) = p
//DAL
let save person =
//put the person in the database…
Some 42
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| None -> printfn "An error occurred"
| Some id -> printfn "The id for %s is %d" (Person.value p) id
F#
EXHAUSTIVE PATTERN MATCHING
//DAL
type DatabaseResult<'a> =
| Success of 'a
| UniqueViolation
| GeneralException of Exception
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| Success(id) ->
printfn "The id for %s is %d" (Person.value p) id
| UniqueViolation ->
printfn "The name %s already exists" (Person.value p)
| GeneralException(ex) ->
printfn "%s" ex.Message
F#
DATABASE ACCESS, TOO?
Amount of code added to project
COMPILER CHECKED CORRECTNESS
1.Focus on the problem
2.Don’t forget stuff
SUMMARY
To Reason: To make sense of
Syntax & Idioms
Functional composition
Compiler-checked correctness
NOW WHAT?

More Related Content

What's hot (20)

PPTX
Rx workshop
Ryan Riley
 
PDF
Pipeline oriented programming
Scott Wlaschin
 
PDF
仕事で使うF#
bleis tift
 
PPTX
F# Presentation
mrkurt
 
PDF
Time for Functions
simontcousins
 
PDF
Chapter 1 Basic Programming (Python Programming Lecture)
IoT Code Lab
 
PPTX
Advance python programming
Jagdish Chavan
 
PDF
CS4200 2019 | Lecture 2 | syntax-definition
Eelco Visser
 
PDF
Python-02| Input, Output & Import
Mohd Sajjad
 
ODP
Python quickstart for programmers: Python Kung Fu
climatewarrior
 
PDF
46630497 fun-pointer-1
AmIt Prasad
 
PPTX
Sharper tools with F#
Kevin Avignon
 
PDF
Chapter 2 Decision Making (Python Programming Lecture)
IoT Code Lab
 
PDF
Game of Life - Polyglot FP - Haskell - Scala - Unison - Part 3
Philip Schwarz
 
PPTX
Introduction to C++
Sikder Tahsin Al-Amin
 
PDF
Railway Oriented Programming
Scott Wlaschin
 
PDF
Game of Life - Polyglot FP - Haskell, Scala, Unison - Part 2 - with minor cor...
Philip Schwarz
 
PPTX
Python Programming Essentials - M16 - Control Flow Statements and Loops
P3 InfoTech Solutions Pvt. Ltd.
 
PPTX
Python Programming Essentials - M17 - Functions
P3 InfoTech Solutions Pvt. Ltd.
 
PDF
Python unit 2 as per Anna university syllabus
DhivyaSubramaniyam
 
Rx workshop
Ryan Riley
 
Pipeline oriented programming
Scott Wlaschin
 
仕事で使うF#
bleis tift
 
F# Presentation
mrkurt
 
Time for Functions
simontcousins
 
Chapter 1 Basic Programming (Python Programming Lecture)
IoT Code Lab
 
Advance python programming
Jagdish Chavan
 
CS4200 2019 | Lecture 2 | syntax-definition
Eelco Visser
 
Python-02| Input, Output & Import
Mohd Sajjad
 
Python quickstart for programmers: Python Kung Fu
climatewarrior
 
46630497 fun-pointer-1
AmIt Prasad
 
Sharper tools with F#
Kevin Avignon
 
Chapter 2 Decision Making (Python Programming Lecture)
IoT Code Lab
 
Game of Life - Polyglot FP - Haskell - Scala - Unison - Part 3
Philip Schwarz
 
Introduction to C++
Sikder Tahsin Al-Amin
 
Railway Oriented Programming
Scott Wlaschin
 
Game of Life - Polyglot FP - Haskell, Scala, Unison - Part 2 - with minor cor...
Philip Schwarz
 
Python Programming Essentials - M16 - Control Flow Statements and Loops
P3 InfoTech Solutions Pvt. Ltd.
 
Python Programming Essentials - M17 - Functions
P3 InfoTech Solutions Pvt. Ltd.
 
Python unit 2 as per Anna university syllabus
DhivyaSubramaniyam
 

Viewers also liked (7)

PPTX
Don't Do Agile, Be Agile
Michael Falanga
 
PPTX
نشاط هرمي
guest9b857e
 
PPTX
第62回 イノベーションのジレンマ②「市場調査やアンケート調査 」vs「行動観察」
Mitsuhiro Shimada
 
PPTX
Software as a Service
Michael Falanga
 
PPTX
第72回 レッドブル翼をさずける② 完結編 単なるスポーツマーケティングではない
Mitsuhiro Shimada
 
DOC
Yellowstone national park
samantha25
 
PPTX
第75回 スポーツマーケティング③スポーツマーケティングの構造&amp;テレビとスポーツ
Mitsuhiro Shimada
 
Don't Do Agile, Be Agile
Michael Falanga
 
نشاط هرمي
guest9b857e
 
第62回 イノベーションのジレンマ②「市場調査やアンケート調査 」vs「行動観察」
Mitsuhiro Shimada
 
Software as a Service
Michael Falanga
 
第72回 レッドブル翼をさずける② 完結編 単なるスポーツマーケティングではない
Mitsuhiro Shimada
 
Yellowstone national park
samantha25
 
第75回 スポーツマーケティング③スポーツマーケティングの構造&amp;テレビとスポーツ
Mitsuhiro Shimada
 
Ad

Similar to Reasonable Code With Fsharp (20)

PDF
Functional programming with F#
Remik Koczapski
 
PPTX
Functional programming with FSharp
Daniele Pozzobon
 
PPTX
FP Day 2011 - Turning to the Functional Side (using C# & F#)
Phillip Trelford
 
PDF
F# and Reactive Programming for iOS
Brad Pillow
 
PPTX
F# Presentation for SmartDevs, Hereford
Kit Eason
 
PPTX
What The F#
RTigger
 
PPTX
F sharp _vs2010_beta2
Eriawan Kusumawardhono
 
PPTX
Intro to F#
Kristian Hellang
 
PPTX
Introduction to F# for the C# developer
njpst8
 
PPTX
F# Eye For The C# Guy - Seattle 2013
Phillip Trelford
 
PPTX
Real World F# - SDD 2015
Phillip Trelford
 
PPTX
F# intro
Alexey Raga
 
PPT
F# Eye for the C# Guy
gueste3f83d
 
PPTX
TechDaysNL 2015 - F# for C# Developers
Ronald Harmsen
 
PPTX
Intro f# functional_programming
Mauro Ghiani
 
PPTX
Introduction to F# 3.0
Talbott Crowell
 
PPTX
Functional programming f#
DouYutao
 
PPTX
F# Eye 4 the C# Guy
Phillip Trelford
 
PDF
FSharp Talk
HaiBin Chang
 
PPTX
F# for C# devs - NDC Oslo 2015
Phillip Trelford
 
Functional programming with F#
Remik Koczapski
 
Functional programming with FSharp
Daniele Pozzobon
 
FP Day 2011 - Turning to the Functional Side (using C# & F#)
Phillip Trelford
 
F# and Reactive Programming for iOS
Brad Pillow
 
F# Presentation for SmartDevs, Hereford
Kit Eason
 
What The F#
RTigger
 
F sharp _vs2010_beta2
Eriawan Kusumawardhono
 
Intro to F#
Kristian Hellang
 
Introduction to F# for the C# developer
njpst8
 
F# Eye For The C# Guy - Seattle 2013
Phillip Trelford
 
Real World F# - SDD 2015
Phillip Trelford
 
F# intro
Alexey Raga
 
F# Eye for the C# Guy
gueste3f83d
 
TechDaysNL 2015 - F# for C# Developers
Ronald Harmsen
 
Intro f# functional_programming
Mauro Ghiani
 
Introduction to F# 3.0
Talbott Crowell
 
Functional programming f#
DouYutao
 
F# Eye 4 the C# Guy
Phillip Trelford
 
FSharp Talk
HaiBin Chang
 
F# for C# devs - NDC Oslo 2015
Phillip Trelford
 
Ad

Recently uploaded (20)

PDF
AI Agents in the Cloud: The Rise of Agentic Cloud Architecture
Lilly Gracia
 
PDF
UPDF - AI PDF Editor & Converter Key Features
DealFuel
 
PDF
SIZING YOUR AIR CONDITIONER---A PRACTICAL GUIDE.pdf
Muhammad Rizwan Akram
 
PDF
Peak of Data & AI Encore AI-Enhanced Workflows for the Real World
Safe Software
 
DOCX
Python coding for beginners !! Start now!#
Rajni Bhardwaj Grover
 
PPTX
The Project Compass - GDG on Campus MSIT
dscmsitkol
 
PDF
The Rise of AI and IoT in Mobile App Tech.pdf
IMG Global Infotech
 
PDF
Staying Human in a Machine- Accelerated World
Catalin Jora
 
PPTX
From Sci-Fi to Reality: Exploring AI Evolution
Svetlana Meissner
 
PPTX
Future Tech Innovations 2025 – A TechLists Insight
TechLists
 
PDF
Transforming Utility Networks: Large-scale Data Migrations with FME
Safe Software
 
PDF
How do you fast track Agentic automation use cases discovery?
DianaGray10
 
PPTX
Agentforce World Tour Toronto '25 - Supercharge MuleSoft Development with Mod...
Alexandra N. Martinez
 
PPTX
Mastering ODC + Okta Configuration - Chennai OSUG
HathiMaryA
 
PDF
“Voice Interfaces on a Budget: Building Real-time Speech Recognition on Low-c...
Edge AI and Vision Alliance
 
PPTX
Agentforce World Tour Toronto '25 - MCP with MuleSoft
Alexandra N. Martinez
 
PDF
NLJUG Speaker academy 2025 - first session
Bert Jan Schrijver
 
PDF
Go Concurrency Real-World Patterns, Pitfalls, and Playground Battles.pdf
Emily Achieng
 
PDF
[Newgen] NewgenONE Marvin Brochure 1.pdf
darshakparmar
 
PDF
“Squinting Vision Pipelines: Detecting and Correcting Errors in Vision Models...
Edge AI and Vision Alliance
 
AI Agents in the Cloud: The Rise of Agentic Cloud Architecture
Lilly Gracia
 
UPDF - AI PDF Editor & Converter Key Features
DealFuel
 
SIZING YOUR AIR CONDITIONER---A PRACTICAL GUIDE.pdf
Muhammad Rizwan Akram
 
Peak of Data & AI Encore AI-Enhanced Workflows for the Real World
Safe Software
 
Python coding for beginners !! Start now!#
Rajni Bhardwaj Grover
 
The Project Compass - GDG on Campus MSIT
dscmsitkol
 
The Rise of AI and IoT in Mobile App Tech.pdf
IMG Global Infotech
 
Staying Human in a Machine- Accelerated World
Catalin Jora
 
From Sci-Fi to Reality: Exploring AI Evolution
Svetlana Meissner
 
Future Tech Innovations 2025 – A TechLists Insight
TechLists
 
Transforming Utility Networks: Large-scale Data Migrations with FME
Safe Software
 
How do you fast track Agentic automation use cases discovery?
DianaGray10
 
Agentforce World Tour Toronto '25 - Supercharge MuleSoft Development with Mod...
Alexandra N. Martinez
 
Mastering ODC + Okta Configuration - Chennai OSUG
HathiMaryA
 
“Voice Interfaces on a Budget: Building Real-time Speech Recognition on Low-c...
Edge AI and Vision Alliance
 
Agentforce World Tour Toronto '25 - MCP with MuleSoft
Alexandra N. Martinez
 
NLJUG Speaker academy 2025 - first session
Bert Jan Schrijver
 
Go Concurrency Real-World Patterns, Pitfalls, and Playground Battles.pdf
Emily Achieng
 
[Newgen] NewgenONE Marvin Brochure 1.pdf
darshakparmar
 
“Squinting Vision Pipelines: Detecting and Correcting Errors in Vision Models...
Edge AI and Vision Alliance
 

Reasonable Code With Fsharp

  • 4. SYNTAX int euler1(int max) { var total = 0; for(var n=1; n<max; n++) { if(n % 3 == 0 || n % 5 == 0){ total += n; } } return total; } euler1(1000); C# let euler1 max = [1..max-1] |> List.filter (fun n -> n % 3 = 0 || n % 5 = 0) |> List.sum euler1 1000 F#
  • 5. SYNTAX – VS LINQ int euler1(int max) { return Enumerable.Range(1, max - 1) .Where(n => n % 3 == 0 || n % 5 == 0) .Sum(); } euler1(1000); C# let euler1 max = [1..max-1] |> List.filter (fun n -> n % 3 = 0 || n % 5 = 0) |> List.sum euler1 1000 F#
  • 6. TYPE INFERENCE int x = 3; long y = 4; var z = x + y; // = 7 C# let x = 3 let y:int64 = 4L x + y F# The type 'int64' does not match the type 'int'
  • 7. AUTOMATIC GENERALIZATION val firstInGroup : g:('a -> 'b) -> list:seq<'a> -> seq<'b * 'a> when 'b : equality public IEnumerable<Tuple<U,T>> firstInGroup<T,U> (Func<T,U> g, IEnumerable<T> list) { return list.GroupBy(g) .Select(grp => new Tuple<U, T>(grp.Key, grp.First())); } C# let firstInGroup g list = list |> Seq.groupBy g |> Seq.map (fun (key,items) -> key, Seq.head items) F#
  • 8. GENERALIZE THIS! int add<T>(T x, T y) where T: op_addition { return x + y; } C# let add x y = x + y add 3 4 add 4.2 5.1 F# let inline add x y = x + y add 3 4 add 4.2 5.1 add "hello" "World" F#
  • 9. IMMUTABILITY Eliminate unintended side effects Sets you up for multi-core programming Debugging is easier Testability is higher Intended side effects are necessary Performance
  • 10. IMMUTABILITY - EXAMPLE Example from “Inside F#” blog let actions = List.init 5 (fun i -> fun() -> i*2) for act in actions do printf "%d " (act()) F# List<Func<int>> actions = new List<Func<int>>(); for (int i = 0; i < 5; ++i) { actions.Add( () => i * 2 ); } foreach (var act in actions) { Console.WriteLine( act() ); } C# The mutable variable 'i' is used in an invalid way. Mutable variables cannot be captured by closures. Consider eliminating this use of mutation or using a heap-allocated mutable reference cell via 'ref' and '!'.
  • 12. FUNCTIONS AND FUNCTIONAL TYPES Which problem would you rather focus on? a) Where the code should live b) What the code should do
  • 13. COMPOSITION VS INHERITANCE Is-a relationship that extends the base class Very high coupling Subclasses may not need all functionality from base class Subclass has to be aware of the base class’s implementation Ninject StructureMap Castle WindsorUnity Interface-dependent
  • 14. FUNCTION COMPOSITION Pipeline Operator: |> Return value of first function becomes the last parameter of second function Forward Composition Operator: >> Create new functions that are sequences of existing functions webUrl |> downloadPage |> extractMetaInfo |> categorizeResource F# let categorizeUrl = downloadPage >> extractMetaInfo >> categorizeResource let categorizeEmail = parseEmail >> extractDetail >> categorizeResource categorizeUrl webUrl categorizeEmail email F#
  • 15. FUNCTION COMPOSITION Partial Application Create new functions by supplying some of the arguments to an existing function let MSBuild properties (outputPath:string) (targets:string) = //Do some msbuild stuff let MSBuildDebug = MSBuild ["Configuration","Debug"] let MSBuildRelease = MSBuild ["Configuration","Release"] F# * From FAKE
  • 16. PATTERN MATCHING let data = ("Cleveland", 390000) let city, population = data F# let x = 9 match x with | num when num < 10 -> printfn "Less than ten" | _ -> printfn "Greater than or equal to ten" F#
  • 17. DISCRIMINATED UNIONS type Shape = | Square of int | Rectangle of float*float | Circle of float F# let getArea shape = match shape with | Square side -> float(side * side) | Rectangle(w,h) -> w * h | Circle r -> System.Math.PI * r * r F# let sq = Square 7 let rect = Rectangle 2.2 3.3 let cir = Circle 3.4 F#
  • 18. OPTION TYPE type Option<‘T> = | None | Some of ‘T F#
  • 19. OBJECT MODELING * From F# Deep Dives type MarkdownDocument = list<MarkdownBlock> and MarkdownBlock = | Heading of int * MarkdownSpans | Paragraph of MarkdownSpans | CodeBlock of list<string> and MarkdownSpans = list<MarkdownSpan> and MarkdownSpan = | Literal of string | InlineCode of string | Strong of MarkdownSpans | Emphasis of MarkdownSpans | Hyperlink of MarkdownSpans * string F#
  • 20. FUNCTIONS AND FUNCTIONAL TYPES 1.Think small, build big 2.Model 3.Flow
  • 21. COMPILER CHECKED CORRECTNESS Step 1: Create types Step 2: Lean on the compiler
  • 22. UNITS OF MEASURE unitsOfMeasure.fsx(11,19): error FS0001: Type mismatch. Expecting a int<mi> [] but given a int<km> [] The unit of measure 'mi' does not match the unit of measure 'km' [<Measure>] type mi [<Measure>] type km // define some values let mike = [| 6<mi>; 9<mi>; 5<mi>; 18<mi> |] let chris = [| 3<km>; 5<km>; 2<km>; 8<km> |] let totalDistance = (Array.append mike chris) |> Array.sum F#
  • 23. UNITS OF MEASURE enum DistanceUnit { Miles, Kilometers } class Run { private float distance; private DistanceUnit unit; public Run(float distance, DistanceUnit unit){ this.distance = distance; this.unit = unit; } } C#
  • 24. EXHAUSTIVE PATTERN MATCHING //Model module Person = type T = Person of string let create name = if String.IsNullOrWhiteSpace(name) then None else Some(Person name) let value (Person p) = p //DAL let save person = //put the person in the database… Some 42 //UI let readInput name = match Person.create name with | None -> printfn "Please supply a name" | Some p -> match save p with | None -> printfn "An error occurred" | Some id -> printfn "The id for %s is %d" (Person.value p) id F#
  • 25. EXHAUSTIVE PATTERN MATCHING //DAL type DatabaseResult<'a> = | Success of 'a | UniqueViolation | GeneralException of Exception //UI let readInput name = match Person.create name with | None -> printfn "Please supply a name" | Some p -> match save p with | Success(id) -> printfn "The id for %s is %d" (Person.value p) id | UniqueViolation -> printfn "The name %s already exists" (Person.value p) | GeneralException(ex) -> printfn "%s" ex.Message F#
  • 26. DATABASE ACCESS, TOO? Amount of code added to project
  • 27. COMPILER CHECKED CORRECTNESS 1.Focus on the problem 2.Don’t forget stuff
  • 28. SUMMARY To Reason: To make sense of Syntax & Idioms Functional composition Compiler-checked correctness

Editor's Notes

  • #2: F# language make code easier to understandCan you use F# for a wide range of problems
  • #3: Small teams, close to businessCut teeth on XPPFP
  • #4: Who has written any F#?Who gets paid to write F#?A lot like most of you: not an expert.Wanted to stretch my brain like what I see so far I want to share
  • #6: {} () ; returnNot completely noise…Compiler needs curly bracesIndentingLINQ: adds a lot to readability, but uses:higher order functionsChaining – tied to an interface
  • #7: Let’s talk about types
  • #8: - Code reuse! You don’t see the constraints, you see the concepts – the behavior.
  • #9: &quot;inline“- gives per-type versions of the function, big performance gain over generics- Needed for code that uses overloaded operators – they statically resolve to the default (usually int)
  • #10: Makes your code more predictableThe default is immutability“minimization” not “elimination”Immutable objects are thread safe
  • #11: 10 10 10 10 100 2 4 6 8
  • #12: SyntaxGeneralizationImmutability
  • #13: F# is a hybridThesethings are not available in the C# language
  • #14: Composition: pass dependencies at runtime into an instance. Operations are interface-dependentLook back at LINQ exampleTalk about “function composition” in F#...
  • #15: PipelineDefine a sequence of operationsAny function can be a part of the pipeline – not limited to a particular interfaceForward composition
  • #16: Great in libraries to create functions that take defaultsOr for eliminating boolean parameters, making existing libraries easier to work with
  • #17: Decompose or extract specific infoCompare data with a structurelet binding AND program control
  • #19: “Object reference not set to an instance of an object.”Very important – eliminatesNullReferenceExceptionsWith pattern matching, forces client code to check for None
  • #20: Simple to understandInstead of strings named “Literal”, “Literal” is a type
  • #21: Model: use functional types to concisely represent complex object models (especially hierarchies)Flow: most appsTake data inDo some workShow results of workBecause immutable, your thinking changes from “mutate the object” to represent the results to “transform” some data
  • #22: Compilers are nice because they tell us when we do something bad.What if the compiler was more proactive (like in the immutability example)?
  • #23: Annotate values in your code with units
  • #24: Just a structure. Not even values…. “new” up a bunch, etc.Think of the work to get the compiler to tell you when you attempt to add miles and kilometers!point: I’m sure it’s possible. But it won’t be nearly as concise or readable.
  • #25: You have to deal with return values.
  • #26: Patterns are exhaustiveNot only detects missingImpossibleRedundant
  • #27: Have to know what the state of the model is compared to the state of the database
  • #28: UOM: always compare apples to applesPM: compiler checks for edge cases; forces you to dealTP: don’t worry about state of two disconnected things
  • #29: Same input, same output; test in isolationCreate functions that solve small problems in your domain (Lego™ blocks), then combine themCreate types that enforce correctness, and force clients to follow the rules
  • #30: Don’t ignore other functional languages – like OO, there’s a lot to learn from other languagescaml or lisp basedThink polyglot – use functional where you think you can.