小编Jam*_*ies的帖子

是否可以链接scala.util.Try和scala.concurrent.Future？它们都有效地提供相同的monadic接口,但是尝试链接它们会导致编译错误.

例如.鉴于下面的两个签名

def someFuture:Future[String] = ???
def processResult(value:String):Try[String] = ???

可以做以下的事情吗？

val result = for( a <- someFuture; b <- processResult( a ) ) yield b;
result.map { /* Success Block */ } recover { /* Failure Block */ }

这显然会导致编译错误,因为Future和Try无法一起进行flatMapp.

然而,能够链接它们是一个很好的功能 - 这是否可能？或者我是否需要将它们组合成一个Future [Try [String]]？

(特别是,我有兴趣使用单个'recover'块来捕获未来或 try中的异常).

假设我有一对转换函数

string2int :: String -> Maybe Int
int2string :: Int -> String

我可以使用Optics轻松地代表这些.

stringIntPrism :: Prism String Int

但是,如果我想表示失败原因,我需要将它们作为两个单独的函数保留.

string2int :: String -> Validation [ParseError] Int
int2string :: Int -> String`

对于这个简单的例子Maybe非常好,因为我们总是可以假设失败是解析失败,因此我们实际上不必使用Either或Validation类型对此进行编码.

但是想象一下,除了解析Prism之外,我还想进行一些验证

isOver18 :: Int -> Validation [AgeError] Int
isUnder55 :: Int -> Validation [AgeError] Int

将这些东西组合在一起是理想的,这样我就可以拥有

ageField = isUnder55 . isOver18 . string2Int :: ValidationPrism [e] String Int

这对于手工构建来说是相当微不足道的,但是它似乎是一个普遍的概念,在镜头/光学领域潜藏着可能存在的东西.是否存在处理此问题的现有抽象？

TL;博士

是否有一种标准的方法来实现部分镜头/棱镜/ iso,可以通过任意仿函数进行参数化,而不是直接绑定到Maybe？.

我上面使用了Haskell表示法,因为它更直接,但我实际上是在Scala中使用Monocle来实现它.但是,对于ekmett的Lens库特定的答案,我会非常满意.

接收事件时,Akka Actors将一次处理一条消息,阻塞直到请求完成,然后再转到下一条消息.

这适用于同步/阻塞任务,但是如果我想执行异步/非阻塞请求,Akka将继续处理而无需等待任务完成.

例如:

 def doThing():Future[Unit] = /* Non blocking request here */

 def receive = {
     case DoThing => doThing() pipeTo sender
 } 

这将调用doThing()并开始处理未来,但在处理下一条消息之前不会等待它完成 - 它将尽可能快地执行队列中的下一条消息.

实质上,似乎Akka认为"返回未来"是"完成处理"并转移到下一条消息.

为了一次处理一条消息,似乎我需要主动阻止Actor线程来阻止它这样做

def receive = {
    case DoThing => sender ! blocking(Await.result(doThing()))
}

这感觉就像一个非常错误的方法 - 它是人为地阻塞代码中的一个线程,否则它应该是完全无阻塞的.

当将Akka与Elixir演员比较时,我们可以通过使用尾调用来请求下一条消息而不需要人为阻塞来轻松避免这个问题.

在Akka还有什么办法吗？

a)等待a Future完成,然后处理下一条消息而不阻塞线程.

b)使用显式尾调用或其他一些机制来使用基于拉的工作流而不是基于推送？

我已经创建了一个执行一些基本操作的Actor并且看起来工作正常 - 但是我看到我的日志定期显示以下内容

[INFO] [05/28/2014 14:24:00.673] [application-akka.actor.default-dispatcher-5] [akka://application/deadLetters] Message [akka.actor.Status$Failure] from Actor[akka://application/user/trigger_worker_supervisor#-2119432352] to Actor[akka://application/deadLetters] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.

我想实际查看失败的内容,以确定究竟是什么抛出一个Failure,但是我无法弄清楚如何查看它们.

通过阅读Akka文档,它提到了如何在日志中禁用死信警告,而不是如何实际编写处理程序来处理它们.

有没有一种简单的方法来实际捕获任何发送到死信的东西？

Haskell提供了一个标准类型类"替代",它有效地<|>为任何类型的应用程序提供操作符.

正如我所理解的那样,Alternative被认为是一个关于Applicative的Monoid,但是<|>运算符似乎在许多不是Applicative Functors的类型中都是完全有意义的,并且不需要对Applicative类类的任何特定依赖它工作正常.

是否有一个理由为什么Alternative需要成为Applicative的子类,如果有的话,是否有一个标准的类型类来定义非应用类型的类似功能？

我知道这通常是相当愚蠢的,但在阅读这个问题之前不要开枪.我保证我有充分的理由需要这样做:)

可以使用反射修改java中的常规私有字段,但是在尝试对final字段执行相同操作时,Java会引发安全性异常.

我认为这是严格执行的,但无论如何我都会问,以防万一有人想出一个黑客来做这件事.

我只想说我有一个带有" SomeClass" 类的外部库

public class SomeClass 
{
  private static final SomeClass INSTANCE = new SomeClass()

  public static SomeClass getInstance(){ 
      return INSTANCE; 
  }

  public Object doSomething(){
    // Do some stuff here 
  }
} 

我基本上想要Monkey-Patch SomeClass,以便我可以执行我自己的版本doSomething().由于没有(据我所知)在java中真正做到这一点的任何方法,我在这里唯一的解决方案是改变它的值,INSTANCE因此它返回我修改后的方法的类版本.

基本上我只想用安全检查包装调用,然后调用原始方法.

外部库总是getInstance()用来获取这个类的实例(即它是一个单例).

编辑:只是澄清,getInstance()由外部库调用,而不是我的代码,所以只是子类化不会解决问题.

如果我不能这样做,我能想到的唯一其他解决方案是复制粘贴整个类并修改方法.这并不理想,因为我必须更新库以更新库.如果某人有更多可维护的东西,我愿意接受建议.

是否可以在Scala构造函数中使用命名参数,稍后在不破坏构造函数接口或使代码非常难看的情况下覆盖getter和setter？

采取以下scala代码

class Person( var FirstName: String, var LastName: String )

干净整洁.这将创建一个名为person的简单类,我们可以通过以下方式使用它

val john = new Person( FirstName="John", LastName="Doe" )
john.FirstName = "Joe"
println( john.FirstName )

稍后,我们决定要为FirstName setter添加一些验证.因此,我们创建一个新的私有局部变量并覆盖getter和setter方法

class Person( var _FirstName: String, var _LastName: String ) {

    def FirstName = _FirstName  
    def FirstName_= (value:String) = _FirstName = value

}

仍然有点干净,但是为了做到这一点,我们必须更改构造函数参数名称,从而破坏外部接口.

我想出的第一个解决这个问题的方法是

class Person {
    var _FirstName:String = null 
    var LastName:String  = null

    def FirstName = _FirstName  
    def FirstName_= (value:String) = _FirstName = value

    def this( FirstName: String, LastName: String …

我试图从AngularJs(1.0.7)中的promise中返回单个记录,并将结果绑定到表单.表单绑定正确,但输入字段是只读的 - 我无法编辑值.

相反,如果我将记录包装在一个数组中并使用ng:repeat进行迭代,则表单正确绑定,我可以编辑值.

我已经创建了一个能够清楚地说明问题的plnkr:

http://embed.plnkr.co/fOWyhVUfekRbKUSRf7ut/preview

您可以编辑直接绑定和列表绑定输入字段,但是无法编辑绑定到单个promise的字段.

是否可以将ng:model直接绑定到promise的返回对象,或者我是否需要使用数组才能使其工作？

app.controller('MainCtrl', function($scope, $timeout, $q) {

  var person = {"name": "Bill Gates"}

  var deferList = $q.defer();
  var deferSingle = $q.defer();

  // Bind the person object directly to the scope. This is editable.
  $scope.direct = person;       

  // Bind a promise to the scope that will return a list of people. This is editable.
  $scope.list   = deferList.promise;

  // Bind ap romise to the scope that will return a single person record. This is *not* editable. …

使用scalaz-stream是可以拆分/分叉然后重新加入流？

举个例子,假设我有以下功能

val streamOfNumbers : Process[Task,Int] = Process.emitAll(1 to 10)

val sumOfEvenNumbers = streamOfNumbers.filter(isEven).fold(0)(add)
val sumOfOddNumbers  = streamOfNumbers.filter(isOdd).fold(0)(add)

zip( sumOfEven, sumOfOdd ).to( someEffectfulFunction )

使用scalaz-stream,在此示例中,结果将如您所期望的那样 - 从1到10的数字元组传递到接收器.

但是,如果我们用streamOfNumbers需要IO的东西替换它,它实际上会执行两次IO动作.

使用Topic我能够创建一个正确复制流中元素的发布/订阅过程,但它不会缓冲 - 它只是尽可能快地消费整个源,而不管它的节奏接收器消耗它.

我可以将它包装在一个有界的队列中,但最终结果感觉要比它需要的复杂得多.

是否有更简单的方法在scalaz-stream中拆分流而没有来自源的重复IO操作？

我正在尝试编写一个简单的查询monad,并且无法使我的泛型类型注释正确.

我的第一次尝试如下(为简洁而大大简化)

case class Person( val name: String )
abstract class Schema[T]    
object People extends Schema[Person]

case class Query[U <: Schema[T], T]( schema: U ) {      <---- Type signature
    def results: Seq[T] = ...
    def where( f: U => Operation ) = ...
}

class TypeText extends Application {
    val query = Query( People )                     <---- Type inference fails
}

编译器不喜欢这样,因为它无法推断'T'的类型.

错误:推断类型参数[People.type,Nothing]不符合方法apply的类型参数bounds [U <:Schema [T],T]

在进行实验时,我发现使用视图边界可以按预期工作

case class Query[U <% Schema[T], T]( schema: U ) {

(注意使用视图绑定"<%"而不是类型绑定"<:")

然而,由于我对类型系统的理解有限,因为我期待Schema …