type MergeWithLazyLists() =
  static member merge(f, x: LazyList, y: LazyList) =
    seq {
      match x, y with
      | LazyList.Cons(xh, xt), LazyList.Cons(yh, yt) when f xh yh ->
        yield xh
        yield! MergeWithLazyLists.merge(f, xt, y)
      | LazyList.Cons(xh, xt), LazyList.Cons(yh, yt) ->
        yield yh
        yield! MergeWithLazyLists.merge(f, x, yt)
      | LazyList.Nil, LazyList.Cons(_, _) -> yield! y
      | LazyList.Cons(_, _), LazyList.Nil -> yield! x
      | LazyList.Nil, LazyList.Nil -> ()
    }

  []
  static member merge(f, x: seq, y: seq) =
    MergeWithLazyLists.merge(f, (LazyList.of_seq x), (LazyList.of_seq y))

let result = MergeWithLazyLists.merge((fun x y -> x < y), (seq {2..6}), (seq {1..7..15}))

printfn "%A" (Seq.to_array result)
// [|1; 2; 3; 4; 5; 6; 8; 15|]

let ms (a1:'a[]) (a2:'a[]) =
 let rec _ms l1 l2 acc =
  match (l1,l2) with
   | ([],[]) -> acc
   | (x::[],[]) -> x::acc
   | (x::xs,[]) -> _ms xs [] (x::acc)
   | ([],y::[]) -> y::acc
   | ([],y::ys) -> _ms [] ys (y::acc)
   | (x::xs,y::ys) ->
     if x < y then
      _ms xs l2 (x::acc)
     else
      _ms l1 ys (y::acc)

 List.to_array (List.rev (_ms (Array.to_list a1) (Array.to_list a2) []))

I added the tags in your comments for you.

let merge_array (a:'a array) b =
....let (|Empty|Head_Rest|) (a:'a array,ai) =
........if ai <a> b
........| _ ->
............System.Array.Copy(a,ai,b,bi,a.Length - ai)
............b
....let append a (c:'a array,ci) =
........c.[ci]   copyToEnd b c
........| a,Empty -> copyToEnd a c
........| Head_Rest(ah,ar),Head_Rest(bh,br) ->
............if ah  append ah |> merge ar b
............else
................c |> append bh |> merge a br
....merge (a,0) (b,0) ((Array.create (a.Length+b.Length) Microsoft.FSharp.Core.Operators.Unchecked.defaultof),0)

how do you post code nicely here?

Quite the contrary. This is a problem of non-FP. Specifically, the lack of controlled side-effects introduces the need for strict evaluation, which is the problem. If F# were more functional, then the problem of evaluation could be eschewed more easily.

let MergeSortedArrays (a:array<_>) (b:array<_>) =
    let al, bl = a.Length, b.Length
    let r = Array.zeroCreate (al+bl)
    let ri = ref 0
    let inline Yield x = r.[!ri] <- x; incr ri
    let rec Merge ai bi =
        if not(ai >= al && bi >= bl) then
            if bi >= bl || ai < al && a.[ai] < b.[bi] then
                Yield a.[ai]
                Merge (ai+1) bi
            else
                Yield b.[bi]
                Merge ai (bi+1)
    Merge 0 0
    r

// some tests
printfn "%A" ([|1..6|] = MergeSortedArrays [|1..4|] [|5;6|])
printfn "%A" ([|1..6|] = MergeSortedArrays [|5;6|] [|1..4|])

let N = 40000
let a1 = Array.init N (fun x -> 2 * x + 1)  // 1, 3, 5, ...
let a2 = Array.init N (fun x -> 2 * x)  // 0, 2, 4, ...
let r = MergeSortedArrays a1 a2
let expected = [| 0..2*N-1 |]
printfn "%A" (r = expected)

I would suggest do a reverse(may be double reverse) and stick to ‘::’, as ‘@’ is a very expensive operation.

@gary: a tail recursive version follows, as usual I find the original version easier to understand and therefore better suited for a didactic post.

let tail_merge_arrays a b =
  let rec merge c d acc =
    match (c, d) with
    | ([], []) -> acc
    | (c, []) -> acc @ c
    | ([], d) -> acc @ d
    | (x::xs, y::ys) ->  if (x < y) then
                            merge xs (y::ys) (acc @ [x])
                         else
                            merge (x::xs) ys (acc @ [y])
  merge a b []

Either it needs to be transformed to a tail call format or use the Lazy library or the ‘yield’ construct.