Jun 29, 2011

f# essential - part 3 matching shortcut

F# provide a shortcut to define a function which purely use input parameter for matching purpose. For example the following are equal.

let printInt =
    function 1 -> printfn "1"
            | 2 -> printfn "2"
            | _ -> printfn "something else"

let printInt number =
    match number with 1 -> printfn "1"
                      | 2 -> printfn "2"
                      | _ -> printfn "something else"

let printInt number =
    match number with
        | 1 -> printfn "1"
        | 2 -> printfn "2"
        | _ -> printfn "something else"

f# essential - part 2 - pipleline operator

Before I discuss pipeline operator, let's talk about operator. F# allow us to define operator as function. The following are infix operators

$ % & * + - . / < = > @ ^ | 

The following are prefix operators.

! ? ~

You can define a infix operator like below

let (operator) ops1 ops2 = ...
//for example 
let (+) a b = a - b

You can define a prefix operator like below

let (!) a = 1

So you can change your expression from "add 2 4" to "2 + 3" or "m1 a" to "!a", let's defined our pipleine operator as below.

let (-->) x f = f x
let rb = 0.5 --> System.Math.Cos

However, F# already define the "|>" for us, so we should use "|>". Operator is not a function, definition, rather you should think of it as macro. The compiler will change the syntax before it compile.

f# essential - part 1 binding

I was very puzzled with some concept when learning F#. Here is some. Even I explain it here, you may be still confused, but it is ok, as you read on.

let t1 = 1
//fsi shows val t1 : int = 1
//think of it as (val t1) bind to (int = 1)

Based on the concept of other language, you think t1 is variable, and it is initialized or assigned with value 1. But here it should be understood as identifier t1 is bind to a value, the value is not function value, it is int 1. So what is the big deal of "identifier", "bind", "function value", and "value", we will see later. If you run the following expression in fsi

//fsi shows val it: int =1

This is evaluation of expression "t1", the process is to bind value int 1 to unknown identifier. Let's read another example.

let t2() = 1
//fsi shows  val t2 : unit -> int
//here fsi should shows
//val t2: unit -> int = <fun:it@91-2>

Here it means identifier t2 is bind to a value, the value is a function value, and the value is a function take unit type parameter and return a int type value. Here unit is similar the concept of "void" in other language. How do I prove my remark "here fsi should shows...", because we can find out what is the value of t2, by evaluating expression "t2" like below, it return the value of t2, here what I really means "the value that t2 is bind to "

//val it : (unit -> int) = <fun:it@91-2>

t2 is different from t1 in that the value t2 bind to is a function, while the value that t1 bind to is not. Because the value is function, we can call the function like below. The concept of "function is a value" is an important concept in functional language, it may not looks a big deal for you. But it is very powerful. Please note the function here is not a traditional function in VB, a method in c#, conceptually it is like C#'s delegate, or javascript's function, people call it lamda in other functional language.

//fsi shows val it : int = 1

The type description generated by fsi need some explanation.

int //int type
int -> string //function type take one int input, return one string
int -> string -> double // a function take one int, one string, return one double
int * string -> double // a function take a (int, string) tuple , and return one double