Overloading + operator in F#

Question

So i have this:

open System
open System.Linq
open Microsoft.FSharp.Collections
type Microsoft.FSharp.Collections.List<\'a> with
    static member (+) (         


        

Answer 1

As pointed out by the other answers, you cannot add implementation of + to an existing type, because extension members are ignored and standalone let binding hides the default (overloaded) implementation.

If you wanted to use + (which is not really needed because F# library contains operator @), you would have to write wrapper for F# list that supports the operator directly:

open System.Collections
open System.Collections.Generic

/// Wrapper for F# list that exposes '+' operator and 
/// implements 'IEnumerable<_>' in order to work with 'for'
type PlusList<'T>(list : list<'T>) =
  member x.List = list
  static member (+) (first : PlusList<'a>, second : PlusList<'a>) =
    first.List @ second.List
  interface IEnumerable with
    member x.GetEnumerator() = (list :> IEnumerable).GetEnumerator()
  interface IEnumerable<'T> with
    member x.GetEnumerator() = (list :> IEnumerable<_>).GetEnumerator()

// Simple function to wrap list
let pl l = PlusList<_>(l)

let a = pl [1; 2; 3; 4; 54; 9]
let b = pl [3; 5; 6; 4; 54]

for x in a + b do
  System.Console.WriteLine(x)

Answer 2

First, overriding operators should be declared in the tuple form, not in the carried form. In your case:

type Microsoft.FSharp.Collections.List<'a> with
    static member (+) (first: List<'a>, second: List<'a>) =
        first.Concat(second)

Second, after you fix that, the compiler raises the "Extension members cannot provide operator overloads. Consider defining the operator as part of the type definition instead." warning. There are some workarounds which have been discussed thoroughly in Overload operator in F#: (/).

Answer 3

Actually there is a way to 're-wire' existing operators, using static constraints and overloads.

type ListExtension = ListExtension with
    static member        (?<-) (ListExtension, a , b) = a @ b
    static member inline (?<-) (ListExtension, a , b) = a + b

let inline (+) a b = (?<-) ListExtension a b

// test

let lst = [1;2] + [3;4]
// val lst : int list = [1; 2; 3; 4]

let sum = 1 + 2 + 3 + 4
// val sum : int = 10

By using the ternary operator the static constraints will be automatically inferred, another option would be to create a method and write the constraints by hand. The first overload cover the case you want to add (lists), the second covers the existing definition.

So now in your code you can do:

for x in (+) a b do
    Console.WriteLine(x)

And that will not break existing (+) for numeric types.

Answer 4

Note that @ is already a 1-char infix operator to concat lists.

Answer 5

I think operator overloading using extension method doesn't work. What you can do is define a global operator overload for list (+) using:

let inline (+) (f : List<'a>) (s : List<'a>) = f.Concat(s)