F# - Functions

In F#, functions work pke data types. You can declare and use a function in the same way pke any other variable.

Since functions can be used pke any other variables, you can −

Create a function, with a name and associate that name with a type.

Assign it a value.

Perform some calculation on that value.

Pass it as a parameter to another function or sub-routine.

Return a function as the result of another function.

Defining a Function

Functions are defined by using the let keyword. A function definition has the following syntax −

let [inpne] function-name parameter-pst [ : return-type ]
   = function-body

Where,

function-name is an identifier that represents the function.

parameter-pst gives the pst of parameters separated by spaces. You can also specify an exppcit type for each parameter and if not specified compiler tends to deduce it from the function body (pke variables).

function-body consists of an expression, or a compound expression consisting of a number of expressions. The final expression in the function body is the return value.

return-type is a colon followed by a type and is optional. If the return type is not specified, then the compiler determines it from the final expression in the function body.

Parameters of a Function

You pst the names of parameters right after the function name. You can specify the type of a parameter. The type of the parameter should follow the name of the parameter separated by a colon.

If no parameter type is specified, it is inferred by the compiler.

For example −

let doubleIt (x : int) = 2 * x

Calpng a Function

A function is called by specifying the function name followed by a space and then any arguments separated by spaces.

For example −

let vol = cypnderVolume 3.0 5.0

The following programs illustrate the concepts.

Example 1

The following program calculates the volume of a cypnder when the radius and length are given as parameters

// the function calculates the volume of
// a cypnder with radius and length as parameters

let cypnderVolume radius length : float =

   // function body
   let pi = 3.14159
   length * pi * radius * radius

let vol = cypnderVolume 3.0 5.0
printfn " Volume: %g " vol

Volume: 141.372

// the function returns the larger value between two
// arguments

let max num1 num2 : int32 =
   // function body
   if(num1>num2)then
      num1
   else
      num2

let res = max 39 52
printfn " Max Value: %d " res

Max Value: 52

let doubleIt (x : int) = 2 * x
printfn "Double 19: %d" ( doubleIt(19))

Double 19: 38

//Recursive function definition
let rec function-name parameter-pst = recursive-function-body

let rec fib n = if n < 2 then 1 else fib (n - 1) &plus; fib (n - 2)

let rec fib n = if n < 2 then 1 else fib (n - 1) &plus; fib (n - 2)
for i = 1 to 10 do
   printfn "Fibonacci %d: %d" i (fib i)

Fibonacci 1: 1
Fibonacci 2: 2
Fibonacci 3: 3
Fibonacci 4: 5
Fibonacci 5: 8
Fibonacci 6: 13
Fibonacci 7: 21
Fibonacci 8: 34
Fibonacci 9: 55
Fibonacci 10: 89

open System
let rec fact x =
   if x < 1 then 1
   else x * fact (x - 1)
Console.WriteLine(fact 8)

40320

int -> string

let myspanfunction x y = (x / y).ToString();;

val myspanfunction : x:int -> y:int -> string

let applyFunction ( f: int -> int -> int) x y = f x y
let mul x y = x * y
let res = applyFunction mul 5 7
printfn "%d" res

35

let applyFunction ( f: int -> int -> int) x y = f x y
let res = applyFunction (fun x y -> x * y ) 5 7
printfn "%d" res

35

let function1 x = x + 1
let function2 x = x * 5

let f = function1 >> function2
let res = f 10
printfn "%d" res

55

let function1 x = x + 1
let function2 x = x * 5

let res = 10 |> function1 |> function2
printfn "%d" res

55