选择模式使用

我有以下特点，其中：选择模式使用

sealed trait Sum[+A, +B] { 
    def fold[C](error: A => C, success: B => C): C = 
    this match { 
     case Failure(v) => error(v) 
     case Success(v) => success(v) 
    } 
} 
final case class Failure[A](value: A) extends Sum[A, Nothing] 
final case class Success[B](value: B) extends Sum[Nothing, B]

正如你可以看到，有一个fold方法实现。

我可以在fold方法移到一个同伴对象如下：

sealed trait Sum[+A, +B] 
final case class Failure[A](value: A) extends Sum[A, Nothing] 
final case class Success[B](value: B) extends Sum[Nothing, B] 

object Sum{ 
    def fold[A, B, C](s: Sum[A,B], error: A => C, success: B => C): C = 
     s match { 
      case Failure(v) => error(v) 
      case Success(v) => success(v) 
     } 
}

什么是更方便的模式，在第一或第二例子，其中的情况呢？

来源

2017-04-04 zero_coding

第二个不起作用，因为它指向Sum伴随对象，并且未定义类型变量A和B.

因此使用第一种模式！

来源

2017-04-04 09:22:53 Harald

对不起，这是我的错，我纠正了代码。 –

您仍然在折叠方法中使用它，它始终是Sum伴随对象 – Harald

IT现在应该没问题。 –

后者可能无法按预期工作，因为this在这种情况下是对象Sum而不是Failure或Success的实例。无论如何，我希望移居的实现来区分等级：

case class Failure[A](value: A) extends Sum[A, Nothing] { 
     def fold[C](error: A => C, success: B => C): C = error(value) 
    } 

    case class Success[A](value: B) extends Sum[A, Nothing] { 
     def fold[C](error: A => C, success: B => C): C = success(value) 
    }

来源

2017-04-04 09:26:32

当然，你必须在基本特征中声明'def fold ...' –

抱歉，这是我的错，我更正了代码 –

我更喜欢第一个（或托马斯Perek的回答修改）。第二应改为

def fold[A, B, C](s: Sum[A,B])(error: A => C, success: B => C): C = 
    s match { 
     case Failure(v) => error(v) 
     case Success(v) => success(v) 
    }

，这样编译器已经知道A和B通过它获取到类型检查的error和success参数的时间。

来源

2017-04-04 17:09:11

选择模式使用

回答

相关问题