How can I define a generic function in scala that accepts all 'computable' Datatypes?

I've had this problem a couple of times now:

I have a function that computes something, lets say

def square(n: Int): Int = n * n

(Very simple example, but this will do)

Then I have the same 'algorithm' for another datatype, lets say long:

def square(n: Long): Long = n * n

And then for BigInt, Short, Byte and so on.

If my algorithm is more complex and longer than in this example, I have a lot of code repetition.

What I would like to have is a generic definition like:

def square[T :> AnyVal](n: T): T = n * n

But this does not work, because in the class hirachy, below AnyVal with Int and Long and Float there also is Boolean and Unit.
And for Boolean and Unit the term n * n does not make sense and I get a compiler error (correctly).

I only want my function to work for the 'computable' Datatypes like Int, Long, Float, ...
that have all the usual math operators like +, *, /, < and so on
and then formulate my algorithm or calculation with this operators for all at once.

Of course I can match on the functions input variable n, and then handle each case
differently, but there I also will repeat all the code like before with overloading.

I tried to make my own trait 'Computables' and then extend to the other classes Int, Long, ..., but the compiler complains '... cannot extend final class Int'

Is this even possible? Am I missing something?

You can use the Numeric trait:

def square[T](n: T)(using numeric: Numeric[T]): T = numeric.times(n,n)

or

def square[T](n: T)(using numeric: Numeric[T]): T = {
  import numeric._
  n * n
}

Demo @scastie

I think, you are looking for a type class

The Numeric mentioned in the other answer is an example of a type class describing all numeric types. But you can generalize that to describe any kind of behavior.

Check out the link I mentioned above, it has the details and examples, but at a high level, the idea is this:

def someFunction[T : SomeType](t: T) is equivalent to def someFunction[T](t: T)(implicit ev: SomeType[T])

This means that something like

val foo: Foo = ???
someFunction(foo)

will compile if and only if, you have an implicit instance of type SomeType[Foo] somewhere in scope.

So, that solves the first part of your problem: we have Numeric instances defined for all the "numeric" types, but not for strings or boolean, so this way you are restricting the types that can be sent to your function to a specific "class" (thus "type class") of types.

The other purpose of the type class is to express the common behaviors of the types it includes. You can "summon" the implicit "evidence" of the type class to access it:

def someFunction[T : SomeType](t: T) = implicitly[SomeType[T]].doStuff(t)

In your case, with the square:

def square[T : Numeric](t: T) = implicitly[Numeric[T]].times(t, t)

It was very hard for me to decide wich answer to accept.
It turned out the simple example I choose was a bit to simple, so i decided to try this with a real life example. But I didn't want to change the question, because of the already given answers. I post this here mostly for my own reference.

So here is my new example. I have a function that computes an integer square root:

def iSqrt1(n: Int): Int =
if n < 0 then throw IllegalArgumentException("Argument to iSqrt can not be negative! Called with: " + n)
else if n < 2 then n
else
val x0 = n / 2
@tailrec
def iterate(x0: Int, x1: Int): Int = if x1 < x0 then iterate(x1, (x1 + n / x1) / 2) else x0
iterate(x0, (x0 + n / x0) / 2)

I don't want to go into details here. If you are interested in the algorithm, I took it straight form wikipedia (see 'Using only integer division').

I implemented this function for the types Int, Long, and BigInt. And it almost looks excactly the same for each type, except for the starting value x0, that is different sometimes to have a better performance.

So I tried to write a generalised isqrt function for the classes Int, Long and BigInt to the best of my abilities, and I used scala Version 3.3.0 for it.

I first tried the approach with type classes:

