如何在函数参数中显式指定列表类型？F#笛卡尔积函数适配问题

Hey there! Let's sort out that type mismatch problem you're hitting with your cartesian product function. The root cause is that F#'s type inference system defaults to using int (which maps to .NET's Int32) for numeric operations like x * y unless told otherwise. To make your function work with Int64 lists (or even be more flexible for other numeric types), here are a few straightforward approaches:

1. Explicitly Annotate Parameter Types #

The most direct fix is to add type annotations to your function's parameters, specifying that they're int64 list (F#'s alias for Int64 lists):

let cartesian (xs: int64 list) (ys: int64 list) =
    xs |> List.collect (fun x -> ys |> List.map (fun y -> x * y))

By doing this, you're telling the compiler exactly what types xs and ys should be. The lambda parameters x and y will automatically inherit the int64 type, so the multiplication operation will use Int64 arithmetic instead of Int32.

2. Make the Function Generic (Support All Numeric Types) #

If you want your function to work with any numeric type that supports multiplication (not just Int64), you can define a generic function with a constraint for the multiplication operator:

let cartesian<'T when 'T : (static member ( * ) : 'T * 'T -> 'T)> (xs: 'T list) (ys: 'T list) =
    xs |> List.collect (fun x -> ys |> List.map (fun y -> x * y))

Now when you pass int64 lists to this function, F# will infer 'T as int64. You can also use it with int, float, or any other numeric type that implements the * operator.

3. Annotate Lambda Parameters (Alternative Approach) #

Another option is to add a type annotation directly to one of the lambda parameters. This will hint to the compiler what type the lists should be:

let cartesian xs ys =
    xs |> List.collect (fun (x: int64) -> ys |> List.map (fun y -> x * y))

Since x is explicitly marked as int64, the compiler will infer that xs is an int64 list, and ys must also be an int64 list (because y needs to multiply with x).

Quick Test Example #

Once you've updated the function, you can test it with Int64 lists like this:

let int64List1 = [1L; 2L; 3L]
let int64List2 = [4L; 5L]
let result = cartesian int64List1 int64List2
// Result will be [4L; 5L; 8L; 10L; 12L; 15L]

内容的提问来源于stack exchange，提问作者Mike Henderson