I think kvb makes an excellent point--you can do it with the code that he's posted but just because you can doesn't make it a great approach. Casting everything from and to System.Object isn't going to give you the best performance.

F#'s maps are ordered data structures, so the keys need to support some way of being compared. If you really need to support objects as keys (which seems like an odd requirement), you could create a simple wrapper type supporting comparison:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

type ComparableWrapper(o) =
  static let list = ResizeArray()
  do
    if not (list.Contains(o)) then
      list.Add(o)
  interface System.IComparable with
    member x.CompareTo(:? ComparableWrapper as y) =
      list.IndexOf(o).CompareTo(list.IndexOf(y.ToObject()))
  member x.ToObject() = o

let wrap o = ComparableWrapper(box o)
let unwrap (c:ComparableWrapper) = c.ToObject()

let m = Map[wrap 1, box 1]

Note that the running time of the comparison function here will be proportional to the number of unique objects wrapped, so this technique should not be used if you are going to have huge maps. In that case, you could come up with a more efficient mechanism to compare two arbitrary objects (such as by using their hash codes if they are unequal as quick first test).