Back to Questions
2.7k
views2
comments
Statically resolved type variables don't work with extension methods
f#extension methods

I have been trying to work out an easier way to accomplish the same idea as monoids but bypassing the entire construct. It struck me that this shouldn't be that difficult. In fact, using inlines and statically resolved type variables would be really easy if only each type had the appropriate methods. Unfortunately, they don't always. So I attempted to use F# extension methods to add on those missing methods.

From FSI:

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

> type Duck() =
  member x.Speak(y) = sprintf "I'm a %A that says \"%s\"" x y;;

type Duck =
  class
    new : unit -> Duck
    member Speak : y:string -> string
  end

> let d = new Duck();;

val d : Duck

> d.Speak("quack");;
val it : string = "I'm a FSI_0022+Duck that says "quack""
> let inline speak (x: ^a) y = (^a : (member Speak: string -> string) (x, y));;

val inline speak :
   ^a -> string -> string when  ^a : (member Speak :  ^a * string -> string)

> speak d "quack";;
val it : string = "I'm a FSI_0022+Duck that says "quack""
> type Duck with
  member x.Talk(y) = sprintf "I'm a %A that now says \"%s\"" x y;;

type Duck with
  member Talk : y:string -> string

> d.Talk("quack");;
val it : string = "I'm a FSI_0022+Duck that now says "quack""
> let inline talk (x: ^a) y = (^a : (member Talk : string -> string) (x, y));;

val inline talk :
   ^a -> string -> string when  ^a : (member Talk :  ^a * string -> string)

> talk d "quack";;

  talk d "quack";;
  -----^

stdin(38,6): error FS0001: The type 'Duck' does not support any operators named 'Talk'

Clearly, extension methods don't get me what I want. I realize that extension methods work differently than just rewiring the existing type, but is it possible to achieve this same effect in F# today? If not, what about F# 3.0? The ability to extend a type and then use that extension within statically resolved inline functions would be a huge help.

My current solutions today are to blow up my api to pass in a "Monoid" type (ugh) or copy entire sets of module functions to work with any unique set type.

My real goal is something of this sort (from a local copy of the FSharpx project):

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

namespace FSharpx

module Monoid =

    let inline mempty (x: ^a) = (^a : (member Empty : 'a) x)
    let inline mappend (x: ^a) y = (^a : (member Append : 'a -> 'a) (x,y))
    let inline mconcat (x: ^a) y = Seq.fold mappend (mempty x) y

    type IMonoid<'a> =
        abstract Empty : 'a
        abstract Append : 'a -> 'a

    /// List monoid
    type ListMonoid<'a> = ListMonoid of 'a list
        with
        interface IMonoid<ListMonoid<'a>> with
            member x.Empty = ListMonoid []
            member x.Append (ListMonoid y) = let (ListMonoid x') = x in ListMonoid(x' @ y)

    /// Option wrapper monoid
    type OptionMonoid<'a when 'a :> IMonoid<'a>> = OptionMonoid of 'a option
        with
        interface IMonoid<OptionMonoid<'a>> with
            member x.Empty = OptionMonoid None
            member x.Append(OptionMonoid y) =
                let (OptionMonoid x') = x
                OptionMonoid <|
                    match x',y with
                    | Some a, Some b -> Some (a.Append b)
                    | Some a, None   -> Some a
                    | None,   Some a -> Some a
                    | None,   None   -> None

    /// Monoid (int,0,+)
    type IntSumMonoid = IntSumMonoid of int
        with
        interface IMonoid<IntSumMonoid> with
            member x.Empty = IntSumMonoid 0
            member x.Append (IntSumMonoid y) =
                let (IntSumMonoid x') = x in IntSumMonoid (x' + y)

    /// Monoid (int,1,*)
    type IntProductMonoid = IntProductMonoid of int
        with
        interface IMonoid<IntProductMonoid> with
            member x.Empty = IntProductMonoid 1
            member x.Append(IntProductMonoid y) =
                let (IntProductMonoid x') = x in IntProductMonoid (x' * y)

This compiles, but it's ugly, and I haven't gotten it to actually work. Also, the fact that I now have a wrapped type is really annoying. I really just want to add Append to Option or List. I also tried a static member variation:

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

namespace FSharpx

module Monoid =

    let inline mempty (x: ^a) = (^a : (static member op_Nil : unit -> 'a) ())
    let inline mappend (x: ^a) y = (^a : (static member op_Append : 'a -> 'a -> 'a) (x, y))
    let inline mconcat (x: ^a) y = Seq.fold mappend (mempty x) y

    /// List monoid
    type ListMonoid<'a> = ListMonoid of 'a list with
        static member op_Nil() = ListMonoid []
        static member op_Append(ListMonoid(a), ListMonoid(b)) = ListMonoid(a @ b)

    /// Option wrapper monoid
    type OptionMonoid<'a> = OptionMonoid of 'a option with
        static member op_Nil() = OptionMonoid None
        static member op_Append(a, b) =
            OptionMonoid <|
                match a, b with
                | Some a', Some b' -> Some (mappend a' b') // Oh no! mappend can't handle this!
                | Some a', None    -> Some a'
                | None, Some a'    -> Some a'
                | None, None       -> None

    /// Monoid (int,0,+)
    type IntSumMonoid = IntSumMonoid of int with
        static member op_Nil() = IntSumMonoid 0
        static member op_Append(a,b) = IntSumMonoid(a + b)

    /// Monoid (int,1,*)
    type IntProductMonoid = IntProductMonoid of int with
        static member op_Nil() = IntProductMonoid 1
        static member op_Append(a,b) = IntProductMonoid(a * b)

Any thoughts on a way to do this? (This latter version doesn't compile, by the way.)

.

I see no type-safe way to do this elegantly in .NET or in F#.

I at least chose the redundant way, where I have a fairly large F# library which contains lots of useful extensions to the F# modules (among them, Option.append), and I added a reference to this library in all my (new) F# projects.

Yes, you need to write lots of code, and sometimes copy-paste code and then edit, but you do it only once.

By on 10/27/2011 11:05 AM ()

Hi Ramon, I invite you to contribute your extensions to FSharpx.

It's obvious by now that the F# std lib, even with PowerPack, is simply too basic for many applications. As a community, we need to stop writing ad-hoc snippets and pool our efforts to create a true quality base library we can all agree upon. Otherwise F# will never really take off.

Cheers,
Mauricio

By on 10/27/2011 3:26 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