icomparable

My problem, in a nutshell, is this: What can I do about storing a tuple (or any type with a constraint of 'comparison') in a C# container that requires an IComparable ? This works: > let x (y : 'a when 'a : comparison) = y ;; val x : y:'a -> 'a when 'a : comparison > x (1,2) ;; val it : int * int = (1, 2) I would have thought this would work: > let x (y : IComparable<int>) = y ;; val x : y:IComparable<int> -> IComparable<int> > x (1,2) ;; x (1,2) ;; ---^^^ stdin(28,4): error FS0001: The type ''a * 'b' is not compatible with the type 'IComparable<int>' And this as well: > let x (y : IComparable

I have implemented a very simple binarySearch implementation in C# for finding integers in an integer array: Binary Search static int binarySearch(int[] arr, int i) { int low = 0, high = arr.Length - 1, mid; while (low <= high) { mid = (low + high) / 2; if (i < arr[mid]) high = mid - 1; else if (i > arr[mid]) low = mid + 1; else return mid; } return -1; } When comparing it to C#'s native Array.BinarySearch() I can see that Array.BinarySearch() is more than twice as fast as my function, every single time. MSDN on Array.BinarySearch : Searches an entire one-dimensional sorted array for a

I am implmenting the IComparable to sort like typed objects. My question is why does it cast type person to int32? The array's Sort() seems to cast each type in the array to the type that I am using for comparison. Comparable: public class Person:IComparable { protected int age; public int Age { get; set; } public int CompareTo(object obj) { if(obj is Person) { var person = (Person) obj; return age.CompareTo(person.age); } else { throw new ArgumentException("Object is not of type Person"); } } } } class Program { static void Main(string[] args) { Person p1 = new Person(); Person p2 = new

I'm trying to use Set operations with a class that I have. Every instance of this class has a unique ID. Do I need to implement the System.IComparable interface and if so how would I? type SomeClass(id : int) = member this.ID = id let someSet = Set.of_list [SomeClass(1); SomeClass(2)] let test = someSet.Contains(SomeClass(2)) Here's an implementation that should work: type SomeClass(id : int) = member this.ID = id override this.Equals(o) = match o with | :? SomeClass as sc -> this.ID = sc.ID | _ -> false override this.GetHashCode() = id.GetHashCode() interface System.IComparable with member

Let's say I have a type that implements IComparable. I would have thought it's reasonable to expect that the operators == , != , > , < , >= and <= would "just work" automatically by calling CompareTo but instead I have to override them all if I want to use them. From the language design perspective is there a good reason it was done this way? Are there any cases when you it's genuinely useful for A>B to behave differently to Compare(A,B)>0 ? The whole situation is vexing. C# has too many ways to express equality and inequality: the == != > < >= <= operators (which are logically static methods)