This document summarizes an introduction to the F# programming language presented at the Houston TechFest 2009. It covers core F# concepts like functional, object-oriented, and language-oriented programming paradigms. It also provides an overview of basic F# syntax, when to use F#, when not to use it, and resources for learning more about F#.

1. Practical F#Ryan RileyCatapult Systems, Inc.Houston TechFest 2009

2. AgendaCore ConceptsBasic SyntaxWhy Consider F#When to use F#When not to use F#Summary

3. Core Concepts

4. F# ParadigmsFunctionalObject-orientedLanguage-oriented

5. Functional Programming ConceptsFirst-Class Functions (and Events)Strong Type InferenceImmutabilityMake side-effects explicit (the M-word)Functional Reactive ProgrammingEasy ConcurrencyActor-model Messaging (similar to Erlang)Lazy Evaluation

6. Basic Syntax

7. letSimilar to var in C#.

8. TuplesType-safe collection of valuesC# out parameters are returned as tuples

9. Class Declaration

10. Abstract Classes

11. Interfaces

12. Inheritance

13. RecordsBut then, why bother?

14. Discriminated UnionsFunctional inheritance

15. Pattern Matching

16. Extension Methods

17. Object Expressions

18. Control Flow with Pipes

19. Function Composition

20. Computation Workflows

21. QuotationsThis is supposed to be a practical discussion!Quotations are similar to LINQ Expressions.

22. REPL

23. Visual Studio Integration

24. Why Consider F#?You can do everything you did in C# within F#Some things are simpler, some harderSimpler: many OO design patternsSimpler: Asynchronous tasksHarder: GUI programmingTerrific for specialized tasks (polyglot)Many great F# librariesTerse language = fewer lines of code = $ saved

25. When to use F#Asynchronous operationsConcurrent operationsMessaging (MailboxProcessor)Transformation operations (like SSIS)Computation-intensive operations (like SSAS)Creating Domain Specific Languages (DSLs)Aspect-Oriented Programming (AOP)Testing

26. FP vs. OOP

27. #1 Reason to use F# Your entire application is already just a series of LINQ statements!

28. TestingFsTestFsUnit

29. Generate Test Data

30. Mathematical CalculationsProject Euler Problem 4:Project Euler Problem 3:Project Euler Problem 6

31. Excel Financial Functions

32. ParsersFSharp.PowerPack has a lexer and parserFparsecCashel

33. Automated Builds with Fake

34. Async Workflows

35. Async Workflows from C#

36. Functional AOP?

37. When not to use F# Just want to use the newest thingGUI programmingYou can do itCan’t use the designersCan still be a great toolWhen you are already proficient in C# and are focused almost entirely on OOP.Stick to what you know. You’ll be faster.

38. Summary“Write tomorrow’s legacy code today with C#”Chris Smith’s F# FactsTry F#Fall in love with F#Use F#The End

39. ResourcesF# is still CTPTry it in VS2010 Beta 1Or use the VS2008 CTP installerRead booksFoundations of F#(Pickering)Expert F# (Syme)Functional Programming for the Real World (Petricek and Skeet)F# for Scientists (Harrop)

40. Resourceshttp://channel9.msdn.com/pdc2008/TL11/http://tomasp.net/blog/fsharp-webcast-functional.aspxhttp://lorgonblog.spaces.live.com/blog/http://codebetter.com/blogs/matthew.podwysocki/default.aspx

41. The end …

42. MonadsMonads are about function composition.Take a monoid:f(x) -> xg(x) -> xf(g(x)) -> xf.g x -> xAdd a transformation:f(x) -> Mxg(x) -> Mxf(g(x)) -> Mxf.g x -> Mx

43. Creating Monadic BuildersThe parts of a monad:(in F#, this would be a workflow builder)x.Let (value, transform): sets a value, like LINQ’s Select().x.Bind (value, transform): splits the value from the transform and passes it into the next function, like LINQ’s SelectMany().x.Return (value): returns the result.x.Delay (transform): kicks off the workflow.

44. Computation workflow structureTypical structure of a workflow builder:type WorkflowBuilder () = member x.Bind (value, transform) = transform value member x.Return (value) = fun () -> value member x.Delay (transform) = fun () -> transform ()let workflow = new WorkflowBuilder()Execute like so:let myWorkflow = workflow { let x = 1 // x.Let let! y = 2 // x.Bind return x + y // x.Return }let result = myWorkflow () // x.Delay