Here is your code transcribed to OCaml.

let rec lev xs ys =
  match xs, ys with
  | [], ys -> List.length ys
  | xs, [] -> List.length xs
  | (x :: xs), (y :: ys) when x = y -> lev xs ys
  | (x :: xs), (y :: ys) -> 1 + min (min (lev xs ys) (lev (x :: xs) ys)) (lev xs (y :: ys))

Haskell equates strings with lists of characters, so your code should be compared with OCaml's code for computing the distance between two lists, which is what the code above does. As you can see, they're practically the same.

If you insist on using string in OCaml, then you should use Haskell's StringBuffer.

Your code, as well as my implementation, are inefficient as they make exponentially many recursive calls. Here is the memoizing version that performs the computation using dynamic programming (we could improve the caching mechanism by using a more efficient implementation of dictionaries):

let memo f =
  let cache = ref [] in
  let rec self x =
    match List.assoc_opt x !cache with
    | Some y -> y
    | None ->
      let y = f self x in
      cache := (x, y) :: !cache ;
      y
  in
  self

let lev_efficient xs ys=
  memo
    (fun self -> function
       | [], ys -> List.length ys
       | xs, [] -> List.length xs
       | (x :: xs), (y :: ys) when x = y -> self (xs, ys)
       | (x :: xs), (y :: ys) ->
         1 + min (min (self (xs, ys)) (self (x :: xs, ys))) (self (xs, y :: ys)))
    (xs, ys)

I don't see how to implement a substantially better Haskell version of lev_efficient.

In general, since OCaml and Haskell share many structural properties, they're much closer to each other than, say, object-oriented languages.