Define symbolic operators with F#

This post describes how we can define a custom operator with F#. Defining a new operator in F# is very straightforward. For instance, by using the following code, we can define “!” as an operator to compute factorial of an integer.

let rec (!) n =
match n with
| 1 -> (1)
| n -> n*(n-1)
view raw sym_op.fs hosted with ❤ by GitHub

Running the following command in the interactive F# console computes the factorial for 10.

> !10;; 
val it : int = 3628800 
>

A symbolic operator can use any sequence of the following characters: ! % & * + - . / ? @ ^ |~. Note that, “:” can also be used in the character sequence of symbolic operation if and only if, it is not the first character in the operator.

Following is an example of modulo operator defined using F#:

let rec (|%|) a n =
match a, n with
|_ when a < n -> a
|_ when a>=n -> (|%|) (a-n) n
//Resulting signature: val ( |%| ) : int -> int -> int
view raw modulo.fs hosted with ❤ by GitHub

Following outputs shows how to use it from F# interactive shell.

> 23 |%| 3;;
val it : int = 2
> 3 |%| 3;;
val it : int = 0
>

Eclipse PDE | Get all the Projects available in current Workspace

This post quickly describes how to get the list of projects available in the current Eclipse workspace. Eclipse PDE’s API provides the functionalities to query different meta-data relevant to the current Eclipse workspace. Using following code snippet, all the projects of the current workspace can be retrieved as an array of IProject …

Eclipse PDE’s API provides various functionalities to query different meta-data relevant to the currently active Eclipse workspace. Using following code snippet, all the projects of the current workspace can be retrieved as an array of IProject :

IProject[] allProjects = ResourcesPlugin.getWorkspace()
.getRoot()
.getProjects();
view raw gistfile1.java hosted with ❤ by GitHub

Further processing on this array can be performed e.g., to filter only open projects, as follows :

for (IProject p : allProjects){
if(p.isOpen())
activeProjects.add(p);
}
view raw gistfile1.java hosted with ❤ by GitHub

F# | Length of a List

The code snippets listed below defines a function to compute the length of a give list using F#. Note that these functions are also called polymorphic function, as they work with any type of list (as shown in the output).

// naive implementation
let rec length list =
match list with
| [] -> 0
| _::tail -> 1 + computeLength tail
view raw gistfile1.fs hosted with ❤ by GitHub

A tail recursive implementation is outlined next.

// Tail recursive computation of List's length
let length list =
// Auxiliary function to compute length
// It store intermediate result in acc.
let rec lengthAux acc list =
match list with
| [] -> acc
| _::tail -> lengthAux (acc+1) tail
lengthAux 0 list // invoking lengthAux with acc = 0
view raw gistfile1.fs hosted with ❤ by GitHub

Following is a more succinct implementation using List.Fold.

let length list =
List.fold
(fun acc _ -> acc+1)
0
list
view raw length.fs hosted with ❤ by GitHub

Output:

> length [];;
val it : int = 0
> length [1;2;3;4];;
val it : int = 4
> length ['a';'b'];;
val it : int = 2