F# 模块中的通用值？

Question

Consider a generic container like:

type Foo<'t> = 
  {
    Foo : 't
  }

This generic function works OK:

module Foo = 
  
  let inline emptyFoo () = 
    {
      Foo = LanguagePrimitives.GenericZero
    }

But this value does not:

module Foo = 
  
  let emptyFoo = 
    {
      Foo = LanguagePrimitives.GenericZero
    }

This is because the compiler infers emptyFoo to have type Foo<obj> .

However, the standard library has generic values like List.empty , so how is that achieved there?

Answer 1

You have to make it explicitly generic.

List.empty is implemented like this :

let empty<'T> = ([ ] : 'T list)

Answer 2

You could implement a List by yourself, with an empty. It looks like this.

type L<'a> =
    | Null
    | Cons of 'a * L<'a>

module L =
    let empty = Null

let xs = Cons(1,  Cons(2,  L.empty))
let ys = Cons(1.0,Cons(2.0,L.empty))

So, why does L.empty in this case works in a generic way? Because the value Null has no special value attached to it. You could say, it is compatible with every other generic.

In your Record on the other hand, you always must produce a value. LanguagePrimitive.GenericZero is not some Generic value. It help so to resolve to a special zero value, and this value is determined by the other code you write.

For example

let x = LanguagePrimitives.GenericZero

is also obj

let x = LanguagePrimitives.GenericZero + 1

will be int . And

let x = LanguagePrimitives.GenericZero + 1.0

will be float . So in some case you can think of GenericZero just as a placeholder for zero for the special type you need, but the code needs to determine at this point, which type you want.

You could change your type, with an option to provide a real empty.

type Foo<'t> = {
    Foo: 't option
}

module Foo =
    let empty = { Foo = None }

let x = Foo.empty                  // Foo<'a>
let y = { x with Foo = Some 1   }  // Foo<int>
let z = { x with Foo = Some 1.0 }  // Foo<float>