Question

是否可以获取未知类型T的MinValue - 或MaxValue？与具有Int和Int.MinValue ??

的Int.MaxValue一样

由于

Answer 1

正如@mpilquist在上面的评论中所说，你可以在Haskell中创建一个Bounded类型的类。

代码示例：

trait Bounded[A] {
  def minValue: A
  def maxValue: A
}

object Bounded {
  def apply[A](min: A, max: A) = new Bounded[A] {
    def minValue = min
    def maxValue = max 
  }  

  implicit val intBounded = Bounded(Int.MinValue, Int.MaxValue)
  implicit val longBounded = Bounded(Long.MinValue, Long.MaxValue)
}

object Main {
  def printMinValue[A : Bounded](): Unit = {
    println(implicitly[Bounded[A]].minValue)
  }

  def main(args: Array[String]): Unit = {
    printMinValue[Int]() // prints -2147483648
    printMinValue[Long]() // prints -9223372036854775808
  }
}

<强>附录：

您甚至可以将其扩展为自定义类型，如下所示：

// A WeekDay ADT
sealed abstract trait WeekDay
case object Mon extends WeekDay
case object Tue extends WeekDay
case object Wed extends WeekDay
case object Thu extends WeekDay
case object Fri extends WeekDay
case object Sat extends WeekDay
case object Sun extends WeekDay

object WeekDay {
  implicit val weekDayBounded = Bounded[WeekDay](Mon, Sun)
}

printMinValue[WeekDay]() // prints Mon

Answer 2

任意类型T的最大值是多少？没有答案，因为DatabaseConnection类没有最大值。您可以使用类型类来告诉编译器某些类型的最大值是什么。这似乎最好用一个例子来解释。

abstract class Limit[T] {
  val min: T
  val max: T
}

implicit object IntLimits extends Limit[Int] {
  val min = Int.MinValue
  val max = Int.MaxValue
}

implicit object DoubleLimits extends Limit[Double] {
  val min = Double.MinValue
  val max = Double.MaxValue
}

您可以按如下方式使用此类型类：

def printMax[T: Limit] {
  println(implicitly[Limit[T]].max)
}
printMax[Int] // prints 2147483647
printMax[Double] // prints 1.7976931348623157E308

关于类型类的一个很酷的事情是，你甚至可以在自定义的类上使用它们，例如一个充当库中索引的类：

// the class definition somewhere
case class Index(key: String)

// the definition of the limit values (potentially) somewhere else 
implicit object IndexLimits extends Limit[Index] {
  val min = Index("AA")
  val max = Index("ZZ")
}

printMax[Index] // prints Index(ZZ)

Answer 3

您不能为任意类型执行此操作，因为只有少数类型（即具有Max-和MinValue。现在，如果您不知道它是Int还是Double或其他一些数值，您可以做什么是模式匹配：

def maxValue[T <: AnyRef](t:T) = t match {
    case x:Int => Int.MaxValue
    case x:Double => Double.MaxValue
    case x:Byte => Byte.MaxValue
    case x:Short => Short.MaxValue        
    case x:Long => Long.MaxValue
    case x:Float => Float.MaxValue
    case x:Char => Char.MaxValue
    case _ => -1
}

或类似的东西。

Answer 4

是否可以获得一个未知的Type T的Min - 或MaxValue？

不，它不是，原因很简单，如果T未知，那么你怎么知道它甚至最小值还是最大值？

未知类型的最小/最大值

4 个答案: