Аргументы функции Scala: класс vs function generic type, например. f (classOf [Foo], «bar») vs f [Foo] («bar»)

Question

В Scala общепринятой практикой является передача типов классов в виде дженериков или их явно передача?

Например, я создал вспомогательную функцию для создания объекта Java, который принимает исключение источника, целевое исключение и третий параметр (я просто использую строку для этого примера). Какой из них лучше практика в Scala:

exceptionTranslation(classOf[FooException], classOf[BarException], "blah") 

def exceptionTranslation(sourceClazz: Class[_ <: Throwable], targetClazz: Class[_ <: Throwable], message: String) = new Translation() 
    .withSource(sourceClazz) 
    .withTarget(targetClazz) 
    .withMessage(message) 

Или

exceptionTranslation[FooException, BarException]("blah") 

def exceptionTranslation[Source <: Throwable, Target <: Throwable](message: String)(
implicit source: ClassTag[Source], target: ClassTag[Target]) = new Translation() 
    .withSource(source.runtimeClass.asInstanceOf[Class[Source]]) 
    .withTarget(target.runtimeClass.asInstanceOf[Class[Target]]) 
    .withMessage(message) 

Answer 1

Я думаю, что это просто вопрос стиля. Они все правильные. Лично я бы пошел с тем, который более интуитивно понятен, короче и имеет наименьшую силу.

Пример извлечения текста имя класса:

import scala.reflect._ 
def bar[F](x: Class[F]) = x.getName 

def foo[X:ClassTag] = implicitly[ClassTag[X]].runtimeClass.getName 

def foobar[X](implicit ctag: ClassTag[X]) = ctag.runtimeClass.getName 

Использование:

> bar(classOf[Double]) // This one has better Java interop 
res: String = "double" 

> foo[Double] // This looks slightly less verbose when calling 
res: String = "double" 

> foobar[Double] 
res: String = "double"