小编elm*_*elm的帖子

与Fibonacci系列类似的方式可以生成如下,

fibs :: [Integer]
fibs = 1 : 1 : zipWith (+) fibs (tail fibs)

如何定义阶乘的系列.

更新

令人尴尬的是,在添加这个问题之前尝试了这个,

Prelude> let factorial = 2 : 6 : zipWith(*) factorial (tail factorial)
Prelude> take 5 factorial
[2,6,12,72,864]

事实上,尾部的数字并不是连续的值.

这个表达

sys.env("HOME")

传递到主文件夹的路径; 通常sys.env("EnvVar")提供与之相关的价值$EnvVar.但是,对于$LIB未声明的环境变量

java.util.NoSuchElementException: key not found: LIB

如何确定是否声明变量而不必捕获异常？

我有一个问题,关于在1000万长度的火花RDD(或scala数组)中进行部分字符串匹配的最有效方法.考虑以下:

val set1 = Array("star wars", "ipad") //These are the String I am looking for
val set2 = RDD[("user1", "star wars 7 is coming out"),
           ("user1", "where to watch star wars"),
           ("user2", "star wars"),
           ("user2", "cheap ipad")]

我希望能够计算Set1中属于Set1的每个字符串的出现次数.所以结果应该是这样的:

Result = ("star wars", 3),("ipad", 1)

我还想计算搜索该术语的用户数(即不同的用户),因此结果应为:

Result = ("star wars", 2), ("ipad", 1)

我尝试了两种方法,第一种方法是将RDD字符串转换为set,flatMapValues然后进行连接操作,但它耗费内存.我正在考虑的另一种方法是正则表达式方法,因为只需要计数并给出确切的字符串,但我不知道如何使其有效(通过创建函数并在映射RDD时调用它？)

我似乎能够在使用LIKE的pgsql中很容易地做到这一点,但不确定是否存在以相同方式工作的RDD连接.

任何帮助将不胜感激.

假设我有一些可能有重叠域的部分函数:

val funcs: Seq[PartialFunction[Any, Int]] = Vector(
{ case i: Int if i % 2 == 0 => i*2 }
,
{ case i: Int if i % 2 == 1 => i*3 }
,
{ case i: Int if i % 6 == 0 => i*5 }
)

我想将它们应用于一个值,并收集该val定义的任何结果.我认为有一种优雅的方式可以collect用于此,但我能做的最好的方法是

val num = 66
funcs.collect { case func if func.isDefinedAt(num) => func(num) }
// or 
funcs.filter(_.isDefinedAt(num)).map(_(num))

这看起来不干净.有没有办法使用内置案例机制来测试定义和同时评估,可能是通过将它们与测试值或类似的东西进行对比？

我有一个这样的序列:

val l = Seq(1,2,3,4)

我想转变为 List(Seq(1,2), Seq(2,3), Seq(3,4))

这是我尝试过的:

def getPairs(inter: Seq[(Int, Int)]): Seq[(Int, Int)] = l match {
 case Nil => inter
 case x :: xs => getPairs(inter :+ (x, xs.head))
}

这奇怪似乎不起作用？有什么建议？

我有List[Any]哪些有价值

List((0,0), (1,1), (1,3), (2,2), (3,1))

我想把它转换成

List[(Int,Int)]

我怎样才能做到这一点？

我有一个Seq看起来像这样的元组:

Seq[(Future[Iterable[Type1]], Future[Iterator[Type2]])]

我想将其转换为以下内容:

Future[Seq([Iterable[Type1], [Iterable[Type2])]

这甚至可能吗？

val g = List(1,2,3)

val k = g.fold((0,0))((a:Tuple2[Int,Int],b:Int)=>(a._1+b,a._2+1))

但我得到以下错误=

found   : ((Int, Int), Int) => (Int, Int)
 required: (Any, Any) => Any
              g.fold((0,0))((a:Tuple2[Int,Int],b:Int)=>(a._1+b,a._2+1))

有人可以解释,为什么它期待"任何"类型.

但下面的工作:

g.map((_,1))

g.map((_,1)).fold((0,0))((a,b)=> (a._1+b._1,a._2+b._2))
res211: (Int, Int) = (6,3)

我尝试使用(1,),但不起作用,在scala中定义Tuple1的语法是什么？

scala> val a=(1,)
<console>:1: error: illegal start of simple expression
       val a=(1,)

我想知道是否有一个构造,Option.fold这将使以下None.**.asInstanceOf[Option[String]**不必要:

def getHiveDir(sqlc: SQLContext, tname: String, partColVals: Seq[(String, String)]): Option[String] = {
     getHiveDir(sqlc, tname).fold(None.asInstanceOf[Option[String]]) { tloc =>
           // some stuff
  }
  Some(someString)
 }

目前,上面.asInstanceOf[Option[String]]是必需的,或者发生编译错误:None不被识别为Option[String]

如何重新安排上面的代码以避免额外的演员？