Accessing the first elements in a list of Lists [F#]

Question

I'm currently interested in F# as it is different to everything I have used before. I need to access the first element of each list contained within a large list. If I assume that the main list contains 'x' amount of lists that themselves contain 5 elements, what would be the easiest way to access each of the first elements.

let listOfLists = [ [1;2;3;4;5]; [6;7;8;9;10]; [11;12;13;14;15] ]

My desired output would be a new list containing [1;6;11]

Currently I have

let rec firstElements list  =
    match list with
    | list[head::tail] -> 
        match head with
        | [head::tail] -> 1st @ head then firstElements tail

To then expand on that, how would I then get all of the second elements? Would it be best to create new lists without the first elements (by removing them using a similar function) and then reusing this same function?

Answer 1

You can use map to extract the head element of each child list:

let firstElements li =
  match li with [] -> None | h::_ -> Some h

let myfirstElements = List.map firstElements listOfLists

I'm using Ocaml's speak with little lookup on F# so this may be inaccurate, but the idea applies.

EDIT : You can also use List.head which makes it more concise and will return a int list instead of int option list . However, it throws an exception if you hits an empty list. Most of the time, I'd avoid using List.head or List.tail in this case.

Answer 2

The easisest way to access the first element in a list is List.head . As you have a list of lists, you just need to List.map this function:

let listOfLists = [ [1;2;3;4;5]; [6;7;8;9;10]; [11;12;13;14;15] ]

listOfLists 
|> List.map List.head
//val it : int list = [1; 6; 11]

Now if you need to access other elements, you can use List.item or just index into your list with xs.[1] . But please keep in mind, that for large lists this will be inefficient and if you want fast look up use an array.

listOfLists
|> List.map (List.item 1)
//val it : int list = [2; 7; 12]

With indexing:

listOfLists
|> List.map (fun x -> x.[1])