2.
F# is starting from a research project of Microsoft, created by Don Syme F# is a functional programming language that runs on top of .NET F# is now part of VS 2010 built in programming language Also part of OCAML programming language family
3.
There are many definitions about this, and there’s no simple standard definition According to Erik Meijer and Brian Beckman of Microsoft, Functional Programming is programming with mathematical function, where function is a first class citizen of a program
4.
A simple operation that returns a value, that can have a parameter or more than one parameters
7.
F# OOP (C#, VB, C++…) Immutable by default Mutable by default Function is the same as Function is treated as a data in a program, and can method that must reside in be written as a standalone a body of a class function ‘Noisy’ syntax Succinct syntax Type inference is only Type inference is available available since C# 3.0 and from the start VB 9.0, not in C++ and others
9.
Immutable by default Mutable by default let y = x + 1 x = x +1 Mutable is explicit Immutable is explicit. For example, in C#: let mutable x = x + 1 readonly x = 0 In VB: ReadOnly x As Integer
10.
In F#, it can be In C# and VB, it must standalone and simple be enclosed in a class/module let f x = x +2 class SimpleFunc { public static Int32 f(Int32 x) This is why it is called { return x + 2; “succinct” } } This is “noisy”
11.
Already have at the first release It is also a strong type language Including built in support of Generic The type inference is not just local type inference, but it then can be inferred based on the use of the parameters!
13.
Type inference on functions when it’s used let f x = sqr x + 1 Infers integer .. return type from a whole becomes int number…let sqr x = x * x Infers double from a double literal.. let f x = sqr x + 1.0
14.
Less noise syntax but it’s still strongly typed
15.
Always begin with keyword “let” let avalue = 10 let aName = ‘Hello’ let savingInterest = 0.2
16.
When there’s a need for explicit type system: let x:int = 0 let piConstant:float = 3.141 let Name:String = ‘Eriawan’
17.
Always begin with let keyword let f x = x + 1 let sqr y = y * y let force x = x * gravity
18.
Parameters are written in a nice separation “juxtaposition” syntax: a space let sqr x = x * x Function parameter let add a b = a + b
20.
Multiple lines of code is using indentation: let rec fib x = if x < 2 then 1 else fib (x–1) + fib (x-2)
21.
Comment is the same with VB and C# // some code let x = x + 2 // XML doc comment: /// <summary>A square function<summary> /// <param name=‚x‛>the value</param> let f x = x * x
22.
The object oriented and imperative are here in F#
24.
Mutable is easy, by adding keyword “mutable” Next operation of assignment must use “<-” to differentiate mutability. let mutable y = 10 y <- y + 1
25.
Creating enum is also easy: type Suit = | Heart | Diamond | Spade | Club
26.
type Vector2D(dx:float, dy:float) = // The pre-computed length of the vector let length = sqrt(dx*dx + dy*dy) /// The displacement along the X-axis member v.DX = dx /// The displacement along the Y-axis member v.DY = dy /// The length of the vector member v.Length = length // Re-scale the vector by a constant member v.Scale(k) = Vector2D(k*dx, k*dy)
27.
It’s easy! Just create type but with abstract keyword as modifier for all functions and other members: type IPeekPoke = abstract Peek: unit -> int abstract Poke: int -> unit
Be the first to comment