2

有时，我会处理包含以下内容的java：

def printDbl(d:Double) { println("dbl: " + d) }
def printInt(i:Int) { println("int: " + i) }

自然，我想把它包装在一些 scala 中，最终看起来像这样：

def print[T:Manifest] (t:T) {
  if (manifest[T] <:< manifest[Int]) { printInt(t.asInstanceOf[Int]) ; return }
  if (manifest[T] <:< manifest[Double]) { printDbl(t.asInstanceOf[Double]) ; return }

  throw new UnsupportedOperationException("not implemented: " + manifest[T])
}

但是当我运行以下命令时，我得到一个运行时异常：

print(1)
print(2.0)
print("hello")

我似乎记得有一种方法可以在编译时捕获它，但我似乎无法用谷歌搜索它。也许一些巧妙的隐含转换？

4

4 回答 4

6

为什么不直接利用方法重载并像这样编写 Scala 包装器？：

object Printer {
  def print(d: Double) { printDbl(d) }
  def print(i: Int) { printInt(i) }
}

这非常简单，并提供了所需的行为：

import Printer._
print(1.)          // dbl: 1.0
print(1)           // int: 1
print("hello")     // compile-time type error
于 2012-04-26T04:37:28.533 回答
1 
scala> object SpecType {
     |   trait SpecType[T] {
     |     def is(s: String): Boolean
     |   }
     |   implicit object DoubleType extends SpecType[Double] {
     |     def is(s: String) = s == "Double"
     |   }
     |   implicit object IntType extends SpecType[Int] {
     |     def is(s: String) = s == "Int"
     |   }
     | }
defined module SpecType 


scala> import SpecType._
import SpecType._

scala> def print[T: SpecType](x: T) {
     |   if(implicitly[SpecType[T]].is("Int")) println("Int")
     |   if(implicitly[SpecType[T]].is("Double")) println("Double")
     | }
print: [T](x: T)(implicit evidence$1: SpecType.SpecType[T])Unit

scala> print(1)
Int

scala> print(1.0)
Double

scala> print("")
<console>:21: error: could not find implicit value for evidence parameter of typ
e SpecType.SpecType[String]
              print("")
于 2012-04-26T05:54:11.197 回答
0

这是我想出的最好的

class CanPrint[T] (t:T) { def getT = t}
implicit def canPrint(i:Int) = new CanPrint[Int](i)
implicit def canPrint(d:Double) = new CanPrint[Double](d)    

def print[T:Manifest] (t:CanPrint[T]) {
    if (manifest[T] <:< manifest[Int]) { printInt(t.getT.asInstanceOf[Int]) ; return }
    if (manifest[T] <:< manifest[Double]) { printDbl(t.getT.asInstanceOf[Double]) ; return }

    throw new UnsupportedOperationException("not implemented: " + manifest[T])
}

以下不编译

print(1)
print(1.0)
print("hello")

以下是我所期望的

print(1)
print(1.0)

但是，这是一个糟糕的代码，因为我必须导入隐式 defs 才能使其工作，并且作为此代码的使用者，我所看到的只是方法签名说我必须传入一个可以实例化的 CanPrint 对象。

print(new CanPrint("hello")) // pwned

我可以将构造函数设为私有并且只能由隐式方法或类似方法访问吗？

于 2012-04-26T17:46:03.243 回答
0 
def printDbl(d:Double) { println("dbl: " + d) }
def printInt(i:Int) { println("int: " + i) }

trait Printer[T] { def print(t:T) }
class PD extends Printer[Double] { def print(d:Double) = printDbl(d) }
class PI extends Printer[Int] { def print(i:Int) = printInt(i) }
implicit val pd = new PD()
implicit val pi = new PI()

def print[T](t:T)(implicit printer:Printer[T]) = printer.print(t)

print(1) // 1
print(2.0) // 2.0
print("hello") // Error:(88, 7) could not find implicit value for parameter printer: A$A336.this.Printer[String]
于 2016-02-11T16:51:54.967 回答