• f# essential - part 7 Curry

    Function application, also sometimes referred to as function composition or composing functions is a big thing in functional programming. One style of composition is called Curry. Curry is feature of lots functional language. When you have a function with two parameter, you can pass one argument to the function, that create an new partial function, which accept one parameter. This partial function is also called curried function. F# support this in a very elegant syntax.

    let print x y = 
         printfn "%i" x 
         printfn "%s" y 
    let print100y = print 100 //create a curried function 
    print100y "hello" //call the curried function 
    

    If you want to fill in the second argument to create a new function, this is also support, like below.

    let printx_hello x = dosomething x "hello" 
    printx_hello 100
    
  • f# essential - part 6 - tuple

    In other language, a method can not return more than one parameter. There are two way to get around this, use passed-by-reference parameter, or use composite type to encapsulate two or more fields in to one object. Both of them are not elegant. However, f# can express this using a very simple syntax to solve this problem, "tuple", which is a strongly typed structure. Here is an example.

    let (x, y, z) = (1, 2, 3)
    //or
    let x, y, z = 1, 2, 3
    
  • f# essential - part 5 - mutable, ref

    As mentioned in previous post, the "let" syntax define a identifier binding, which is immutable. So it is not variable in the sense of traditional programming. But we can not programming in pure functional language environment. We need to create state, and side effect. F# is pragmatic and play nice with .net framework, so it has to be support variable. To use variable, you just need to add a "mutable" in front identifier, then the identifier became variable in the sense of traditional programming.

    let totalArray2 () =
        let array = [|1; 2; 3|]
        let mutable total = 0
        
        for x in array do
            total <- total + x
    
    
  • f# essential part 4 - closure

    f# support closure. Here is the definition of closure

    In computer science, a closure (also lexical closure, function closure or function value) is a function together with a referencing environment for the nonlocal names (free variables) of that function.

    In f#, you can define functions within other functions. The inner function can use any identifier in scope, including identifiers defined in outer function. When the inner identifier return as result of the outer function, identifiers defined in outer function is still being captured by the inner function, the inner is called closure.

    let buildGreet greeting  = 
        let prefix = Printf.sprintf "%s ," greeting
        let greet name = 
            Printf.sprintf "%s%s" prefix name
        greet //greet is a closure, even the it is return it can still access,
    
    
  • 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"