This document discusses F#, a functional-first, object-oriented, and statically typed .NET language. It provides code examples comparing F# and C# implementations of classes, unit tests, and other programming concepts. F# code is generally shorter, easier to read, refactor, and contains fewer bugs than equivalent C# code. The document also outlines F# resources like the F# Software Foundation and community for learning and contributing to the language.

1. Phil Trelford, @ptrelford
#FuncBY Minsk, 2014

7.  Statically Typed
 Functional First
 Object Orientated
 Open Source
 .Net language
 In Visual Studio
& Xamarin Studio

8. Kaggle
The fact that F# targets the
CLR was also critical
we have a large existing code
base in C#,
getting started with F# was
an easy decision.

9. The F# code is
consistently shorter,
easier to read,
easier to refactor and
contains far fewer bugs.
…we’ve become
more productive.

10. Phil Trelford, @ptrelford
#FuncBY Minsk, 2014

11. F#
type Person(name:string,age:int) =
/// Full name
member person.Name = name
/// Age in years
member person.Age = age
C#
public class Person
{
public Person(string name, int age)
{
_name = name;
_age = age;
}
private readonly string _name;
private readonly int _age;
/// <summary>
/// Full name
/// </summary>
public string Name
{
get { return _name; }
}
/// <summary>
/// Age in years
/// </summary>

12. F#
type VerySimpleStockTrader
(analysisService:IStockAnalysisService,
brokerageService:IOnlineBrokerageService) =
member this.ExecuteTrades() =
() // ...
C#
public class VerySimpleStockTrader
{
private readonly
IStockAnalysisService analysisService;
private readonly
IOnlineBrokerageService brokerageService;
public VerySimpleStockTrader(
IStockAnalysisService analysisService,
IOnlineBrokerageService brokerageService)
{
this.analysisService = analysisService;
this.brokerageService = brokerageService;
}
public void ExecuteTrades()
{
// ...
}
}

13. F# NUnit
module MathTest =
open NUnit.Framework
let [<Test>] ``2 + 2 should equal 4``() =
Assert.AreEqual(2 + 2, 4)
C# NUnit
using NUnit.Framework;
[TestFixture]
public class MathTest
{
[Test]
public void TwoPlusTwoShouldEqualFour()
{
Assert.AreEqual(2 + 2, 4);
}
}

14. F# Foq
let ``order sends mail if unfilled``() =
// setup data
let order = Order("TALISKER", 51)
let mailer = mock()
order.SetMailer(mailer)
// exercise
order.Fill(mock())
// verify
verify <@ mailer.Send(any()) @> once
C# Moq
public void OrderSendsMailIfUnfilled()
{
// setup data
var order = new Order("TALISKER", 51);
var mailer = new Mock<MailService>();
order.SetMailer(mailer.Object);
// exercise
order.Fill(Mock.Of<Warehouse>());
// verify
mailer.Verify(mock =>
mock.Send(It.IsAny<string>()),
Times.Once());
}

16. type formula =
| Neg of formula
| Exp of formula * formula
| ArithmeticOp of
formula * arithmetic * formula
| LogicalOp of
formula * logical * formula
| Num of UnitValue
| Ref of int * int
| Range of int * int * int * int
| Fun of string * formula list

17. open FSharp.Data
type Simple = JsonProvider<""" { "name":"John", "age":94 } """>
let simple = Simple.Parse(""" { "name":"Tomas", "age":4 } """)
Simple.Age

19. Phil Trelford, @ptrelford
#FuncBY Minsk, 2014

20. software stacks
trainings teaching F# user groups snippets
mac and linux cross-platform books and tutorials
F# Software Foundation
F# community open-source MonoDevelop
http://www.fsharp.org
contributions research support
consultancy mailing list

21. //---------------------------------------------------------------
// About Let
//
// The let keyword is one of the most fundamental parts of F#.
// You'll use it in almost every line of F# code you write, so
// let's get to know it well! (no pun intended)
//---------------------------------------------------------------
[<Koan(Sort = 2)>]
module ``about let`` =
[<Koan>]
let LetBindsANameToAValue() =
let x = 50
AssertEquality x __

26. Phil Trelford, @ptrelford
#FuncBY Minsk, 2014