Hi there,

I would like to implement a generic Point type that can be used with both int and float element types.
The code below uses the (+) operator which seems to have F# constrain "translate" to be of type "int -> int -> int Point -> int Point".
I'm used to Haskell where arithmetic operators are handled via type classes. Is there something like type classes in F#? I don't want to pass around all the necessary operators manually.
I know I could inline translate but in the end that is not a clean solution as it would require me to
inline also every generic function that built upon translate and possibly would have other negative effects.
I'm stuck. Does somebody know a solution to this problem?

module Point =
type 'a Point = Point of 'a * 'a
let point x y = Point (x, y)
let x (Point (x, _)) = x
let y (Point (_, y)) = y
let translate dx dy (Point (x, y)) = Point (x + dx, y + dy)

let test =
let p1 = Point.point 0 0
let p1' = Point.translate 1 1 p1

let p2 = Point.point 1.0 1.0
let p2' = Point.translate 1.0 1.0 p2 // problem: translate is of type int -> int -> int Point -> int Point

printfn "point 1: %d, %d" (Point.x p1') (Point.y p1')
printfn "point 1: %f, %f" (Point.x p2') (Point.y p2')


Greetings,

Toby