Deciphering compiler error for binding tuple values - f#

Question

For
subs
|> Array.map (fun x ->
let t, s, _ = x
getAuditEventsAsync s t (now - TimeSpan.FromDays(7.0)) now)
the compiler says for t when applying getAuditEventsAsync:
The type 'string' does not match the type 'string * string'
getAuditEventsAsync is a string -> string -> DateTime -> DateTime -> Async<string> and t and s are strings.
Any hints on why the compiler think I'm attempting to bind a string to a tuple of strings?
Update:
The root cause was actually in getAuditEventsAsync which does
async {
return! Http.AsyncRequestString
( url, httpMethod="GET",
headers = [ Accept HttpContentTypes.Json;
Authorization "Bearer " + t ])
}
for some url and token t where both are strings.
Operator precedence means that Authorization "Bearer " + t is interpreted as (Authorization "Bearer ") + t. Authorization returns string * string, (a non-overloaded) + is thus applied to a string * string and string which confuses the compiler.
The solution was to change Authorization "Bearer " + t to Authorization ("Bearer " + t).
So the question is now: why is the compiler error thrown at the application of getAuditEventsAsync rather than Authorization? :)

Answer 1

Here is a minimal example giving the same error message:
let Accept a = "Accept", a
let foo x = Accept "hoo" + x
foo "z"
The compiler and editor report two error messages, but (for some reason unclear to me) F# Interactive reports only the one you were getting. One of the errors is for + inside foo and the other is when calling foo.
If you comment out the last line, you get just one error on +:
error FS0071: Type constraint mismatch when applying the default type '(string * string)' for a type inference variable. Expecting a type supporting the operator '+' but given a tuple type Consider adding further type constraints
This makes sense and it says that + cannot be applied to tuples. Now, the compiler uses some defaulting mechanism so that it can continue type-checking and it decides that the argument of foo is also string * string. This then gives you the later error message when calling foo:
error FS0001: The type 'string' does not match the type 'string * string'
The confusing thing is that when you uncomment the last line again, the error message for the body of foo also changes to:
error FS0001: The type 'string' does not match the type 'string * string'
This is happening because the compiler now sees that foo is called with string as an argument and so the default guess x : string * string is replaced with x : string. I think this only affects the first error message though and so the second one still uses the default guess that foo takes string * string.
This is not entirely sensible behavior, but I guess that's the best the compiler can do given code with multiple errors - it has to use some default resolution for the error.