Digamos que estou resolvendo um problema em particular e crie uma função

let function parameter1 ... = 
     a lot of adding, multiplying & so on with a lot of 
     literals all over the place

Agora esta função funciona bem se meus parâmetros forem do tipo int. Mas em algum lugar eu vou precisar para ir até 11, eu vou precisar desse push extra para o int64 ou mesmo para o BigInteger. Então o que eu faço? Eu copio e colo a função, mudo o nome e vou procurar todas as aparências literais que fazem o compilador achar que a função deve operar em int. E isso é uma merda.

Existe uma maneira de fazer isso:

let greatFunction param1 param2 = (param1+1)/(param2*2)

onde param1 e param2 podem ser qualquer combinação de tipos inteiros?

Editar:

Expandindo um pouco sobre uma ótima dica de kvb abaixo, eu vim com o seguinte

module NumericLiteralG 

  let inline FromZero() = LanguagePrimitives.GenericZero
  let inline FromOne() = LanguagePrimitives.GenericOne
  let inline FromInt32 n =
    let rec loop nIn nOut = 
        if nIn>0 then loop (nIn - 1) (nOut + LanguagePrimitives.GenericOne)
        else nOut
    loop n LanguagePrimitives.GenericZero

então fica um pouco menos feio quando usado

let inline halfSquare num =
   let res = num / 2G
   res * res

let solve1 = halfSquare 5I 
let solve2 = halfSquare 5.0
let solve3 = halfSquare 5uy

Agora a questão é que devo usar isso? Se não, por que não?