如何在Scala中找到超类型

Question

If A<:B, I understand that means A is a subtype and B a supertype, I thought I use A in place of B anywhere B is needed because it has inherited all of its properties from B. Now here is my problem

type One
type Two
type Three
type Four
type Five
type Six
type Seven
type Eight

type Fun1 = { val a: One } => { val b: Two }
type Fun2 = { val b: Two } => { val a: One }

type SuperType = {
??
}

type TypeOne = {
  def apply: { val func: Fun1 ; val c: Three } => { val b: Two ; val d: Four }
  val g: Seven
}

type TypeTwo = {
  def apply: { val func: Fun2 ; val e: Five } => { val b: Two ; val f: Six }
  val h: Eight
}

How can I make SuperType which is the supertype of TypeOne and TypeTwo. I could only come up with the keyword 'Any' nothing else works. I also tried

def apply: {val func: Fun1}=>{val b: Two}

because I don't see and relationship between all the other values

Answer 1

Here's one way to get the relationships you want.

abstract class SuperType
class TypeOne extends SuperType { /* your code here */ }
class TypeTwo extends SuperType { /* etc. */ }

The type keyword is mostly used to make a type alias or declare an abstract type the will be concretely defined later on, somewhere down the chain of hierarchy. As it is, the code you've posted doesn't really create anything. You can't instantiate objects of any of those types.

BTW, if that's what you're trying to do, declare an abstract type relationship, then something like this, type TypeOne <: SuperType , is what you want.

Answer 2

Maybe this isn't what you're looking for, but does this work for you?

sealed trait SuperType
trait TypeOne extends SuperType {
  def apply: { val func: Fun1 ; val c: Three } => { val b: Two ; val d: Four }
  val g: Seven
}

trait TypeTwo extends SuperType {
  def apply: { val func: Fun2 ; val e: Five } => { val b: Two ; val f: Six }
  val h: Eight
}

Answer 3

The only possible relationship I see between Fun1 and Fun2 is that they're both functions, so I guess SuperType is a function with generic arguments. I tried to stick as much as possible to the style you exposed in your snippet (although Scala offers much more idiomatic ways to define type hierarchies).

type SuperType = {
  type A
  type B
  def apply: { val a: A } => { val b: B }
}

type Fun1 <: SuperType {
  type A = One
  type B = Two
}
type Fun2 <: SuperType {
  type A = Two
  type B = One
}