Q:

Scala: how do I access a `Numeric` type's arithmetic operations?

class Foo[T](t: T)(implicit int: Numeric[T]) {
  val negated = -t
  val doubled = t + t
  val squared = t * t
  // ...
}

I get red squigglies on all three lines here. What gives?

A:

You need to add an import for the implicit conversion for those functions:
class Foo[T](t: T)(implicit num: Numeric[T]){
  import num._
  val negated = -t
  val doubled = t + t
  val squared = t * t
}

Because in reality they are defined like this (scala source code)
class Ops(lhs: T) {
  def +(rhs: T) = plus(lhs, rhs)
  def *(rhs: T) = times(lhs, rhs)
  // etc
}

You could also ditch the implicit conversion and do this instead:
class Foo[T](t: T)(implicit num: Numeric[T]){
  val negated = num.negate(t)
  val doubled = num.plus(t, t)
  val squared = num.times(t, t)
}

A:

You have an instance of Numeric[T] for some T, and this is where all the goodies are. So you simply need to access your desired methods (e.g. plus):
class Foo[T](t: T)(implicit int: Numeric[T]) {

  val sum = int.plus(t, t)

}

If you use a context bound (the "T : Numeric" syntactic sugar), then:
class Foo[T : Numeric](t: T) {

  val sum = implicitly[Numeric[T]].plus(t, t)

}

If you want to use the shortcut operators such as +, you can simply import the members of your implicit instance:
class Foo[T](t: T)(implicit int: Numeric[T]) {

  import int._
  val sum = t + t

}

