Back to Questions
4.4k
views3
comments
Comparison
f#c#.net

Hi,

I've got a bunch of "funny" operators in my code and I was looking at how I could make them integrate a bit more nicely. For example, (+:) to (+) and so on.

I cant seem to get this working with the comparison or equality operators though. Note that for my types equality does not imply a boolean result - I just want to generate a node of my datatype.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

type Signal = { signal : Circuit.signal_t; sign : sign_t }
  with

    static member (+) (s1,s2) = 
      signs_same s1.sign s2.sign
      { 
        signal = s1.signal +: s2.signal;
        sign = s1.sign
      }

    static member (<) ((a:Signal), (b:Signal)) =
      signs_same a.sign b.sign
      {
        signal = a.signal <: b.signal;
        sign = Unsigned
      }
  end

  let h = a < b -- ..nope
  let h = Signal.(<) (a,b) -- ..ok

Looking though the documentation I started to think it was a .net thing. However, I also have a binding to c# and I successfully overload these operators there, albeit with a couple of warnings.

1
2
3
4
5
6
7
8
9

public class Signal : HdfsUtils {

    public static Signal operator + (Signal a, Signal b) 
    { return new Signal(DigitalLogic.Design.op_PlusColon(a.s,b.s)); }
    public static Signal operator < (Signal a, Signal b) 
    { return new Signal(DigitalLogic.Design.op_LessColon(a.s,b.s)); }

}

Looking at the documentation in Pervasives it does seem to suggest you cannot overload these operators and have to go through the structral comparison interface which I dont think will get me the result I'd like.

Cheers,

Andy

.

Yes, that's right, you can't overload comparison operators, except by implementing IComparable.

How about defining your own set of operators that you reserve to correspond to constructions. e.g. you could systematically use the "+." etc. operators that OCaml uses for floating point addition (these don't tend to get used in F# since + etc. are overloaded).

1
2

let inline (+.) x y = (^a: (static member (+.) : ^a * ^b -> ^c) (x,y))
let inline (<.) x y = (^a: (static member (<.) : ^a * ^b -> ^c) (x,y))

and then implementing these on your types.

Don

By on 10/10/2006 1:43 PM ()

Thanks, that makes sense. I currently have a bunch of global operators using a colon as the differentiating character; (+:), (-:) etc. Rather than use the "inline static member" syntax you give above they are just global ocaml style declarations:

1

let (+:) a b = ....

I noticed then when I build a new class and used these operators within it the top level delcarations got in the way. So perhaps if I mark these operators for proper overloading then I'll be abe to define new types which build on the basic ones i.e. to give implementations for Signed/Unsigned arithmetic, Fixed point arithmetic and so on.

Cheers,

Andy

By on 10/11/2006 3:26 AM ()

I noticed then when I build a new class and used these operators within it the top level delcarations got in the way. So perhaps if I mark these operators for proper overloading then I'll be abe to define new types which build on the basic ones i.e. to give implementations for Signed/Unsigned arithmetic, Fixed point arithmetic and so on.

Yes, that's right - overloaded operators need "let (+.) x y = ..." bindings that show how they map through to members on particular types. For example, the (.[]) operator maps across to a requirement that an "Item" property exist on the type of the value being accessed.

Cheers!

Don

By on 10/14/2006 9:34 AM ()

    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