标签: scalaz

我想调用Scalaz的pure方法将值放入State monad.以下作品:

type IntState[A] = State[Int, A]
val a = "a".pure[IntState]
a(1)
    (Int, java.lang.String) = (1,a)

我也可以删除类型别名(感谢Scalaz的Pure.scala):

val a = "a".pure[({type T[A]=State[Int,A]})#T]
a(1)
    (Int, java.lang.String) = (1,a)

但这非常笨重.是否有更短的方法来合成这样的类型？就像函数文字的占位符语法一样,有类似的东西:

"a".pure[State[Int, *]]

是否可以在常量堆栈和堆空间中在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] { …

最近,我一直在玩scalaz.iteratee和Play的iteratee.我认为iteratee是一个很好的想法,提供模块化而不是旧的命令循环 - 目的是使用一个函数作为每个新行的处理程序,而不是从文件中获取字符串[].

但是,当我查看scalaz.stream的功能概述时,它提到它的设计是取代旧的iteratee实现,但它没有提到为什么要替换它.

有人可以向我解释我们是否可以使用Stream,我们可以获得哪些功能和优点以及使用iteratee有什么缺点？

假设我的整个项目配置很简单build.sbt:

scalaVersion := "2.11.4"

libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.1.0"

这是我的代码:

import scalaz.Equal
import scalaz.syntax.equal._

object Foo {
  def whatever[A: Equal](a: A, b: A) = a === b
}

现在,当我sbt doc在浏览器中运行并打开API文档时,我会看到scalazScalaDoc根包列表中的包,以及我的Foo:

object Foo
package scalaz

或者,如果你不相信我:

我之前已经注意到了Scalaz,并且我不是唯一一个它(例如参见当前发布的Argonaut API文档版本).我不确定我是否看到Scalaz以外的任何库都会发生这种情况.

如果我在项目代码中实际上没有使用Scalaz中的任何内容,则它不会显示出来.同样的事情发生在至少2.10.4和2.11.4.

为什么scalaz包装出现在这里以及如何让它停止？

阅读了这本书,了解了一本Haskell For Great Good,以及非常有用的维基书籍Haskell分类理论帮助我克服了将类别对象与编程对象混淆的常见类别错误,我仍然有以下问题:

为什么必须fmap映射List的每个元素？

我喜欢它,我只想理解这在理论上是如何合理的.(或者更容易证明使用HoTT？)

在Scala表示法中,List是一个仿函数,它接受任何类型并将其映射到所有列表类型集合中的类型,例如,它将类型映射Int到类型List[Int],并将函数映射到Int例如

• Int.successor: Int => Int 至 Functor[List].fmap(successor) : List[Int] => List[Int]
• Int.toString: Int => String 至 Functor[List].fmap(toString): List[Int] => List[String]

现在每个实例List[X]都是一个带有empty函数(mempty在Haskell中)和combine函数(mappend在Haskell中)的monoid .我的猜测是,人们可以使用列表是Monoids的事实,以表明map必须映射列表的所有元素.我的感觉是,如果添加了pureApplicative的函数,这给了我们一个只包含其他类型元素的列表.例如Applicative[List[Int]].pure(1) == List(1).因为map(succ)在这些元素上给我们带有下一个元素的单例列表,所以这涵盖了所有这些子集.然后我想combine所有这些单身人士的功能都会给我们列出所有其他元素.不知怎的,我想这限制了地图的工作方式.

另一个暗示性的论点是map必须在列表之间映射函数.由于a中的每个元素List[Int]都是Int类型,并且如果一个映射到List[String]一个元素必须映射它的每个元素,或者一个元素不是正确的类型.

所以这两个论点似乎都指向了正确的方向.但我想知道剩下的方式需要什么.

反例？ …

我们在项目中使用scalaz验证特性来验证HTTP参数.常见的情况是,只有在所有值都有效的情况下,只需要很少的验证值并执行必要的操作,否则返回错误列表:

(pavam1Val.liftFailNel |@|
 param2Val.liftFailNel |@|
 param3Val.liftFailNel) {
    getSomeResponse(_, _, _)
}

这很好用,直到我们必须使用8个以上的参数,因为| @ | operator构造ApplicativeBuilder,限制为8个参数.是否有其他方法可以执行此类一次性验证,最好是保持代码可读？

我一直在寻找,但我找不到隐含的转换器.写一篇文章显然是微不足道的,但我想知道我是否错过了某个scalaz库中的一个!

这里真的很简单.看完镜头的精彩介绍后:

http://www.youtube.com/watch?v=efv0SQNde5Q

我想我可能会尝试谈谈中的一个简单例子:

import scalaz.Lens._
fst.andThen(snd).set(((1,2),3),9)

之后是这个错误

error: type mismatch;
 found   : scalaz.Lens[(Nothing, Nothing),Nothing]
 required: scalaz.Lens[(Nothing, Nothing),C]
Note: Nothing <: C, but class Lens is invariant in type B.
You may wish to define B as +B instead. (SLS 4.5)
              fst.andThen(snd).set(((1,2),3))
                      ^

有关如何使这项工作的任何想法？

是否有函数/ Scala方法重复调用函数,直到成功,同时对失败的尝试作出反应？

让我举一个例子来说明.假设我想从标准输入中读取一个整数,如果用户实际上没有输入整数,则重试.

鉴于此功能:

def read_int(): Either[String, Int] = {
  val str = scala.io.StdIn.readLine()
  try {
    Right(str.trim().toInt)
  } catch {
    case _: java.lang.NumberFormatException => Left(str)
  }
}

而这个匿名函数:

val ask_for_int = () => {
  println("Please enter an Int:")
  read_int()
}

val handle_not_int = (s: String) => {
  println("That was not an Int! You typed: " + s)
}

我会像这样使用它们:

val num = retry_until_right(ask_for_int)(handle_not_int)
println(s"Thanks! You entered: $num")

我的问题是:

• retry_until_rightScala中已存在类似的东西吗？
• 可以用现有设施解决吗？(流,迭代器,Monad等)
• 任何FP库(scalaz？)都提供这样的东西吗？
• 我可以做更好/更惯用的事情吗？(*)

谢谢!

*)除了snake_case.我真的很喜欢

这两种Scalaz类型

• scalaz.concurrent.Task[+A]
• scalaz.effect.IO[A]

看起来在概念上非常相似.他俩:

• 表示潜在的副作用计算
• 产生success(A)或failure(Exception)结果
• 有Monad实例
• 可以用run或不安全地打开unsafePerformIO

他们有什么不同？为什么它们都存在？