import scala.annotation.{tailrec, targetName}
trait MathOperators[T] {
def plus(x: T, y: T): T
def minus(x: T, y: T): T
def multiply(x: T, y: T): T
def divide(x: T, y: T): T
def divide(x: T, y: Int): T
def lessThan(x: T, y: T): Boolean
def lessThan(x: T, y: Int): Boolean
def toBigInt(x: T): BigInt
def startValueFrom(x: T): T
}
given MathOperators[Int] with {
def plus(x: Int, y: Int): Int = x + y
def minus(x: Int, y: Int): Int = x - y
def multiply(x: Int, y: Int): Int = x * y
def divide(x: Int, y: Int): Int = x / y
def lessThan(x: Int, y: Int): Boolean = x < y
def toBigInt(x: Int): BigInt = BigInt(x)
def startValueFrom(n: Int): Int = n / 2
}
given MathOperators[Long] with {
def plus(x: Long, y: Long): Long = x + y
def minus(x: Long, y: Long): Long = x - y
def multiply(x: Long, y: Long): Long = x * y
def divide(x: Long, y: Long): Long = x / y
def divide(x: Long, y: Int): Long = x / y
def lessThan(x: Long, y: Long): Boolean = x < y
def lessThan(x: Long, y: Int): Boolean = x < y
def toBigInt(x: Long): BigInt = BigInt(x)
def startValueFrom(n: Long): Long = n / 2
}
given MathOperators[BigInt] with {
def plus(x: BigInt, y: BigInt): BigInt = x + y
def minus(x: BigInt, y: BigInt): BigInt = x - y
def multiply(x: BigInt, y: BigInt): BigInt = x * y
def divide(x: BigInt, y: BigInt): BigInt = x / y
def divide(x: BigInt, y: Int): BigInt = x / y
def lessThan(x: BigInt, y: BigInt): Boolean = x < y
def lessThan(x: BigInt, y: Int): Boolean = x < y
def toBigInt(x: BigInt): BigInt = x
def startValueFrom(n: BigInt): BigInt = BigInt(2).pow((n.bitLength / 2) + 1)
}
def startValue[A](n: A)(using mathOp: MathOperators[A]): A = {
mathOp.startValueFrom(n)
}
implicit class MathOperatorsSyntax[T](x: T)(using op: MathOperators[T]) {
@targetName("plus")
def +(y: T): T = op.plus(x, y)
@targetName("minus")
def -(y: T): T = op.minus(x, y)
@targetName("multiply")
def *(y: T): T = op.multiply(x, y)
@targetName("divide")
def /(y: T): T = op.divide(x, y)
@targetName("divide")
def /(y: Int): T = op.divide(x, y)
@targetName("lessThen")
def <(y: T): Boolean = op.lessThan(x, y)
@targetName("lessThen")
def <(y: Int): Boolean = op.lessThan(x, y)
}
def iSqrt[T](n: T)(using op: MathOperators[T]): T =
if n < 0 then throw IllegalArgumentException("Argument to iSqrt can not be negative! Called with: " + n)
else if n < 2 then n
else
val x0: T = startValue(n)
@tailrec
def iterate(x0: T, x1: T): T = if x1 < x0 then iterate(x1, (x1 + n / x1) / 2) else x0
iterate(x0, (x0 + n / x0) / 2)
@main
def main(): Unit = {
val n1 = BigInt("1236549865413213456498765432136546879854651321")
println(iSqrt(n1))
}

As Dima commented above:
> But you can just write your own [type class] to do whatever you like.

Yes, One can. It for shure is a good thing to know how to do it just in case. But in my example here it looks like some boilerplate to me. (Or at least I could not figure out how to do this shorter.)

So I looked into the second approach: use a already build in type class like Numeric

For my new example, I picked the class Integral.
At first this was not very satisfying as well, until I found infixOrderingOps and infixIntegralOps. With these imports I could use operators like +, -, %, < and so on:

import scala.annotation.tailrec
import scala.math.Integral
import scala.math.Integral.Implicits
import math.Ordering.Implicits.infixOrderingOps
import math.Integral.Implicits.infixIntegralOps
import collection.immutable.Range.BigDecimal.bigDecAsIntegral
def iSqrt[T](input: T)(using integral: Integral[T]): T =
val two: T = integral.fromInt(2)
val zero: T = integral.zero
val n: T = input match {
case _: BigDecimal => throw IllegalArgumentException("iSqrt does not accept arguments of type BigDecimal")
case x: T if x < zero => throw IllegalArgumentException("Argument to iSqrt can not be negative! Called with: " + x)
case x: T => x
}
val x0: T =
val startValue: Any =
n match
case x: BigInt => BigInt(2).pow(x.bitLength / 2 + 1) 
case x: T => x / two
startValue match
case x: T => x
@tailrec
def iterate(x0: T, x1: T): T = if x1 < x0 then iterate(x1, (x1 + n / x1) / two) else x0
if n < two then n
else
iterate(x0, (x0 + n / x0) / two)

I even managed to sneak in the speacial start value x0 for certain types, but this is admittedly not so clean as in the first version.

After trying all that out, the first answer looks like the right choice for what I wanted, so I accepted it.