1-MathProvider.scala

trait MathProvider[A] {
  def plus(a: A, b: A): A
  def minus(a: A, b: A): A
  def divide(a: A, b: A): A
  def multiply(a: A, b: A): A
}

2-MathProviderFactory.scala

trait AbstractMathProviderFactory {
  def numericMathProvider[A: Numeric]: MathProvider[A]
}

class AbstractMathProviderFactoryImpl extends AbstractMathProviderFactory {
  def numericMathProvider[A: Numeric]: MathProvider[A] =
    new MathProvider[A] {
      def plus(x: A, y: A): x + y
      def minus(x: A, y: A): x - y
      def divide(x: A, y: A): x / y
      def multiply(x: A, y: A): x * y
    }
}

class AbstractMathProviderFactory(n: 

3-FactoryProxy.scala

class MathProviderFactoryProxyBean(factory: AbstractMathProviderFactory, existingFactories: mutable.Map[TypeTag[_], _]) extends AbstractMathProviderFactory {
  private val mathProviders: mutable.Map[TypeTag[_], _] = existingFactories
  
  private def getOrSet[A: TypeTag](newA: => A): A =
    mathProviders.getOrElse(implicitly[TypeTag[A]], {
      mathProviders += (implicitly[TypeTag[A]] -> newA)
    }).asInstanceOf[A]
  
  def numericMathProvider[A: Numeric: TypeTag]: A = getOrSet(MathProviderFactory.numericMathProvider[A])
}

4-Usage.scala

def add(x: Int, y: Int)(provider: MathProvider[Int]): Int =
  provider.plus(x,y)

val proxy = new MathProviderFactoryProxyBean(new AbstractMathProviderFactoryImpl, mutable.Map.empty)

add(10, 11)(proxy.numericMathProvider)