在Haskell中写这个Scala矩阵乘法

Possible Duplicate:
07000

你能实现一个Matrix类和一个可以在两个矩阵上运行的*运算符吗？：

scala> val x = Matrix(3,1,2,3,4,5,6)  
x: Matrix =   
[1.0,2.0,3.0]  
[4.0,5.0,6.0]  

scala> x*x.transpose  
res0: Matrix =   
[14.0,32.0]  
[32.0,77.0]

只是让人们不说这很难,这是Scala的实现(由Jonathan Merritt提供)：

class Matrix(els: List[List[Double]]) {  

    /** elements of the matrix,stored as a list of  
      its rows */  
    val elements: List[List[Double]] = els  
    def nRows: Int = elements.length  
    def nCols: Int = if (elements.isEmpty) 0   
                     else elements.head.length  

    /** all rows of the matrix must have the same  
        number of columns */  
    require(elements.forall(_.length == nCols))  

    /* Add to each elem of matrix */
    private def addRows(a: List[Double],b: List[Double]):   
      List[Double] =   
        List.map2(a,b)(_+_)  

    private def subRows(a: List[Double],b: List[Double]):List[Double] =  
        List.map2(a,b)(_-_)  

    def +(other: Matrix): Matrix = {  
      require((other.nRows == nRows) &&   
              (other.nCols == nCols))  
      new Matrix(  
        List.map2(elements,other.elements)  
          (addRows(_,_))
      )  
    }  

    def -(other: Matrix): Matrix = {  
      require((other.nRows == nRows) &&   
              (other.nCols == nCols))  
      new Matrix(  
        List.map2(elements,other.elements)  
          (subRows(_,_))  
      )  
    }  

    def transpose(): Matrix = new Matrix(List.transpose(elements))    

    private def dotVectors(a: List[Double],b: List[Double]): Double = {  
      val multipliedElements =   
        List.map2(a,b)(_*_)  
      (0.0 /: multipliedElements)(_+_)  
    }  

    def *(other: Matrix): Matrix = {  
      require(nCols == other.nRows)  
      val t = other.transpose()  
      new Matrix(  
        for (row <- elements) yield {  
          for (otherCol <- t.elements)  
            yield dotVectors(row,otherCol)  
        }  
      )  

    override def toString(): String = {  
        val rowStrings =   
        for (row <- elements)   
          yield row.mkString("[",","]")  
        rowStrings.mkString("","n","n")  
    }  
}  

/* Matrix constructor from a bunch of numbers */
object Matrix {  
  def apply(nCols: Int,els: Double*):Matrix = {  
    def splitRowsWorker(  
      inList: List[Double],working: List[List[Double]]):  
    List[List[Double]] =  
      if (inList.isEmpty)  
        working  
      else {  
        val (a,b) = inList.splitAt(nCols)  
        splitRowsWorker(b,working + a)  
      }  
    def splitRows(inList: List[Double]) =  
      splitRowsWorker(inList,List[List[Double]]())  
    val rows: List[List[Double]] =   
      splitRows(els.toList)  
    new Matrix(rows)  
  }  
}

编辑我明白,严格来说答案是否定的：重载*不可能没有定义a和其他或特殊技巧的副作用. numeric-prelude package最佳描述：

In some cases,the hierarchy is not finely-grained enough: Operations
that are often defined independently are lumped together. For
instance,in a financial application one might want a type “Dollar”,
or in a graphics application one might want a type “Vector”. It is
reasonable to add two Vectors or Dollars,but not,in general,
reasonable to multiply them. But the programmer is currently forced to
define a method for ‘(*)’ when she defines a method for ‘(+)’.