在scala中返回不同的返回类型

Question

有没有办法从scala中的单一方法返回不同的返回类型？

例如，如果我有一个load()方法，我想根据调用此方法的对象返回不同的数据类型。

def load(path: String):<return type> 
{ 
    // if this instance is of type "type1", do some processing on this object, 
    // and return object of type "type1" 

    // else if this instance is of type "type2", do some processing on this object, 
    // and return object of type return "type2" 
} 

Answer 1

您可以使用Scala的Either：

def load(path : String) : Either[Type1, Type2] = { 
    this match { 
    case t1 : Type1 => Left(someProcessing(t1)) 
    case t2 : Type2 => Right(someOtherProcessing(t2)) 
    } 
} 

Answer 2

正如其他人所说，你可以使用

您可以使用Scala的Either

只要记住，每一个方法调用你的方法，将需要检查它返回哪种类型（使用.map或模式匹配）。无论是平时使用像Either[ErrorType, NormalType]顺便说一句，当然你可以使用它，但是你想

斯卡拉猫库有其他的选择：http://eed3si9n.com/herding-cats/Xor.html

当然，scalaz还提供了一种替代方案：http://appliedscala.com/blog/2016/scalaz-disjunctions/

由于不得已，难道你可以定义自己的“或者”

Answer 3

如果我理解正确的话，你想要什么，F-bounded polymorphism可能会为你工作：

trait Base[T <: Base[T]] { 
    def load(path: String): T 
} 

class Type1 extends Base[Type1] { 
    override def load(path: String): Type1 = new Type1 // provisional implementation 
} 

class Type2 extends Base[Type2] { 
    override def load(path: String): Type2 = new Type2 
} 

Then load将返回当前对象的类型。请注意，结果类型的表达式：

new Type1().load(path) 
scala> res2: Type1 = Type1@744f0e0b 

new Type2().load(path) 
scala> res3: Type2 = Type2@77988c45 

Answer 4

如果你的要求是为返回的上下文实例的类型的一些实例作为简单...即this那么你可以做到这一点，

class A() { 
    def omg(s: String): this.type = new A() 
} 

如果的传承参与，

trait A { 
    type omgType 

    def omg(s: String): omgType 
} 

class B() extends A { 
    override type omgType = this.type 

    override def omg(s: String): omgType = new B() 
} 

class C() extends A { 
    override type omgType = this.type 

    override def omg(s: String): omgType = new C() 
} 

但是，如果你想要更多的普遍性，那么你可能需要阅读以下内容并应用它在那里，

最简单的方法是从magnet pattern中获取灵感，这是在喷雾中大量使用的。

我们可以借助灵感来构建我们的定制解决方案，请记住它既不是pure magnet pattern也不是path dependent type的方法。它是一个混合的混合鸡尾酒。

因此...可以说你想让你的def process能够支持Int和String类型的输入参数，并最终返回相应的结果。

您需要定义隐含的磁铁，这些类型，

trait ProcessMagnet { 
    type Input 
    type Result 
    def input: Input 
    def process: Result 
} 

object ProcessMagnetProvider { 
    implicit def stringToStringProcessMagnet(string: String): ProcessMagnet = new ProcessMagnet { 
    override type Input = String 
    override type Result = String 

    override def input: Input = string 
    // define this for your doing... 
    override def process: Result = input + "_omg" 
    } 
    //... add for all your inputs 
    implicit def intToIntProcessMagnet(int: Int): ProcessMagnet = new ProcessMagnet { 
    override type Input = Int 
    override type Result = Int 

    override def input: Input = int 
    // define this for your doing... 
    override def process: Result = input + 1 
    } 
} 

def process[T](t: T)(implicit pmConverter: T => ProcessMagnet): ProcessMagnet = pmConverter(t) 

// now just import our implicit magnets... 
import ProcessMagnetProvider._ 

val intResult: Int = process(5).process.asInstanceOf[Int] 

val stringResult: String = process("omg").process.asInstanceOf[String] 

Answer 5

怎么样的工厂方法，只是定义特征loadable例如：

trait Loadable { 
    def load(path: String): Loadable 
} 

class Type1 extends Loadable { 
    def load(path: String): Type1 = this 
} 

class Type2 extends Loadable { 
    def load(path: String): Type2 = this 
} 
object Main { 
    def test(): Loadable = { 
    new Type1().load("path") 
    } 

    def main(args: Array[String]): Unit = { 
    println(test().getClass) 
    } 
}