Possible F# type inference limitation
===

I'm quite sure that I run into some kind of limitation, but I do not understand it:

    type IRunner = 
        abstract member Run : (string -> 'a) -> 'a
    type T() = 
        let run4 doFun = doFun "4"
        let run5 doFun = doFun "5"
        let parseInt s = System.Int32.Parse(s)
        let parseFloat s = System.Double.Parse(s)
        let doSomething () = 
            let i = parseInt |> run4
            let f = parseFloat |> run4
            f |> ignore

        // Make it more generic ->
        //let doSomething2 (runner:(string->'a)->'b) =
        let doSomething2 runner = 
            // Error on the following lines with both declarations
            let i = parseInt |> runner
            let f = parseFloat |> runner
            f |> ignore

        // Want to do something like
        let test () = 
            doSomething2 run4
            doSomething2 run5

        // Workaround
        let workaround (runner:IRunner) = 
            let run f = runner.Run f
            let i = parseInt |> run
            let f = parseFloat |> run
            f |> ignore

Can somebody bring some light over this? I did not find any related question, sorry if i duplicated something.