标签: scalaz7

阅读http://eed3si9n.com/learning-scalaz/Tagged+type.html并尝试示例代码:

import scalaz._; import Scalaz._

sealed trait KiloGram
def KiloGram[A](a: A): A @@ KiloGram = Tag[A, KiloGram](a)
val mass = KiloGram(20.0)
2 * mass

根据指南,应该屈服于40.0Scala 2.11.2我得到:

scala> 2 * mass
<console>:17: error: overloaded method value * with alternatives:
  (x: Double)Double <and>
  (x: Float)Float <and>
  (x: Long)Long <and>
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int
 cannot be applied to (scalaz.@@[Double,KiloGram])
              2 * mass
                ^

而

2 * mass.asInstanceOf[Double]

工作得很好.

那是2.10 vs 2.11还是我错过了什么？如果我不能像这样(不再)使用它们并且必须求助于显式转换,那么未装箱的标记类型有什么意义呢？

有没有办法,如何point在Reader上下文中轻松获得价值？
我可以使用Readerobject并忽略上下文:

Reader {
  _ ? 3
}

无法弄清楚是否可以使用Scalaz 7编写类似的内容.我试图用代码块中的注释表达自己.

def validate1(p: String) = ValidationNel[String, Value] = ...
def validate2(p: String) = ValidationNel[String, Value] = ...

validateCombination(p1: String, p2: String) = {
  // I would like to write something like
  (validate1(p1) |@| validate2(p2)) { (v1, v1) =>
    // And validate the combinations here and return successNel of failNel
  }
}

def validate(p1: String, p2: String, p3: String) = {
  (validateCombination(p1, p2) |@| validate1(p3)) { (v1, v2, v3) =>
    // Notice the three parameters I want to have here …

当我使用Scalaz进行编码时,我经常遇到问题,范围内没有隐含的内容.我认为在大量的软件包scalaz中应该存在一些默认的含义,但要么我不知道哪里有没有.

假设我们想要show任何Anyscalaz(我使用scalaz 7):

scala>     import scalaz._
import scalaz._

scala>     import Scalaz._
import Scalaz._

scala>     {def a: Any = "sratatata"; a}.show
<console>:14: error: could not find implicit value for parameter F0: scalaz.Show[Any]
{def a: Any = "sratatata"; a}.show
^

这是行不通的Show[Any],因为范围没有隐含.

为什么Scalaz不提供它？使用某些全球性的好方法是Show[A]什么？我的意思是这样的:

scala> implicit def anyShow[A] = Show.showFromToString[A]
anyShow: [A]=> scalaz.Show[A]

scala> {def a: Any = "sratatata"; a}.show
res0: scalaz.Cord = sratatata

我觉得同样的感觉Equal.

编辑

我已经尝试在添加的答案中提到,import scalaz.syntax.ShowSyntax但这并不能解决我的问题.看到:

scala>     import scalaz._
import …

我有下一个代码

val listOption: List[Option[Int]] = List(1.some, none, 2.some)

我想折叠元素,我写下一个代码

val result = listx.fold(0.some)((acc, el) => {
  (acc, el) match {
    case (Some(a), Some(b)) => Some(a + b)
    case (Some(a), _) => Some(a)
    case (_, Some(b)) => Some(b)
    case _ => el
  }
})
println(result.getOrElse(0)) // => 3 

这工作得很好,但我在scalaz来源中看到下一个三重奏

val composeFold = Foldable[List] compose Foldable[Option]
composeFold.fold(listOption) // => 3

但我不明白它是如何正确的工作,以及为什么scalaz不将这些方法混合到listOption实例中,以及scala fold和scalaz 之间的区别fold

下划线中的下划线意味着什么.这是scalaz7库的片段:

trait Apply[F[_]] extends Functor[F] { self =>
  //...
  def ap[A, B](fa: => F[A])(f: => F[A => B]): F[B]
  //...
  def apF[A, B](f: => F[A => B]): F[A] => F[B] = ap(_)(f)   // <----HERE
  //...
}

使用它的一般规则是什么？

是否有可能将异构向量的向量转换为Scala中的Tuple3列表

即

Vector(Vector(1,"a","b"),Vector(2,"b","c")) to List(Tuple3(1,"a","b"),Tuple3(2,"b","c"))

我对scalaz很新,我正试图将各种类型转换为monad变换器.

我坚持试图将a转换Int为a OptionT[Future, Int],甚至转换为EitherT[Future, String, Int].

我发现了一堆教程/ SO答案,解释了如何使用它point,但由于某种原因我无法编译它们.

例如,该段从这里:

1.point[({ type L[x] = EitherT[Future, String, x] })#L]

错误:(9,9)找不到类型的证据参数的隐含值 scalaz.Applicative[[x]scalaz.EitherT[scala.concurrent.Future,String,x]]

另一个来自Scalaz Monad变形金刚

type Result[A] = OptionT[Future, A]
"".point[Result]

错误:(8,10)找不到类型的证据参数的隐含值 scalaz.Applicative[A$A35.this.Result]

我相信这个应该也可以,但它说方法liftM不是以下成员Future[Int]:

1.point[Future].liftM[OptionT]    //doesnt compile
1.point[List].liftM[OptionT]      //compiles

所有这些示例都失败了,但是如果我替换Future,比如说,它们会编译List.现在,这是对我有用的唯一方式,但它有点冗长 - 我真的希望能够使用point:

OptionT(Future.successful(1.some))

为什么这不编译？Future在最近的版本中,应用/ monad是否已从scalaz中移除？

我正在使用scala 2.11.7和scalaz 7.1.3.对于它的价值,这些是我的进口:

import scala.concurrent.Future
import scalaz._
import Scalaz._