Question

I have some Run Length Encoding code that I wrote as an exercise

let rle s = 
    s
    |> List.map (fun x -> (x, 1))
    |> List.fold (fun acc x -> 
        match acc with 
            | [] -> [(x, 1)]
            | h::(x, n) -> h::(x, n+1)
            | h -> h::(x, 1)
        )
    |> List.map (fun (x, n) -> 
        match n with
            | 1 -> x.ToString()
            | _ -> x.ToString() + n.ToString()
        )

The pattern h::(x, n) -> h::(x, n+1) fails to compile.

Does anyone know why?

Answer 1

It can’t compile because the second argument for :: pattern match must be a list, but here it is a tuple. In general, you seem to just misunderstand head and tail. Head is the top element while tail is a list of following elements. Essentially swapping them does the trick:

|> List.fold (fun acc x -> 
    match acc with 
        | [] -> [(x, 1)]
        | (x0, n)::t when x0=x -> (x0, n+1)::t
        | t -> (x, 1)::t
    )
    []

Note 1: As @pad noticed, List.fold requires one more argument, a “bootstrap” accumulator to start with. Obviously, it should be just an empty list, [].
Note 2: you can’t directly match x. Instead, you bind it to x0 and compare x0 with x.
Note 3: matching empty list [] is not necessary as it would happily work with the last pattern.