Overloading one operator with different argument types in the same type definition?

Question

is it possible to have the same operator in a type definition work with different types on the right-hand side of the operator?

Definition of the |== operator via name plugElts compiles fine, but using it later in module RemoverTest fails with error FS0002: This function takes too many arguments, or is used in a context where a function is not expected when function is supplied on the right-hand side.

module SampleOperators =

    let inline (|==) (x: ^URel) (wires: ^Wires) =
        (^URel: (static member plugElts: ^URel * ^Wires -> 'R) (x, wires))

module Remover =

    open SampleOperators

    type RemGroup<'G> = RemGroupPass | RemGroupAll | RemGroupExcept of 'G | RemGroupElts of 'G
    type RemMap<'K,'P when 'K: comparison> =
        RemGroup<Map<'K,'P>>
    type RemFun<'K,'P when 'K: comparison> =
        'K * 'P -> bool
    type Rem<'K,'MapVal,'FunVal when 'K:comparison> =
        | Map_ of RemMap<'K,'MapVal>
        | Fun_ of RemFun<'K,'FunVal>

    type X<'K,'P when 'K:comparison> =
        { id: 'K
          vv: Rem<'K,'P,'P> }
        static member inline plugElts (x:X<_,_>, ws:('K * 'P) seq) =
            {x with vv = Map_ (RemGroupElts (Map.ofSeq ws))}

        static member inline plugElts (x:X<_,_>, i:int) =
            {x with vv = Map_ (RemGroupElts (Map.ofSeq [i,i]))}

        static member inline plugElts (x:X<_,_>, fn:('K * 'P -> bool)) =
            {x with vv = Fun_ fn}


module RemoverTest =

    open Remover
    open SampleOperators

    let xxx1 () =
        {id = 1; vv = Map_ RemGroupPass} |== [1,1]   // compiles ok

    let xxx2 () =
        {id = 1; vv = Map_ RemGroupPass} |== 1       // compiles ok

    let xxx3 () =
        ({id = 1; vv = Map_ RemGroupPass}:X<_,_>) |== (fun _ -> bool)  // can't compile

Are there ways to make this work without wrapping the right-hand side in discriminated union?

Thanks, Karol

edit: added overload for right-hand side with int type which works fine

@JohnPalmer: But then the left-hand side of the operator (type X) would have to be different, right? — karol skocik
– karol skocik, Commented May 5, 2016 at 7:00
Problem is that instance of X is nested in a sequence with other Xs, so I have to keep the left-hand side the same... — karol skocik
– karol skocik, Commented May 5, 2016 at 7:11
The code posted does not compile as-is. Some things can be fixed easily (missing type args), but unclear still what type RemMap = RemGroup> is supposed to be. Can you post a correct version? — Anton Schwaighofer
– Anton Schwaighofer, Commented May 5, 2016 at 8:54

Anton Schwaighofer · Accepted Answer · 2016-05-05 09:42:54Z

The moment you invoke the operator in xxx3 you need to provide an actual function - what you have there right now is only the equivalent of a type declaration. Change to the following, and it will compile:

let xxx3 () =
    ({id = 1; vv = Map_ RemGroupPass}:X<_,_>) |== (fun _ -> true)

Here's a more compact version of your question:

type MoreFun<'T> = 'T -> int

type X<'T> = 
    { 
        B: int 
        F: MoreFun<'T>
    }
    static member (|==) (a: X<_>, b: int) = { B = b; F = fun (f:int) -> b}
    static member (|==) (a: X<_>, b: MoreFun<_>) = { a with F = b }

module Tests = 
    let one (f: int) = 1
    let t1() = { B = 1; F = one } |== 2
    // let t2() = { B = 1; F = one } |== (fun _ -> int) // Does not work
    let three: MoreFun<_> = (fun _ -> 3)
    let t3() = { B = 1; F = one } |== three
    // You don't need to cast three to be of type MoreFun:
    let t4() = { B = 1; F = one } |== (fun _ -> 3)

Thank you for your answer Anton. After seeing that it's working for you, I looked again on what I posted and realized I'm returning a 'bool' as a value, instead of 'true' or 'false'. Cheers

Collectives™ on Stack Overflow

Overloading one operator with different argument types in the same type definition?

1 Answer 1

1 Comment

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Related