Hi.

In many situations when I design interfaces I also provide a default implementation. Then I inherit from the default implementation and override the behavior when needed.

All is well.

But then I would like to implement multiple interfaces but .NET only supports single inheritance (for good reasons).

One solution is to create a member variable that holds the default implementation and I then forward the calls manually to the default implementation.

But why shouldn't the language help me with that? In F# I would imagine this could look like this:

#light

// ---------------------------------------------------------------
// Simple interface
type IPeekPoke = interface
abstract member Peek: unit -> int
abstract member Poke: int -> unit
end

// ---------------------------------------------------------------
// Default implementation
type A = class
val mutable state: int
interface IPeekPoke with
member x.Poke(n) = x.state <- x.state + n
member x.Peek() = x.state
end
member x.HasBeenPoked = (x.state <> 0)
new() = { state = 0 }
end

// ---------------------------------------------------------------
// implementation forward IPeekPoke calls to state
type B = class
val state: A
interface IPeekPoke with state
end
new() = { state = new A() }
end

// ---------------------------------------------------------------
// implementation forward IPeekPoke to state but "overloads" Poke
type C = class
val mutable poke_call_count: int
val state: A
interface IPeekPoke with state
member x.Poke(n) =
x.poke_call_count <- x.poke_call_count + 1
x.state.Poke(n)
end
member x.PokeCallCount = x.poke_call_count
new() = { state = new A() }
end

This way I could implement multiple interfaces and have automatic forwarding to member variables (holding the implementations) for convenience.

It would not require multiple inheritance.

It would increase encapsulation as I don't tell how I implement the interface (if I inherit a base class that does the implementation the type give away implemenation details).

It would not mix implementation and interface (a problem with classic OO imo).

To me this would actually be a big deal as I missed this language feature for many years and I hope I'm clear enough that more people can see the benefits. I also think that it would fit well in the F# language.

Regards,

Mårten