标签: scalaz7

一个用例示例:

def div2(i: Int): Validation[String, Int] = 
    if (i%2 == 0) Validation.success(i/2)
    else Validation.failure("odd")

def div4(i: Int) = for {
    a <- div2(i)
    b <- div2(a)
} yield b

错误:无法取消应用类型scalaz.Validation[String,Int]到M[_]由类型类别分类的类型构造函数scalaz.Bind

我猜错误是由编译器无法找到的Monad实例引起的Validation[String, Int]

我可以为自己制作一个,比如:

object Instances {
implicit def validationMonad[E] = new Monad[({type L[A] = Validation[E, A]})#L] {
    override def point[A](a: => A) =
        Validation.success(a)
    override def bind[A, B](fa: Validation[E, A])(f: A => Validation[E, B]) =
        fa bind f
} …

可能重复:
好的scalaz介绍

我想了解更多有关Scalaz的信息,可能会使用Scalaz7来避免在声明稳定后重新布线.我的问题是Scalaz包含很多功能.虽然大部分内容都是独立于其他部分,但我希望能够全面了解Scalaz提供的全局功能以及它的组织方式.据我所知,Scalaz除其他外提供了

• Functor,Applicative和Monad特征,
• 新的monad如Validation(编辑:原来它只是一个应用)
• monad变形金刚(OptionT,EitherT....)
• Itereatee小号
• LensES
• Zipper小号

除此之外还有很多隐式转换,以及新的构造函数,例如some与标准库重叠但在类型方面表现更好

:type Some(3) // Some[Int]
:type some(3) // Option[Int]

我对大多数这些结构有基本的把握,但我对任何概念都不熟悉.

您对以何种顺序学习库有什么建议吗？模块之间存在哪些逻辑依赖关系？更一般地说,我在哪里可以找到图书馆的高级概述？

编辑似乎大多数答案都是针对学习函数式编程的基本组件,比如monad,所以我会尝试更精确.我有Haskell的基本知识和数学家背景,所以我的问题与类别理论或基本函数式编程无关.

我的问题是Scalaz是一个庞大的图书馆.我不知道在哪里找到什么,在各种数据类型上有哪些方法可用或有用.我真正需要的是一张地图,例如,它会告诉我,当我想要迭代需要处理的资源时,我可能想要考虑迭代以及我可以用它做什么样的操作.更像是图书馆可用功能的全景.

我是scalaz的新手,我试图找出以下代码的工作原理:

import scalaz._
import Scalaz._
scala> Map[String,List[String]]() |+| Map[String,List[String]]()
res3: scala.collection.immutable.Map[String,List[String]] = Map()

但这不......

import scalaz._
import Scalaz._
scala> Map[String,Seq[String]]() |+| Map[String,Seq[String]]()
<console>:14: error: value |+| is not a member of      scala.collection.immutable.Map[String,Seq[String]]
          Map[String,Seq[String]]() |+| Map[String,Seq[String]]()

我看到Semigroup隐含了Map,但我看不到List或Seq的Map.

情侣问题:

1. ListSemigroup隐含在哪里？
2. 为什么Seq不存在？

也许我错过了一些明显的东西,但我正在尝试清理一个使用Scalaz 7的项目中的一些样板,而我找不到一个看似非常简单且可能有用的特殊拼图.

假设我们有两种类型的双射:

case class Foo(x: Int)
case class Bar(i: Int)

import scalaz._, Scalaz._, BijectionT._

val fb: Foo <@> Bar = bijection[Id, Id, Foo, Bar](
  foo => Bar(foo.x),
  bar => Foo(bar.i)
)

现在假设我们发现我们需要List[Foo]和之间的双射List[Bar].我们可以轻松编写一个提供此功能的隐式类(实际上我们也可以使它适用于任何仿函数):

implicit class BijectionLifter[A, B](val bij: A <@> B) extends AnyVal {
  def liftInto[F[_]: Functor]: F[A] <@> F[B] = bijection[Id, Id, F[A], F[B]](
    _ map bij.to,
    _ map bij.from
  )
}

请注意,这是bimapHaskell的直接翻译Data.Bijection.Scalaz的双射也有一个名为的方法bimap,但它有一个更繁忙的类型,似乎没有以任何明显的方式做我想要的.

现在我们可以写下面的内容:

fb.liftInto[List]

我们得到了我们需要的双射.

我是否遗漏了一些抽象,这使得我可以用Scalaz 7中已经提供的用于双射的函数和实例更清晰地编写它？

我正在学习Scalaz,我有一个已经使用Scalaz7的项目.关注这个问题我想使用这个功能

sequence[T](l: List[Option[T]]): Option[List[T]]

(并不是说我自己写的很难).但上述问题提到了Scalaz6.

在Scalaz7中哪里可以找到序列函数？

我试图了解背后scalaz concurrent包,主要是未来和任务类的想法和目的,但在一些应用程序中使用它们时,它现在从简单的顺序模拟远,然而scala.concurrent.Future,更多的工作更好地然后.任何人都可以分享他使用scalaz编写并发/异步应用程序的经验,基本上如何async正确使用它的方法？据我所知,从源代码async不使用单独的线程,如调用标准future,或fork/applyscalaz工作的方法,那么为什么它被调用async呢？这是否意味着为了与scalaz实现真正的并发,我总是要调用fork(now(...))或apply？

我有一个应用程序,可以对不同的后端系统进行大量调用,并希望使用for-comprehensions来简化后端系统的流程.

我希望结合使用EitherT(scalaz)和Future(scala 2.10),这样我就可以捕获第一个潜在错误(其未来或后端系统问题),并向最终用户返回相应的消息.我已经快速查看了scalaz验证,但是建议捕获第一个错误而不是所有错误都是使用EitherT.

我首先在REPL中尝试一个简单的例子,但是我收到了以下错误

错误:找不到参数F的隐含值:scalaz.Functor [scala.concurrent.Future]

import scala.concurrent._
import scalaz._
import Scalaz._
import ExecutionContext.Implicits.global

type EitherFuture[+A] = EitherT[Future, String, A]

def method1Success : EitherFuture[Int] = {
  println("method 1 success")
  EitherT {
    Future {
      1.right
    }
  }
}

def method2Failure : EitherFuture[Int] = {
  println("method 2 failure")
  EitherT {
    Future {
      "fail".left
    }
  }
}

val m1 = method1Success

// problem
m1.isRight

// problem
def methodChain1 = {
  for {
    a <- method1Success
    b <- method2Failure
  } yield b
}

我仍然是scala和scalaz的新手,所以任何指针都会很棒. …

我在项目中使用scalaz7,有时我会遇到导入问题.最简单的方法是开始

import scalaz._
import Scalaz._

但有时这会导致冲突.到目前为止我一直在做的事情是下面一个有点痛苦的过程:

• 找出一个需要与我的实际代码相同导入的最小示例
• 在单独的项目中复制该示例
• 使用选项编译它,-Xprint:typer以找出隐式解析后代码的外观
• 导入原始项目中所需的含义.

虽然这有效,但我想简化它.我看到scalaz7有更多细粒度的导入,但我不完全了解它们的组织方式.例如,我看到一个人可以做到

import scalaz.std.option._
import scalaz.std.AllInstances._
import scalaz.std.AllFunctions._
import scalaz.syntax.monad._
import scalaz.syntax.all._
import scalaz.syntax.std.boolean._
import scalaz.syntax.std.all._

等等.

这些子进口是如何组织的？

举个例子,假设我想使用验证.我需要什么,例如注入验证含义并进行以下编译？

3.fail[String]

如何制作ValidationNEL[A, B]一个实例Applicative？

有没有人来到一段代码如何正确地将scala的Future(2.10)转换为新的scalaz7未来？我知道热转换scalaz未来通过scala Promise转换为scala Future,但不知道如何正确地做到这一点

例如

import scalaz.concurrent.{Future => Zuture}
import scala.concurrent.Future

我想实施

implicit def scalaF2scalazF[A](in:Future[A]):Zuture[A]=???

然后显然会是一块蛋糕写

implicit def scalaF2scalazTask[A](in:Future[A]):Task[A]=???

因为那是我真正想要的:-)

是否可以在常量堆栈和堆空间中在State monad中执行折叠？或者是一种不同的功能技术更适合我的问题？

接下来的部分将描述问题和激励用例.我正在使用Scala,但Haskell中的解决方案也受到欢迎.

折叠在StateMonad填充堆

假设Scalaz 7.考虑一下州Monad的monadic折叠.为了避免堆栈溢出,我们将蹦蹦跳跳.

import scalaz._
import Scalaz._
import scalaz.std.iterable._
import Free.Trampoline

type TrampolinedState[S, B] = StateT[Trampoline, S, B] // monad type constructor

type S = Int  // state is an integer
type M[B] = TrampolinedState[S, B] // our trampolined state monad

type R = Int  // or some other monoid

val col: Iterable[R] = largeIterableofRs() // defined elsewhere

val (count, sum): (S, R) = col.foldLeftM[M, R](Monoid[R].zero){ 
    (acc: R, x: R) => StateT[Trampoline, S, R] { …