From OCaml to F# -> type inference

• Wednesday, May 01, 2013 6:52 AM

   

   
  

  1

  Hi,

  A couple of years ago, I wrote a compiler in OCaml for a very large subset of the Java programming language. I enjoyed using OCaml and IMO it is a perfect language for writing compilers in.

  However, lately I have begun giving F# a go since it can be considered a successor to OCaml, and enjoys interop with the .NET platform. I have however found some errors that makes me wonder if the type inference system in F# is that much different. for instance:

  let convertStrToIntArray (s:(int * string) list) =          
      let rec convert input = //(input:(int * string) list) =
          match input with
          | (count, freqs) :: rest ->
              let freqsArr = freqs.Split ';' 
              let freqsIntArr = Array.map (fun freq ->
                  match Int32.TryParse freq with
                  | (true, result) -> result
                  | (false,_) -> -1) freqsArr
              (count, freqsIntArr) :: convert rest
          | [] -> []
      convert s

   

  The above code generates the following error at the freqs.Split function: 

  "Error 1 Lookup on object of indeterminate type based on information prior to this program point. A type annotation may be needed prior to this program point to constrain the type of the object. This may allow the lookup to be resolved."

  how is that possible? If I hover over s in the last line where the recursive function it says (int * string) list as it's type. AFAIK OCaml would easily infer the right types in this circumstance.

  However if I change the code to the following:

  let convertStrToIntArray s = //(s:(int * string) list) =          
      let rec convert (input:(int * string) list) =
          match input with
          | (count, freqs) :: rest ->
              let freqsArr = freqs.Split ';' 
              let freqsIntArr = Array.map (fun freq ->
                  match Int32.TryParse freq with
                  | (true, result) -> result
                  | (false,_) -> -1) freqsArr
              (count, freqsIntArr) :: convert rest
          | [] -> []
      convert s

   Such that the type (int * string) list is typed at the recursive part, then it does not generate any errors.

  Why does one need to type the types directly in the recursive function, rather than in the outer function argument?

  
  

  • Reply
  • Quote