Why is this F# code so slow?

Question

A Levenshtein implementation in C# and F#. The C# version is 10 times faster for two strings of about 1500 chars. C#: 69 ms, F# 867 ms. Why? As far as I can tell, they do the exact same thing? Doesn't matter if it is a Release or a Debug build. EDIT: If anyone comes here looking specifically for the Edit Distance implementation, it is broken. Working code is here. C#: ``` private static int min3(int a, int b, int c) { return Math.Min(Math.Min(a, b), c); } public static int EditDistance(string m, string n) { var d1 = new int[n.Length]; for (int x = 0; x < d1.Length; x++) d1[x] = x; var d0 = new int[n.Length]; for(int i = 1; i < m.Length; i++) { d0[0] = i; var ui = m[i]; for (int j = 1; j < n.Length; j++ ) { d0[j] = 1 + min3(d1[j], d0[j - 1], d1[j - 1] + (ui == n[j] ? -1 : 0)); } Array.Copy(d0, d1, d1.Length); } return d0[n.Length - 1]; } ``` F#: ``` let min3(a, b, c) = min a (min b c) let levenshtein (m:string) (n:string) = let d1 = Array.init n.Length id let d0 = Array.create n.Length…

Accepted Answer

The problem is that the `min3` function is compiled as a generic function that uses generic comparison (I thought this uses just `IComparable`, but it is actually more complicated - it would use structural comparison for F# types and it's fairly complex logic).

```
> let min3(a, b, c) = min a (min b c);;
val min3 : 'a * 'a * 'a -> 'a when 'a : comparison
```

In the C# version, the function is not generic (it just takes `int`). You can improve the F# version by adding type annotations (to get the same thing as in C#):

```
let min3(a:int, b, c) = min a (min b c)
```

...or by making `min3` as `inline` (in which case, it will be specialized to `int` when used):

```
let inline min3(a, b, c) = min a (min b c);;
```

For a random string `str` of length 300, I get the following numbers:

```
> levenshtein str ("foo" + str);;
Real: 00:00:03.938, CPU: 00:00:03.900, GC gen0: 275, gen1: 1, gen2: 0
val it : int = 3

> levenshtein_inlined str ("foo" + str);;
Real: 00:00:00.068, CPU: 00:00:00.078, GC gen0: 0, gen1: 0, gen2: 0
val it : int = 3
```

Why is this F# code so slow?

Solution

Problem