Dave Fancher presenting at the March Indy .NET Mobile Dev meetup: Originally developed by Microsoft Research, Cambridge, F# is an open-source, functional-first language in the ML family. Despite its lofty position as a first-class Visual Studio language for the past two releases and its cross-platform availability it hasn't seen widespread adoption in the business world. These slides take you on an introductory tour of F#, exploring how its constructs and terse syntax can allow you to write more stable, maintainable code while keeping you focused on the problem rather than the plumbing.

1. Break Free with
Managed Functional Programming
An Introduction to F#

2. A language that doesn't affect the way you think
about programming, is not worth knowing.
Alan Perlis, Epigrams on Programming, 1982

3. About Me
• Dave Fancher
• Blog: http://davefancher.com
• Twitter: @davefancher
• Email: dave@davefancher.com

4. My Background

6. Why F#?

7. LINQ: The Functional Gateway Drug
• Learned about query syntax
• The method syntax
• Introduced me to functional principles

8. JavaScript, Too!
• Functions are first class citizens
• Its most powerful features are enabled by closures

9. Turning Functional
• Began applying functional principles in my code
• Immutability with readonly fields & properties
• More delegation
• Coding without side-effects

10. C# Was Getting Frustrating
• Verbose and repetitive
• Fragile
• Ceremonial

11. An Accidental Discovery
• Hanselminutes #311
• F#

12. So, what is this F# thing?

13. F# is a succinct, expressive, and efficient
functional and object-oriented language
for Microsoft .NET that helps you write
simple code to solve complex problems.

14. Origin
• CLR Language
• Microsoft Research, Cambridge

15. Lineage
ML OCaml F#

16. Multi-Paradigm
• Imperative
• Object-oriented
• Functional

17. Licensing & Availability
• First Class Citizen of Visual Studio since VS2010
• Apache 2.0 License
• Every major platform
• Managed by F# Software Foundation

18. Ok, but why should I care?

19. Gaining Traction
Source: TIOBE Index, May 2014 (http://bit.ly/1cvhJp3)

20. F# Over Time
August 2011
March 2013
March 2014
Source: TIOBE Index, May 2014 (http://bit.ly/1nnmeWK)

21. Functional-First
• Favors FP over other styles
• Other styles are available if needed

22. Design Principles

23. Terse Syntax
• Few keywords
• Limited punctuation
• Strong type inference
• Implicit return values

24. Top-Down Evaluation
• File order is significant
• Declaration order is, too
• Avoids inadvertent mutually recursive definitions
• Inferred return values

25. Organization Constructs
• Namespaces
• Modules

26. Expression-Based
• Everything returns a value
• Eager evaluation

27. Immutable by Default
• 3 Types of bindings
• Immutable by default

28. Let Bindings

29. Mutability

30. Reference Cells

31. Using Function & Use Bindings

32. Type system

33. All CLR Types
• Int32
• String
• Double
• Float
• DateTime
• TimeSpan
• Types from other assemblies
• …

34. Enumerations

35. Functions
• Every F# function accepts exactly one input and returns exactly one
output
• No concept of void functions
• No concept of parameterless functions

36. Unit
• Denoted as ()
• Indicates no specific value
• Can safely be ignored
• Usually indicative of a function that has some effect

37. Tuples

38. Tuples for out Parameters

39. Syntactic Tuples

40. Records

41. Discriminated Unions
• Immutable
• Structural Equality
• Resemble enumerations but are more powerful
• Versatile

42. DUs as Object Hierarchies

43. DUs as Trees

44. http://bit.ly/1g76AOv
Mitigating Null

45. Options

46. Integrated Units of Measure

47. Measure Types

48. Live Demo: Enforcing Units of Measure

49. Collection Types
• Sequences – seq { … }
• Arrays – [| … |]
• Lists – [ … ]
• Maps
• Sets

50. Collection Modules
• Provide functions for manipulating collections
• Many LINQ-like operations
• map -> Select
• reduce -> Aggregate
• filter -> Where

51. F# Lists
• Not List<‘T>
• Immutable
• [ … ]
• List module
• Cons operator ::
• Concatenation operator @

52. Composing F# Lists With :: and @

53. Object-Oriented

54. Classes

55. Filthy little
hobbitses.
They stole it
from us!

56. Classes

57. Interfaces

58. Implementing Interfaces

59. Inheritance & Virtual Members

60. Object Expressions

61. Functional

62. Functional programming is programming without
assignment statements.
Bob Martin, FP Basics, Episode 1 (http://bit.ly/1nnhDnm)

63. Functional Purity
• F# is impure
• Mutability and side-effects are
allowed

64. Functions as Data
• Higher-order functions
• Let-bound functions
• Lambda expressions

65. Currying
• Named for Haskell Curry
• Arguments are applied individually
• Changes function organization

66. Curried Addition & Expanded Form

67. Partial Application

68. Pipelining

69. Function Composition

70. Recursion
• Preferred looping mechanism
• Compiler optimizes for tail calls

71. Pattern Matching

72. Basic Pattern Matching

73. Built-in patterns
• Null
• Variable & Wildcard
• Literal
• Tuple
• Record
• Identifier
• Array
• List
• Cons
• As
• And
• Or

74. Decomposing Tuples

75. Decomposing DUs

76. Active Patterns
• Custom patterns
• Special type of function called an Active Recognizer
• Curried
• Maximum number of cases is 7
• Each input must map to a named case

77. Partial Active Patterns
• Single custom case
• Not restricted to 7 active patterns
• Return value is option

78. Live Demo: Partial Active Patterns

79. Data Access

80. Language Features
• Query Expressions
• Type Providers

81. Live Demo: Using the OData Type Provider

82. Async & Parallel Programming

83. Asynchronous Workflows
• Conceptually similar to async/await in C#
• Works using lightweight callbacks and continuations

84. Agent-based programming
• Borrowed from Erlang
• In-memory queuing mechanism
• Uses MailboxProcessor<‘T> for message passing
• Implementation often includes asynchronous workflows for
monitoring

85. Live Demo: Agent-based Calculator

86. Computation Expressions

87. Extending the Language
• Basis for several language features
• Based on a builder class
• Builder class methods map to familiar language elements

88. Live Demo: Custom Computation Expression

89. In Summary
• F# is a powerful, multi-paradigm language
• Plays nicely with other CLR languages
• Offers numerous constructs to keep you focused on the problem
rather than the plumbing
• Simple code for complex problems

90. No matter what language you work in, programming
in a functional style provides benefits. You should do it
whenever it is convenient, and you should think hard
about the decision when it isn’t convenient.
John Carmack, Functional Programming in C++

91. The More You Know
• The Book of F#
http://bit.ly/1hzHV6v
• F# Software Foundation
http://fsharp.org
• Try F#
http://tryfsharp.org
• F# Language Reference
http://bit.ly/1koEoqK