Here's another choice - convert the list into a Set then convert it back:

1

 let uniq a = a |> Set.of_list |> List.of_seq 

You can even leave the result as a Set, then treat it as a sequence (seq<'a>) for an even shorter solution:

1
2
3
4
5

let uniq = Set.of_list


let a = [ 1; 1; 1; 1; 3; 3; 4; 4; 8; 9; 11; 11; 11 ];
let b = a |> uniq;

> b;;
val it : Set<int> = seq [1; 3; 4; 8; ...]
>

Hi,
implementing this by sorting the data and then using something like "uniq" is definitely possible. As far as I know there is nothing like "uniq" available in F#, but it is not so difficult to implement.

So, the first thing is to create a list and to sort it:

1
2
3

 
let a = [ 1; 11; 9; 1; 1; 3; 4; 8; 11; ]
a |> List.sort compare

The "|>" operator in F# does pipelining, so it calls the thing on the right side with the thing on the left side as an argument. The first argument of the sort function is a comparison function, which compares the elements - here we can use generic "compare" function which works on most of the standard F# types.

Implementing the "uniq" will be slightly more difficult - since we have the list sorted already, we can walk through the list and remember the last processed element - we will then check whether the current element is different and skip the element if it was already added to the resulting list. You can implement this (using pattern matching :-) ) as a primitive recursive function:

1
2
3
4
5
6
7

let rec uniq' lst res last =
  match lst with
  | [] -> res
  | h::tl when h=last -> uniq tl res last
  | h::tl -> uniq tl (h::res) h

let uniq lst = (uniq' lst [] -1) |> List.rev

The function takes the input list as a first argument, currently collected resulting list as a second one and last processed value as a third argument. Since we're adding the elements to the beginning of the "res" list, it will reverse the list, so it calls "List.rev" when it completes to reverse it once again (to the original ordering).

It is also possible to implement the same thing using "fold_left" function, which "remembers" the state while walking through the list and allows you to modify the state when processing each element. Here the state will be a tuple which contains last element ("st") and the result created so far ("lst") and when processing the element it either adds it to the resulting list or returns the original. The initial state that we'll give to the fold_left is -1 (some special value) and empty list (the result collected so far).

1
2
3
4
5

 
sorted 
  |> List.fold_left (fun (st,lst) a -> if st = a then (st,lst) else (a,a::lst)) (-1, []) 
  |> snd
  |> List.rev

The call to "snd" at the end drops the first element from the tuple, so we get just the resulting list and finally, "List.rev" reverses the list - similarly to the previous implementation.

Hope this helps!