scala

Traits with concretely implemented operators


Scala newbie here. I want to create a class/trait for error correction layers that has methods with no mundated implementation (e.g. a function for output error probability given input error probability that might be completely different for each instance) but also a composition operator that is the same for every instance of the class. What is the way of doing this with classes and traits, given that what I want is somewhere inbetween the two.

In the end I would like to have something like this:

trait ECC(duration: Int, space: Int) {
  def output_error_rate(input_error_rate: Int): Int
  def <(other: ECC) : ECC = {
    val output =  new ECC (duration + other.duration, space * other.space)
    output.output_error_rate(input_error_rate) = output_error_rate(other.output_error_rate(input_error_rate)
    return output
  }
} 
class PerfectECC(duration: Int, space: Int) instance of ECC {
  def output_error_rate(a: Int): Int = {
    return 35 * a * a
  }
}

Solution

  • From a pure syntax point of view, what you want can already be implemented:

    trait ECC(val duration: Int, val space: Int) {
      def output_error_rate(input_error_rate: Int): Int
      def <(other: ECC) : ECC = {
        val that = this
        val output =  new ECC (duration + other.duration, space * other.space) {
           def output_error_rate(input_error_rate: Int) = that.output_error_rate(other.output_error_rate(input_error_rate))
        }
        output
      }
    } 
    class PerfectECC(duration: Int, space: Int) extends ECC(duration, space) {
      def output_error_rate(a: Int): Int = {
        return 35 * a * a
      }
    }
    
    val p1 = PerfectECC(1,2)
    val p2 = PerfectECC(3,4)
    
    p2.output_error_rate(5) // 875
    p1.output_error_rate(875) // 26796875
    
    p1.<(p2).output_error_rate(5) // 26796875
    

    Though to be honest, it's a bit unclear if this really is the best approach to solve your problem.