使用Scala特征建模C概念

concept InputIterator<typename Iter> {
  typename value_type;
  value_type operator*(Iter);
  ...
};

template<typename Iter,typename V>
requires InputIterator<Iter> && EqualityComparable<Iter::value_type,V>
Iter find(Iter first,Iter last,V v) { 
    while (first < last && *first != v)
        ++first;
    return first;
}

我不确定我是否正确理解了这些特征.但仍然……在Scala中编写了InputIterator特征(或者更确切地说 – 它是使用find函数中使用的方法简化的模拟)：

trait InputIterator[Iter] {
    type value_type

    def <(a: Iter,b: Iter): Boolean
    def ++(it: Iter): Unit
    def *(it: Iter): value_type
}

EqualityComparable很清楚：

trait EqualityComparable[S,T] {
    def ==(s: S,t: T): Boolean
    def !=(s: S,t: T): Boolean = !(s == t)
}

但是我们应该如何处理？我想写这样的东西：

def find[Iter,V](first: Iter,last: Iter,x: V)(implicit iterator: InputIterator[Iter],cmp: EqualityComparable[iterator.value_type,V]): Iter =
{
    while (iterator.<(first,last) && cmp.!=(iterator.*(first),x))
        iterator.++(first)
    first
}

但它会导致错误?非法依赖方法类型?.而且我不知道如何以其他方式“提取”抽象类型value_type.所以我得到了这段代码：

trait EqualityComparable[S,t: T): Boolean = !(s == t)
}

trait InputIterator[Iter] {
    type value_type

    def <(a: Iter,b: Iter): Boolean
    def ++(it: Iter): Unit
    def *(it: Iter): value_type
}

trait VTInputIterator[Iter,VT] extends InputIterator[Iter] {
    type value_type = VT
}

class ArrayListIterator[T](a: ArrayList[T],i: Int) {
    val arr: ArrayList[T] = a
    var ind: Int = i

    def curr(): T = arr.get(ind)
    def ++(): Unit = { ind += 1 }

    override def toString() = "[" + ind.toString() + "]"
}

class InputIterArrList[T] extends VTInputIterator[ArrayListIterator[T],T]{ 
    def <(a: ArrayListIterator[T],b: ArrayListIterator[T]) = {
      if (a.arr == b.arr) a.ind < b.ind
      else throw new IllegalArgumentException()
    }

    def ++(it: ArrayListIterator[T]): Unit = it.++()
    def *(it: ArrayListIterator[T]) = it.curr()
}

object TestInputIterator extends Application{   

    def find[Iter,VT,x: V)(implicit iterator: VTInputIterator[Iter,VT],cmp: EqualityComparable[VT,V]): Iter = 
    {
      while (iterator.<(first,x))
        iterator.++(first)
      first
    }

    implicit object EqIntInt extends EqualityComparable[Int,Int] {
      def ==(a: Int,b: Int): Boolean = { a == b }
    }

    implicit object inputIterArrListInt extends InputIterArrList[Int]{}

    val len = 10;
    var arr: ArrayList[Int] = new ArrayList(len);
    for (i: Int <- 1 to len)
      arr.add(i)
    var arrFirst = new ArrayListIterator(arr,0)
    var arrLast = new ArrayListIterator(arr,len)
    var r = find(arrFirst,arrLast,7)
    println(r)
}

我们在def find [Iter,V]中使用了类型参数VT,而不是抽象类型.

所以问题是：如何做得更好？是否可以使用抽象类型value_type而无需额外的类型参数VT？