The short answer is yes: you have to write a separate function for each primitive numeric data type you want to support.

You can use the name of a numeric type as a function to convert to this numeric type. E.g., if you wanted to pass an int to the int64 version of factorial.

1
2
3

val factoriali64 : int64 -> int64

factoriali64 (int64 5)

F# supports some overloading in certain contexts. As zakaluka points out it supports OO-style overloading with the OverloadID attribute, but this only works on methods of classes not functions (afaik). Another form of overloading is with inline functions -- this is how operator overloading (e.g. +) is implemented in F#.

To write a truly generic factorial function, you could write something like this

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

open Math
open GlobalAssociations

let rec factorial (n : INumeric<_>) a =
  if a = n.Zero || a = n.One 
  then n.One 
  else n.Multiply(a, factorial n (n.Subtract(a, n.One)))

let i32 = factorial (GetNumericAssociation ()) 5
let i64 = factorial (GetNumericAssociation ()) 5L
let f = factorial (GetNumericAssociation ()) 5.0
let b = factorial (GetNumericAssociation ()) 5I

To this factorial function you need to pass an INumeric<'a> object which contains methods for addition, multiplication, etc. on the type 'a. To get a default implemenation for this interface for primitive numeric types you call the GetNumericAssociation function. However you can write your own implemenations of this interface for your own custom types and use it with this factorial function too.

Welcome to the forums. You are correct, in that F# has great similarities to OCaml (and can still cross-compile F# code into OCaml bytecode).

Unlike OCaml, F# does support overloading in certain situations. For example, the same operator is used for addition for all the different types (+), as opposed to OCaml where you have (+) for integers and (+.) for floating point numbers.

The question you asked here is quite tricky. For one thing, F# does not perform automatic casting from int to int64 and vice versa (or between any two types of numbers, for that matter). Also, numbers are written differently for different types (1, 1., 1L, 1I, 1N, 1y, 1uy, ...). These different representations of the same constant cannot be compared directly, but must be explicitly type-cast first.

So, for your problem, you would have to do some extra work. Here is one way you could do it:

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

#light

type Factorial =
  | Vali of int
  | Valf of float
  
  static member ( * ) (x: Factorial, y: Factorial) = 
    match x, y with
    | Vali(a), Vali(b) -> Vali(a * b)
    | Valf(a), Valf(b) -> Valf(a * b)
    | _ -> failwith "shouldn't happen"

let helper a =
  match box a with
  | :? int as x -> Vali(x)
  | :? float as x -> Valf (x)
  | _ -> failwith "type not supported"

let fact a =
  let rec f' b =
    match b with
    | Vali(x) -> if x = 0 then Vali(1) else b * (f' (helper (x - 1)))
    | Valf(x) -> if x = 0. then Valf(1.) else b * (x - 1. |> helper |> f')
  f' <| helper a

As you can see, I basically created a new Factorial type that supports the multiplication operator (*). If you wanted to add another type, say, bigint, you would have to add it to the type definition, the (*) operator, the helper function and the internal f' function. However, if you look at the signature of fact, you see that it is val fact : 'a -> Factorial. This means that it will take a value of any type (since fact sends the argument to helper, which immediately boxes it). Here are some sample outputs:

1
2
3
4
5
6
7
8
9

> fact 5;;
val it : Factorial = Vali 120
> fact 5.;;
val it : Factorial = Valf 120.0
> fact 5L;;
Microsoft.FSharp.Core.FailureException: type not supported
   at FSI_0006.helper[T](T a)
   at <StartupCode$FSI_0012>.FSI_0012._main()
stopped due to error

A more reasonable solution may be to use the BigInt type.

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

open Microsoft.FSharp.Math

let fact2 a =
  let helper x =
    match box x with
    | :? int as y -> BigInt.of_int y
    | :? int64 as y -> BigInt.of_int64 y
    | :? string as y -> BigInt.of_string y
    | _ -> failwith "unsupported type"
  let rec f' b =
    if b = 0I then 1I
    else b * (f' (b - 1I))
  helper a |> f'

The code is much shorter. Here is some sample output:

1
2
3
4
5
6
7
8
9
10

> fact2 5;;
val it : bigint = 120I
> fact2 5L;;
val it : bigint = 120I
> fact2 5.;;
Microsoft.FSharp.Core.FailureException: unsupported type
   at <A href="mailto:FSI_0014.helper@1114@1114[U](U">FSI_0014.helper@1114@1114[U](U</A> x)
   at FSI_0014.fact2[T](T a)
   at <StartupCode$FSI_0017>.FSI_0017._main()
stopped due to error

Hope this helps,

z.