Question

简而言之，我想声明一个这样的特征：

trait Test {
    def test(amount: Int): A[Int] // where A must be a Monad
}

这样我就可以在不知道A是什么的monad的情况下使用它，例如：

class Usecase {
    def someFun(t: Test) = for { i <- t.test(3) } yield i+1
}

更多细节......

基本上，我想做这样的事情：

class MonadResultA extends SomeUnknownType {
    // the base function
    def test(s: String): Option[Int] = Some(3)
}

class MonadResultB(a: MonadResultA) extends SomeUnknownType {
    // added a layer of Writer on top of base function
    def test(s: String): WriterT[Option, String, Int] = WriterT.put(a.test(s))("the log")
}

class Process {
    def work(x: SomeUnknownType) {
        for {
            i <- x.test("key")
        } yield i+1
    }
}

我希望能够传递MonadResultA 或 MonadResultB的任何实例，而不对功能work进行任何更改。
缺少的部分是SomeUnknowType，我想下面应该有一个test来编译work函数。

trait SomeUnknowType {
    def test(s: String): T[Int] // where T must be some Monad
}

正如我所说，我仍在学习这个monad的东西...如果你发现我的代码不是正确的方式，那么你会受到欢迎。出〜

非常感谢~~

Answer 1

假设你有一个名为Monad的类型类，你可以写

def test[A:Monad](amount: Int): A[Int]

编译器将要求在调用test时在范围内隐含类型Monad[A]。

修改我仍然不确定你在寻找什么，但是你可以将monad值和相应的类型类打包成这样的特征：

//trait that holds value and monad trait ValueWithMonad[E] { type A[+E] type M <: Monad[A] val v:A[E] val m:M } object M { //example implementation of test method def test(amount:Int):ValueWithMonad[Int] = new ValueWithMonad[Int] { type A[+E] = Option[E] type M = Monad[Option] override val v = Option(amount) override val m = OptionMonad } //test can now be used like this def t { val vwm = test(1) vwm.m.bind(vwm.v, (x:Int) => { println(x) vwm.m.ret(x) }) } } trait Monad[A[_]] { def bind[E,E2](m:A[E], f:E=>A[E2]):A[E2] def ret[E](e:E):A[E] } object OptionMonad extends Monad[Option] { override def bind[E,E2](m:Option[E], f:E=>Option[E2]) = m.flatMap(f) override def ret[E](e:E) = Some(e) }

如何将函数的返回类型指定为（任意）monad？

1 个答案: