F# type constraints and overloading resolution

Question

I am trying to emulate a system of type classes in F#; I would like to create pair printer which automatically instantiates the right series of calls to the printing functions. My latest try, which is pasted here, fails miserably since F# cannot identify the right overload and gives up immediately:

type PrintableInt(x:int) =
  member this.Print() = printfn "%d" x

let (!) x = PrintableInt(x)

type Printer() =
  static member inline Print< ^a when ^a : (member Print : Unit -> Unit)>(x : ^a) =
    (^a : (member Print : Unit -> Unit) x)
  static member inline Print((x,y) : 'a * 'b) =
    Printer.Print(x)
    Printer.Print(y)

let x = (!1,!2),(!3,!4)

Printer.Print(x)

Is there any way to do so? I am doing this in the context of game development, so I cannot afford the runtime overhead of reflection, retyping and dynamic casting: either I do this statically through inlining or I don't do it at all :(

Answer 1

What you're trying to do is possible. You can emulate typeclasses in F#, as Tomas said maybe is not as idiomatic as in Haskell. I think in your example you are mixing typeclasses with duck-typing, if you want to go for the typeclasses approach don't use members, use functions and static members instead.

So your code could be something like this:

type Print = Print with    
  static member ($) (_Printable:Print, x:string) = printfn "%s" x
  static member ($) (_Printable:Print, x:int   ) = printfn "%d" x
  // more overloads for existing types

let inline print p = Print $ p

type Print with
  static member inline ($) (_Printable:Print, (a,b) ) = print a; print b

print 5
print ((10,"hi"))
print (("hello",20), (2,"world"))

// A wrapper for Int (from your sample code)
type PrintableInt = PrintableInt of int with
  static member ($) (_Printable:Print, (PrintableInt (x:int))) = printfn "%d" x

let (!) x = PrintableInt(x)

let x = (!1,!2),(!3,!4)

print x

// Create a type
type Person = {fstName : string ; lstName : string } with
  // Make it member of _Printable
  static member ($) (_Printable:Print, p:Person) = printfn "%s, %s" p.lstName p.fstName

print {fstName = "John"; lstName = "Doe" }
print (1 ,{fstName = "John"; lstName = "Doe" })

Note: I used an operator to avoid writing the constraints by hand, but in this case is also possible to use a named static member. More about this technique here.

Answer 2

What you're trying to do is not possible (edit: apparently, it can be done - but it might not be idiomatic F#), because the constraint language cannot capture the constraints you need for the second Print operation. Basically, there is no way to write recursive constraints saying that:

Let C be a constraint specifying that the type either provides Print or it is a two-element tuple where each element satisfies C.

F# does not support type-classes and so most of the attempts to emulate them will (probably) be limited in some way or will look very unnatural. In practice, instead of trying to emulate solutions that work in other languages, it is better to look for an idiomatic F# solution to the problem.

The pretty printing that you're using as a sample would be probably implemented using Reflection or by wrapping not just integers, but also tuples.