InsertSort F# program I have written this InsertSort program in F#.  It works, but I am not very happy with it.

let rec SubArrayBegin list n =
    list |&gt; Seq.ofList |&gt; Seq.take n |&gt; List.ofSeq

let SubArrayEnd list n =     
    List.rev (SubArrayBegin (List.rev list) ((List.length list) - n - 1))

let InsertSort list = 
    let rec innerInsertSort list n = 
        if n = (List.length list) then
            list
        else
            let key = List.nth list n
            let firstList = SubArrayBegin list n
            let (firstListA, firstListB) = List.partition (fun x -&gt; x &lt; key) firstList
            let remList = SubArrayEnd list n
            innerInsertSort (firstListA @ [key] @ firstListB @ remList) (n + 1)
    innerInsertSort list 1


[&lt;EntryPoint&gt;]
let main args = 
    let a = [10; 2; 9; 1; 4; 5; -1]
    let b = InsertSort a
    List.iter (fun x -&gt; printfn "%i" x) b
    0


List of annoyances:


@ symbol for joining the lists back.
If Condition being used instead of pattern matching. 


I wonder if there is a better way of writing this.

Can you please review this and help me improve this code?
Function names in F# are usually written in camelCase. (Though members that are not private should use PascalCase, to adhere to general .Net naming conventions.)
SubArrayBegin is not recursive, so it doesn't need to be rec.
List implements Seq, so you don't need that Seq.ofList.
Collection manipulation functions usually have that collection as the last parameter, so that you can use them with |&gt;.
Your implementation of SubArrayEnd is pretty complicated and inefficient. Instead, you could write it for example like this:

let rec subArrayEnd n list =
    match (n, list) with
    | 0, _ | _, [] -&gt; list
    | _ -&gt; subArrayEnd (n-1) (List.tail list)

There is no reason why your innerInsertSort has to follow the normal imperative version of insert sort so closely and operate on a single list (and use List.nth). Instead, you could have two collections: one where you take from using pattern matching and one where you insert using List.partition and @.
Alternatively, you could use ImmutableList from Microsoft.Bcl.Immutable instead of List for the collection you're inserting into. With that, you can insert into the middle in O(log n) and you can also find the index to insert to in O(log n) using binary search. So it will make your code simpler and also much faster.