Question

I keep running into the following problem:

(System.Console.ReadLine ()).Split [|'('; ')'|]
|> Array.filter (fun s -> not (System.String.IsNullOrEmpty (s)))
|> Array.map (fun s -> s.Split [|','|])
|> Array.map (fun s -> Array.map (fun t -> t.Trim ()) s) (* t.Trim () is underlined with a red squiggly line *)
|> [MORE CODE]

The error associated with the red squiggly line is:

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.

But when the mouse pointer hovers over t, IntelliSense correctly says that t is of type string.

I can bypass the error by writing fun (t : string) -> [CODE], but I wonder why Visual Studio draws the squiggly line at all when it is already detecting the type of the variable correctly. Is this a simple bug in the trial build, or am I misunderstanding something about F#’s type inferencing?

Thanks in advance for your responses.

Answer 1

There is some gap between F# intellisense and F# type checker.

The type checker works from left to right in order. Your problem can be fixed be changing:

fun s -> Array.map (fun t -> t.Trim()) s

to

fun s -> s |> Array.map (fun t -> t.Trim())

Since type of s is available before using Array.map, the type checker is able to infer type of t.

Remarks:

This error usually occurs when using instance methods. You could replace these methods by static functions with extra type annotation and refactor to make your code more composable:

let split arr (s: string) = s.Split arr
let trim (s: string) = s.Trim()

System.Console.ReadLine()
|> split [|'('; ')'|]
|> Array.filter (not << System.String.IsNullOrEmpty)
|> Array.map (split [|','|])
|> Array.map (Array.map trim)