サブタイプのスカラー型の結合型：A | B <：A | B | C

Question

A|BタイプをA|B|Cのサブタイプにしたいと考えています。 Scalaでエンコードすることは可能ですか？はいの場合、どうですか？

私はimplicitly[¬¬[IF] <:< T]（元のコードhere）をコンパイルできると期待していましたが、そうではありません。サブタイプを許可するためにこのコードを修正する方法はありますか？

object NUnion{ 
    type ¬¬[A] = ¬[¬[A]] 

    type ¬[A] = A => Nothing 
    trait Disj[T] { 
    type or[S] = Disj[T with ¬[S]] 
    type apply = ¬[T] 
    } 

    // for convenience 
    type disj[T] = { type or[S] = Disj[¬[T]]#or[S] } 


    type T = disj[Int]#or[Float]#or[String]#apply 
    type IF = disj[Int]#or[Float]#apply 
    implicitly[¬¬[Int] <:< T] // works 
    // implicitly[¬¬[Double] <:< T] // doesn't work 
    // implicitly[¬¬[IF] <:< T] // doesn't work - but it should 

}

私も（hereから）これを試してみました：

object Kerr{ 
    def f[A](a: A)(implicit ev: (Int with String with Boolean) <:< A) = a match { 
    case i: Int => i + 1 
    case s: String => s.length 
    } 

    f(1) //works 
    f("bla") // works 
    def g[R]()(implicit ev: (Int with String with Boolean) <:< R):R = "go" // does not work 

} 

が、ここで私は、彼らが唯一の引数の型として存在することができるユニオン型「ファーストクラス」ではないことはできません戻り値の型としてthisアプローチと

同じ問題：

object Map{ 
    object Union { 
    import scala.language.higherKinds 

    sealed trait ¬[-A] 

    sealed trait TSet { 
     type Compound[A] 
     type Map[F[_]] <: TSet 
    } 

    sealed trait ∅ extends TSet { 
     type Compound[A] = A 
     type Map[F[_]] = ∅ 
    } 

    // Note that this type is left-associative for the sake of concision. 
    sealed trait ∨[T <: TSet, H] extends TSet { 
     // Given a type of the form `∅ ∨ A ∨ B ∨ ...` and parameter `X`, we want to produce the type 
     // `¬[A] with ¬[B] with ... <:< ¬[X]`. 
     type Member[X] = T#Map[¬]#Compound[¬[H]] <:< ¬[X] 

     // This could be generalized as a fold, but for concision we leave it as is. 
     type Compound[A] = T#Compound[H with A] 

     type Map[F[_]] = T#Map[F] ∨ F[H] 
    } 

    def foo[A : (∅ ∨ String ∨ Int ∨ List[Int])#Member](a: A): String = a match { 
     case s: String => "String" 
     case i: Int => "Int" 
     case l: List[_] => "List[Int]" 
    } 


    def geza[A : (∅ ∨ String ∨ Int ∨ List[Int])#Member] : A = "45" // does not work 


    foo(geza) 

    foo(42) 
    foo("bar") 
    foo(List(1, 2, 3)) 
// foo(42d) // error 
// foo[Any](???) // error 
    } 

} 

Answer 1

Scala.js（sourceとtests）のユニオン型はA | B | CのA | Bサブタイプをサポートしています。それはA | BサブタイプB | C | Aのような並べ替えをサポートします。

Answer 2

あなたの最初のアプローチは私にとってはうまくいきます。また、型の順列でも動作します。もちろん

type IFS = disj[Int]#or[Float]#or[String]#apply 
type IF = disj[Int]#or[Float]#apply 
type IS = disj[Int]#or[String]#apply 
type IFD = disj[Int]#or[Float]#or[Double]#apply 
type FI = disj[Float]#or[Int]#apply 

scala> implicitly[IF <:< IFS] 
res0: <:<[IF,IFS] = <function1> 

scala> implicitly[IS <:< IFS] 
res1: <:<[IS,IFS] = <function1> 

scala> implicitly[FI <:< IFS] 
res2: <:<[FI,IFS] = <function1> 

scala> implicitly[IFD <:< IFS] 
<console>:18: error: Cannot prove that IFD <:< IFS. 
     implicitly[IFD <:< IFS] 

それはすでにユニオンタイプだから、あなたは、¬¬[IF]との連合型にIFを持ち上げてはいけません。このアプローチではIntがユニオンタイプではないため、¬¬[Int]を実行する必要があります。