小编ron*_*ron的帖子

有时我偶然发现了半神秘的符号

def f[T](..) = new T[({type l[A]=SomeType[A,..]})#l] {..} 

在Scala博客文章中,它给了它一个"我们使用那种类型 - lambda技巧"的手动波.

虽然我对此有一些说明(我们获得了一个匿名类型参数A而不必用它来污染定义？),我发现没有明确的来源描述类型lambda技巧是什么,以及它有什么好处.它只是语法糖,还是开了一些新的维度？

我在GHCI遇到一个奇怪的情况,不知道是否有人观察过类似的情况.对于一些模块,当我有它在搜索路径都通过-package-conf,也可以通过-i,GHCI当我尝试导入与模块发生故障'module is not loaded: FooModule'.

• :module 但加载它很好
• 或者我可以做:load FooModule,:m清除导入列表,然后import FooModule
• 或者我可以删除路径-i然后导入正常

跟踪这是GHC中的otherwise -> modNotLoadedError m loc情况,其中〜(其中我不知道的含义).otherwisemodulePackageId = this_pkg

这不是完全系统化的,有一些模块既包含在源包中,也包含在源包中,但可以导入.

浏览Hackage时,大多数monad都有Lazy和Strict版本.有什么区别？你能用一些常见的monad(State,Reader,Writer)的例子来突出它吗？

执行定义的IO操作时someFun <$> (a :: IO ()) <$> (b :: IO ()),是否执行了a和已执行的b操作？也就是说,我可以指望a之前执行的b是吗？

对于GHC,我可以看到IO是使用State实现的,并且在这里也看到它是一个Applicative实例,但是找不到实际实例声明的来源.通过State实现表明不同的IO效果需要是连续的,但不一定要定义它们的顺序.

在GHCi中玩耍似乎Appliative保留了效果顺序,但这是一些普遍的保证,还是GHC特定的？我会对细节感兴趣.

import System.Time
import Control.Concurrent
import Data.Traversable
let prec (TOD a b) = b
fmap (map prec) (sequenceA $ replicate 5 (threadDelay 1000 >> getClockTime))

[641934000000,642934000000,643934000000,644934000000,645934000000]

谢谢!

这个问题是关于处理混合非接口特征的类的测试,这是包含一些功能的特征.在测试时,类功能应该与混合特性(假设单独测试)提供的功能隔离.

我有一个简单的Crawler类,它依赖于HttpConnection和一HttpHelpers组实用函数.现在让我们关注HttpHelpers.

在Java中,HttpHelpers可能是一个实用程序类,并且可以将其单例作为依赖项传递给Crawler,无论是手动还是使用某些IoC框架.测试Crawler非常简单,因为依赖项很容易被模拟.

在Scala中,似乎辅助特征是组合功能的更优选方式.实际上,它更容易使用(扩展时自动导入命名空间的方法,可以withResponse ...代替使用httpHelper.withResponse ...等).但它如何影响测试？

这是我提出的解决方案,但遗憾的是它将一些样板提升到测试端.

助手特质:

trait HttpHelpers {
  val httpClient: HttpClient
  protected def withResponse[A](resp: HttpResponse)(fun: HttpResponse => A): A = // ...
  protected def makeGetRequest(url: String): HttpResponse = // ...
}

要测试的代码:

class Crawler(val httpClient: HttpClient) extends HttpHelpers {
  // ...
}

测试:

// Mock support trait
// 1) Opens up protected trait methods to public (to be able to mock their invocation)
// 2) …

当编写在Stream(s)上运行的函数时,存在不同的递归概念.第一个简单的意义在编译器级别上不是递归的,因为如果不立即计算尾部,那么函数会立即返回,但返回的流是递归的:

final def simpleRec[A](as: Stream[A]): Stream[B] = 
  if (a.isEmpty) Stream.empty              
  else someB(a.head) #:: simpleRec(a.tail) 

上述递归概念不会引起任何问题.第二个是在编译器级别上真正的尾递归:

@tailrec
final def rec[A](as: Stream[A]): Stream[B] = 
  if (a.isEmpty) Stream.empty              // A) degenerated
  else if (someCond) rec(a.tail)           // B) tail recursion
  else someB(a.head) #:: rec(a.tail)       // C) degenerated

这里的问题是C)编译器将该情况检测为非tailrec调用,即使没有执行实际调用.这可以通过将流尾部分解为辅助函数来避免:

@tailrec
final def rec[A](as: Stream[A]): Stream[B] = 
  if (a.isEmpty) Stream.empty              
  else if (someCond) rec(a.tail)          // B)
  else someB(a.head) #:: recHelp(a.tail)  

@tailrec
final def recHelp[A](as: Stream[A]): Stream[B] = 
  rec(as)

在编译时,这种方法最终会导致内存泄漏.由于尾递归rec最终是从recHelp …

我明白了

instance (Foo a) => Bar a
instance (Xyy a) => Bar a

GHC不考虑上下文,并且实例报告为重复.

什么是违反直觉的,(我猜)在选择实例后,它仍然需要检查上下文是否匹配,如果不匹配,则丢弃实例.那么为什么不反转顺序,并丢弃具有不匹配上下文的实例,并继续使用剩余的集合.

这会在某种程度上难以解决吗？我看到它如何能够在前期引起更多的约束解析工作,但就像有UndecidableInstances/ IncoherentInstances,不可能有ConsiderInstanceContexts"我知道我在做什么"的时候？

如果我有一个操作Application.show(tag: String),并且还有相应的路由条目,如何在不手动创建URL的情况下将此操作的链接插入模板？

我想做点什么magiclink(Application.show("tag")).

的apidoc distinct中SeqLike说:

从此序列构建新序列,不带任何重复元素.返回:包含此序列的每个元素的第一个匹配项的新序列.

我觉得没有提供订购保证是否正确？更一般地说,SeqLike的方法是否提供任何按顺序处理(和有序返回)保证？

可以使用流(懒惰列表)从一个数字(例如两个为了简单)中提取需求.Iteratees可用于处理来自单一来源的数据.

是否有类似Iteratee的功能概念来处理多个输入源？我可以想象一个Iteratee,它的状态信号来自它想要拉动的源.