Back to Questions
795
views2
comments
When are generics not generic?
f#

Seems like the behavior of generic code is different depending on whether it's in a type or a module. In this code, can someone explain why BarWithChar and BarWithInt work together in a module, but not in a type?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

type GenericSunshineType =
  // Foo is generic
  static member Foo f s acc =
    List.fold_left f s acc

type SpecificSunshineType =
  static member Foo f s acc =
    List.fold_left f s acc

  // You can only include one of the 
  // functions BarWithChar or BarWithInt.
  // Either works on their own, but
  // you can't have both together.  And
  // once you include one of them, Foo
  // is no longer generic.
  static member BarWithChar() =
    SpecificSunshineType.Foo (fun s acc -> s) 'a' ['a']
    
//  static member BarWithInt() =
//    SpecificSunshine.Foo (fun s acc -> s) 1 [1]
    
module GenericSunshineModule =
  let Foo f s acc =
    List.fold_left f s acc

module SpecificSunshineModule =
  let Foo f s acc =
    List.fold_left f s acc
    
  // But in a module, you can have both
  // BarWithChar and BarWithInt, no 
  // problem.
  let BarWithChar() =
    Foo (fun s acc -> s) 'a' ['a']
    
  let BarWithInt() =
    Foo (fun s acc -> s) 1 [1]
    
//type GenericSunshineType =
//  class
//    static member Foo : f:('a0 -> 'a1 -> 'a0) -> ('a0 -> 'a1 list -> 'a0)
//  end
//type SpecificSunshineType =
//  class
//    static member BarWithChar : unit -> char
//    static member Foo : f:(char -> char -> char) -> (char -> char list -> char)
//  end
//module GenericSunshineModule = begin
//  val Foo : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
//end
//module SpecificSunshineModule = begin
//  val Foo : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
//  val BarWithChar : unit -> char
//  val BarWithInt : unit -> int
//end
//
.

The issue is F# and 'let rec' versus 'let'. 'member' functions are implicitly 'let rec'. I don't know enough of the language speci to point you at exactly why this happens, but the 'solution' is to be explicit (add generic type annotations) in the definition of Foo to force it to be generic.

By on 3/22/2009 2:45 PM ()

I believe that the answer is that the .NET type system makes inference a bit tricky due to subtleties like overloading, differences between functions taking no arguments and taking a single argument of type unit, etc. This means that type inference within types is a bit more limited than in modules. However, if you specify explicit types you can achieve the result that you want:

1
2
3
4
5
6
7
8
9

type SpecificSunshineType =
  static member Foo<'a,'b> (f:'a->'b->'a) (s:'a) (acc:'b list) : 'a =
    List.fold_left f s acc

  static member BarWithChar() =
    SpecificSunshineType.Foo (fun s acc -> s) 'a' ['a']
    
  static member BarWithInt() =
    SpecificSunshineType.Foo (fun s acc -> s) 1 [1]
By on 3/22/2009 2:01 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper