layout: page
title: “Why use F#?”
description: “Why you should consider using F# for your next project”
nav: why-use-fsharp
hasIcons: 1

image: “/assets/img/four-concepts2.png”

Although F# is great for specialist areas such as scientific or data analysis, it is also an excellent choice for enterprise development.
Here are five good reasons why you should consider using F# for your next project.

Conciseness" class="reference-link">“Why use F#?” in one page - 图6 Conciseness

F# is not cluttered up with coding “noise” such as curly brackets, semicolons and so on.

You almost never have to specify the type of an object, thanks to a powerful type inference system.

And, compared with C#, it generally takes fewer lines of code to solve the same problem.

  1. // one-liners
  2. [1..100] |> List.sum |> printfn "sum=%d"
  4. // no curly braces, semicolons or parentheses
  5. let square x = x * x
  6. let sq = square 42 
  8. // simple types in one line
  9. type Person = {First:string; Last:string}
  11. // complex types in a few lines
  12. type Employee = 
  13.   | Worker of Person
  14.   | Manager of Employee list
  16. // type inference
  17. let jdoe = {First="John";Last="Doe"}
  18. let worker = Worker jdoe

Convenience" class="reference-link">“Why use F#?” in one page - 图7 Convenience

Many common programming tasks are much simpler in F#. This includes things like creating and using
complex type definitions, doing list processing,
comparison and equality, state machines, and much more.

And because functions are first class objects, it is very easy to create powerful and reusable code by creating functions
that have other functions as parameters,
or that combine existing functions to create new functionality. 

  1. // automatic equality and comparison
  2. type Person = {First:string; Last:string}
  3. let person1 = {First="john"; Last="Doe"}
  4. let person2 = {First="john"; Last="Doe"}
  5. printfn "Equal? %A"  (person1 = person2)
  7. // easy IDisposable logic with "use" keyword
  8. use reader = new StreamReader(..)
  10. // easy composition of functions
  11. let add2times3 = (+) 2 >> (*) 3
  12. let result = add2times3 5

Correctness" class="reference-link">“Why use F#?” in one page - 图8 Correctness

F# has a powerful type system which prevents many common errors such
as null reference exceptions.

Values are immutable by default, which prevents a large class of errors.

In addition, you can often encode business logic using the type system itself in such a way
that it is actually impossible to write incorrect code
or mix up units of measure, greatly reducing the need for unit tests. 

  1. // strict type checking
  2. printfn "print string %s" 123 //compile error
  4. // all values immutable by default
  5. person1.First <- "new name"  //assignment error 
  7. // never have to check for nulls
  8. let makeNewString str = 
  9.    //str can always be appended to safely
  10.    let newString = str + " new!"
  11.    newString
  13. // embed business logic into types
  14. emptyShoppingCart.remove   // compile error!
  16. // units of measure
  17. let distance = 10<m> + 10<ft> // error!

Concurrency" class="reference-link">“Why use F#?” in one page - 图9 Concurrency

F# has a number of built-in libraries to help when more than one thing at a time is happening.
Asynchronous programming is very easy, as is parallelism.

F# also has a built-in actor model, and excellent support for event handling
and functional reactive programming.

And of course, because data structures are immutable by default, sharing state and avoiding locks is much easier.

  1. // easy async logic with "async" keyword
  2. let! result = async {something}
  4. // easy parallelism
  5. Async.Parallel [ for i in 0..40 -> 
  6.       async { return fib(i) } ]
  8. // message queues
  9. MailboxProcessor.Start(fun inbox-> async{
  10.     let! msg = inbox.Receive()
  11.     printfn "message is: %s" msg
  12.     })

Completeness" class="reference-link">“Why use F#?” in one page - 图10 Completeness

Although it is a functional language at heart, F# does support other styles which are not 100% pure,
which makes it much easier to interact with the non-pure world of web sites, databases, other applications, and so on.

In particular, F# is designed as a hybrid functional/OO language, so it can do virtually everything that C# can do.

Of course, F# is part of the .NET ecosystem, which gives you seamless access to all the third party .NET libraries and tools.
It runs on most platforms, including Linux and smart phones (via Mono and the new .NET Core).

Finally, it is well integrated with Visual Studio (Windows) and Xamarin (Mac), which means you get a great IDE with IntelliSense support, a debugger,
and many plug-ins for unit tests, source control, and other development tasks. Or on Linux, you can use the MonoDevelop IDE instead.

  1. // impure code when needed
  2. let mutable counter = 0
  4. // create C# compatible classes and interfaces
  5. type IEnumerator<'a> = 
  6.     abstract member Current : 'a
  7.     abstract MoveNext : unit -> bool 
  9. // extension methods
  10. type System.Int32 with
  11.     member this.IsEven = this % 2 = 0
  13. let i=20
  14. if i.IsEven then printfn "'%i' is even" i
  16. // UI code
  17. open System.Windows.Forms 
  18. let form = new Form(Width= 400, Height = 300, 
  19.    Visible = true, Text = "Hello World") 
  20. form.TopMost <- true
  21. form.Click.Add (fun args-> printfn "clicked!")
  22. form.Show()

The “Why Use F#?” series

The following series of posts demonstrates each of these F# benefits, using standalone snippets of F# code (and often with C# code for comparison).