Cách thiết lập chuyển đổi ngầm để cho phép số học giữa các loại số?

Question

Tôi muốn triển khai một lớp C để lưu trữ các giá trị của các loại số khác nhau, cũng như boolean. Hơn nữa, tôi muốn có thể hoạt động trên các trường hợp của lớp này, giữa các loại, chuyển đổi khi cần thiết Int --> Double và Boolean -> Int, tức là, để có thể thêm Boolean + Boolean, Int + Boolean, Boolean + Int, Int + Double, Double + Double v.v. nhập (Int hoặc Double) bất cứ khi nào có thể.

Cho đến nay tôi đến với điều này:

abstract class SemiGroup[A] { def add(x:A, y:A):A } 

class C[A] (val n:A) (implicit val s:SemiGroup[A]) { 
    def +[T <% A](that:C[T]) = s.add(this.n, that.n) 
} 

object Test extends Application { 
    implicit object IntSemiGroup extends SemiGroup[Int] { 
    def add(x: Int, y: Int):Int = x + y 
    } 

    implicit object DoubleSemiGroup extends SemiGroup[Double] { 
    def add(x: Double, y: Double):Double = x + y 
    } 

    implicit object BooleanSemiGroup extends SemiGroup[Boolean] { 
    def add(x: Boolean, y: Boolean):Boolean = true; 
    } 

    implicit def bool2int(b:Boolean):Int = if(b) 1 else 0 

    val n = new C[Int](10) 
    val d = new C[Double](10.5) 
    val b = new C[Boolean](true) 

    println(d + n) // [1] 
    println(n + n) // [2] 
    println(n + b) // [3] 
    // println(n + d) [4] XXX - no implicit conversion of Double to Int exists 
    // println(b + n) [5] XXX - no implicit conversion of Int to Boolean exists 
} 

này làm việc cho một số trường hợp (1, 2, 3) nhưng không cho (4, 5). Lý do là có sự mở rộng tiềm ẩn của loại từ thấp hơn đến cao hơn, nhưng không phải là cách khác. Nói cách khác, phương pháp

def +[T <% A](that:C[T]) = s.add(this.n, that.n) 

bằng cách nào đó cần phải có một phương pháp đối tác đó sẽ giống như thế:

def +[T, A <% T](that:C[T]):T = that.s.add(this.n, that.n) 

nhưng điều đó không biên dịch vì hai lý do, trước hết là trình biên dịch không thể chuyển đổi this.n để nhập T (mặc dù chúng tôi chỉ định chế độ xem bị ràng buộc A <% T) và thứ hai, ngay cả khi nó có thể chuyển đổi this.n, sau khi xóa hai phương thức + trở nên mơ hồ.

Rất tiếc, quá trình này quá dài. Bất kì sự trợ giúp nào đều được đánh giá cao! Nếu không có vẻ như tôi phải viết ra tất cả các hoạt động giữa tất cả các loại một cách rõ ràng. Và nó sẽ nhận được lông nếu tôi đã phải thêm các loại bổ sung (Complex là tiếp theo trên menu ...).

Có thể ai đó có cách khác để đạt được tất cả điều này hoàn toàn? Cảm thấy như có một cái gì đó đơn giản tôi nhìn ra.

Cảm ơn trước!

Answer 1

Được rồi, Daniel!

Tôi đã hạn chế giải pháp để bỏ qua Boolean và chỉ hoạt động với AnyVals có giới hạn tối thiểu thấp nhất có thể hiện là Numeric. Những hạn chế này là tùy ý, bạn có thể loại bỏ chúng và mã hóa mối quan hệ phù hợp yếu của bạn giữa các loại - việc triển khai a2b và a2c có thể thực hiện một số chuyển đổi.

thú vị của nó để xem xét cách các tham số ngầm có thể mô phỏng thừa kế (thông qua các thông số ngầm loại (nguồn gốc => Base) hoặc sự phù hợp Yếu. Họ thực sự mạnh mẽ, đặc biệt là khi các loại inferencer giúp bạn ra ngoài.

Thứ nhất, chúng ta cần một loại lớp để đại diện cho Giới hạn tối thiểu thấp nhất của tất cả các cặp A và B mà chúng ta quan tâm.

sealed trait WeakConformance[A <: AnyVal, B <: AnyVal, C] { 
    implicit def aToC(a: A): C 

    implicit def bToC(b: B): C 
} 

object WeakConformance { 
    implicit def SameSame[T <: AnyVal]: WeakConformance[T, T, T] = new WeakConformance[T, T, T] { 
    implicit def aToC(a: T): T = a 

    implicit def bToC(b: T): T = b 
    } 

    implicit def IntDouble: WeakConformance[Int, Double, Double] = new WeakConformance[Int, Double, Double] { 
    implicit def aToC(a: Int) = a 

    implicit def bToC(b: Double) = b 
    } 

    implicit def DoubleInt: WeakConformance[Double, Int, Double] = new WeakConformance[Double, Int, Double] { 
    implicit def aToC(a: Double) = a 

    implicit def bToC(b: Int) = b 
    } 

    // More instances go here! 


    def unify[A <: AnyVal, B <: AnyVal, C](a: A, b: B)(implicit ev: WeakConformance[A, B, C]): (C, C) = { 
    import ev._ 
    (a: C, b: C) 
    } 
} 

Phương pháp unify lợi nhuận gõ C, được tìm ra bởi các loại inferencer dựa trên tính sẵn sàng của các giá trị tiềm ẩn để cung cấp như là đối số ngầm ev.

Chúng tôi có thể cắm mã này vào lớp bao bọc C của bạn như sau, cũng yêu cầu Numeric[WeakLub] để chúng tôi có thể thêm giá trị.

case class C[A <: AnyVal](val value:A) { 
    import WeakConformance.unify 
    def +[B <: AnyVal, WeakLub <: AnyVal](that:C[B])(implicit wc: WeakConformance[A, B, WeakLub], num: Numeric[WeakLub]): C[WeakLub] = { 
    val w = unify(value, that.value) match { case (x, y) => num.plus(x, y)}; 
    new C[WeakLub](w) 
    } 
} 

Và cuối cùng, đặt nó tất cả cùng nhau:

object Test extends Application { 
    val n = new C[Int](10) 
    val d = new C[Double](10.5) 

    // The type ascriptions aren't necessary, they are just here to 
    // prove the static type is the Weak LUB of the two sides. 
    println(d + n: C[Double]) // C(20.5) 
    println(n + n: C[Int]) // C(20) 
    println(n + d: C[Double]) // C(20.5) 
} 

Test 

Answer 2

Có một số way để làm điều đó, nhưng tôi sẽ để nó ở số retronym để giải thích, vì ông đã viết giải pháp này. :-)