最近斯卡拉兹引起了我的注意.它看起来很有趣,但我没有找到任何关于图书馆的好介绍.看起来scalaz融合了很多来自haskell和数学的想法.我发现的大多数文章都假设您已经对这些概念感到满意.
我正在寻找的是逐步介绍图书馆和基本概念 - 从简单和基本概念到更高级(基于基础).
我也看了一些例子,但是我很难找到应该开始学习库的地方.
有人可以向我推荐一些好的scalaz介绍或教程(涵盖基础知识和高级概念)吗？或者在答案中给我起点.
谢谢大家的好消息!我总结了所有的答案,并在我的博客中添加了一些链接:
http://hacking-scala.org/post/49050104489/scalaz-resources-for-beginners
对于那些寻找Scalaz API文档的人来说,他们在这里:
http://docs.typelevel.org/api/scalaz/nightly/index.html#package
我是否理解这一点
def 每次访问时都会进行评估
lazy val 一旦被访问就被评估
val 进入执行范围后进行评估？
在我当前的项目中,我们总是在java源文件的末尾插入空的新行.我们还使用CheckStyle(具有错误级别)强制执行此操作.
我很长一段时间都在寻找这个话题,但不幸的是我找不到任何令人信服的理由.似乎其他开发人员对此非常漠不关心,因为他们只是在eclipse格式化程序中选中了一个复选框,并且它是自动完成的.但我仍然不知道为什么需要它,为什么它可能很重要).所以我的问题是:
为什么Java源文件末尾的空行需要？它是当前的需求还是过去的遗留物,在目前的代码库中是不可取的？
这是一个Scala会话,它定义并尝试了一些函数:
scala> def test1(str: String) = str + str;
test1: (str: String)java.lang.String
scala> test1("ab")
res0: java.lang.String = abab
很好地工作.
scala> val test2 = test1
<console>:6: error: missing arguments for method test1 in object $iw;
follow this method with `_' if you want to treat it as a partially applied function
val test2 = test1
^
哎呀.
scala> val test2 = test1 _
test2: (String) => java.lang.String = <function1>
scala> test2("ab")
res1: java.lang.String = abab
效果很好!
现在,我已经看到_折叠时的语法(_ + …
我经常遇到以下情况:假设我有这三个功能
def firstFn: Int = ...
def secondFn(b: Int): Long = ...
def thirdFn(x: Int, y: Long, z: Long): Long = ...
我也有calculate功能.我的第一种方法可能如下所示:
def calculate(a: Long) = thirdFn(firstFn, secondFn(firstFn), secondFn(firstFn) + a)
它看起来很漂亮,没有任何花括号 - 只有一个表达式.但它不是最佳的,所以我最终得到了这个代码:
def calculate(a: Long) = {
val first = firstFn
val second = secondFn(first)
thirdFn(first, second, second + a)
}
现在有几个用大括号括起来的表达式.在这样的时刻,我羡慕Clojure一点点.使用let函数我可以在一个表达式中定义此函数.
所以我的目标是calculate用一个表达式定义函数.我想出了两个解决方案.
1 - 使用scalaz我可以像这样定义它(有更好的方法用scalaz做到这一点吗？):
def calculate(a: Long) =
firstFn |> {first => secondFn(first) |> {second => …这个问题困扰了我一段时间了(我希望我不是唯一的一个).我想采用一个典型的3层Java EE应用程序,看看它可能看起来像是用actor实现的.我想知道是否真的有意义进行这样的转换以及如果它确实有意义我可以从中获利(可能是性能,更好的架构,可扩展性,可维护性等等).
这是典型的Controller(演示),服务(业务逻辑),DAO(数据):
trait UserDao {
def getUsers(): List[User]
def getUser(id: Int): User
def addUser(user: User)
}
trait UserService {
def getUsers(): List[User]
def getUser(id: Int): User
def addUser(user: User): Unit
@Transactional
def makeSomethingWithUsers(): Unit
}
@Controller
class UserController {
@Get
def getUsers(): NodeSeq = ...
@Get
def getUser(id: Int): NodeSeq = ...
@Post
def addUser(user: User): Unit = { ... }
}
你可以在许多弹簧应用中找到类似的东西.我们可以采用没有任何共享状态的简单实现,因为没有同步块...所以所有状态都在数据库中,应用程序依赖于事务.服务,控制器和dao只有一个实例.因此,对于每个请求,应用程序服务器将使用单独的线程,但线程不会相互阻塞(但将被DB IO阻止).
假设我们正在尝试与actor实现类似的功能.它看起来像这样:
sealed trait UserActions
case class GetUsers extends UserActions
case class GetUser(id: Int) extends UserActions …我正在看SubCut和Scaldi在我的项目中使用.各自的入门文档中提供的示例看起来非常相似.这两个项目似乎都没有提供Getting Started和scala docs 之外的文档.
有人可以总结这些框架之间的实际差异,主要是在特征和成熟度/稳定性方面.我正在研究这些包,因为我需要能够在运行时动态创建和组合配置.运行时配置是我查看这些库而不是使用implicits和/或层蛋糕模式进行DI /配置的主要原因,因此运行时配置工具对我来说是最重要的.另外我不认为编译器插件对我来说是一个选项,但是这两个库都可以在没有各自插件的情况下使用,而且冗长度只有很小的增加.我现在在scala-2.9.2上.
我也对直接在Scala中进行运行时DI /配置的建议感兴趣,但是将我的整个项目转换为monadic样式对我来说也不是一个选项.
在scala中,这两种导入策略有什么区别
选项1
import com.somepackage
class MyClass {
//further code
}
选项2
class MyClass {
import com.somepackage
//further code
}
我认为用具体的例子来描述问题会更容易.假设我有Fruit类层次结构和Show类型类:
trait Fruit
case class Apple extends Fruit
case class Orange extends Fruit
trait Show[T] {
def show(target: T): String
}
object Show {
implicit object AppleShow extends Show[Apple] {
def show(apple: Apple) = "Standard apple"
}
implicit object OrangeShow extends Show[Orange] {
def show(orange: Orange) = "Standard orange"
}
}
def getAsString[T](target: T)(implicit s: Show[T]) = s show target
我还有一些我希望向用户展示的水果列表Show (这是我在这个问题中的主要目标):
val basket = List[Fruit](Apple(), Orange())
def printList[T](list: List[T])(implicit s: Show[T]) =
list …假设有类/特征定义如下:
trait T1 {}
trait T2 {}
abstract class A{}
class B {}
class C extends A with T1 with T2 {}
val b = new B with T1
val c = new C
给定b和c的实例,我如何获得它们的继承信息(即知道b实现T1,c实现A,T1和T2)？
谢谢你的帮助.