标签: functional-programming

此代码有效(在Javadoc中使用):

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
String commaSeparatedNumbers = numbers.stream()
    .map(i -> i.toString())
    .collect(Collectors.joining(", "));

这个不能编译:

int[] numbers = {1, 2, 3, 4};
String commaSeparatedNumbers = Arrays.stream(numbers)
    .map((Integer i) -> i.toString())
    .collect(Collectors.joining(", "));

IDEA告诉我,我在lambda表达式中有一个"不兼容的返回类型字符串".

为什么？以及如何解决这个问题？

我正在寻找一种算法来生成集合的排列,这样我就可以在Clojure中创建它们的惰性列表.即我想迭代一个排列列表,其中每个排列都不计算,直到我请求它,并且所有排列不必一次存储在内存中.

或者我正在寻找一种给定某个集合的算法,它将返回该集合的"下一个"排列,以这种方式在自己的输出上重复调用该函数将循环遍历原始集合的所有排列,一些订单(订单无关紧要).

有这样的算法吗？我见过的大多数排列生成算法都倾向于一次性生成它们(通常是递归的),这些算法不能扩展到非常大的集合.Clojure(或其他函数式语言)中的实现会有所帮助,但我可以从伪代码中找出它.

我已经阅读了一些我可以在互联网上找到的关于多态性的文章.但我认为我无法理解它的含义及其重要性.大多数文章没有说明为什么它很重要以及如何在OOP中实现多态行为(当然在JavaScript中).

我无法提供任何代码示例,因为我还没有想到如何实现它,所以我的问题如下:

1. 它是什么？
2. 为什么我们需要它？
3. 这个怎么运作？
4. 如何在javascript中实现这种多态行为？

我有这个例子.但是很容易理解这段代码会产生什么结果.它没有给出关于多态性本身的任何清晰的想法.

function Person(age, weight) {
    this.age = age;
    this.weight = weight;
    this.getInfo = function() {
        return "I am " + this.age + " years old " +
        "and weighs " + this.weight +" kilo.";
    }
}
function Employee(age, weight, salary) {
    this.salary = salary;
    this.age = age;
    this.weight = weight;
    this.getInfo = function() {
        return "I am " + this.age + " years old " +
        "and weighs " + this.weight +" …

我正在通过阅读DrBoolean的书来学习javascript FP .

我四处寻找函数式编程库.我找到了Ramda和Folktale.两者都声称是函数式编程库.

但它们是如此不同:

• Ramda似乎包含用于处理列表的实用函数:map,reduce,filter和pure函数:curry,compose.它不包含任何处理monad,functor的东西.

• 但是,Folktale不包含列表或功能的任何实用程序.它似乎在monad中实现了javascript中的一些代数结构:也许,任务......

实际上我找到了更多的图书馆,它们似乎都属于这两个类别.下划线,lodash非常喜欢Ramda.Fantasy-land,pointfree-fantasy就像民间故事.

这些非常不同的库是否都可以被称为功能性的,如果是这样,是什么使每个库成为功能库？

定义函数的两个条件pure如下：

1. 无副作用（即仅允许更改本地范围）
2. 给定相同的输入，始终返回相同的输出

如果第一个条件始终为真，那么是否有第二次条件不为真？

即真的只有第一个条件才需要吗？

Scala分配评估单元而不是分配的值的动机是什么？

I/O编程中的一个常见模式是执行以下操作:

while ((bytesRead = in.read(buffer)) != -1) { ...

但这在Scala中是不可能的,因为......

bytesRead = in.read(buffer)

..返回Unit,而不是bytesRead的新值.

从函数式语言中省略,似乎是一件有趣的事情.我想知道为什么这样做了？

我无法理解Option[T]Scala中的课程要点.我的意思是,我不能看到任何advanages None了null.

例如,考虑代码:

object Main{
  class Person(name: String, var age: int){
    def display = println(name+" "+age)
  }

  def getPerson1: Person = {
    // returns a Person instance or null
  }

  def getPerson2: Option[Person] = {
    // returns either Some[Person] or None
  }

  def main(argv: Array[String]): Unit = {
    val p = getPerson1
    if (p!=null) p.display

    getPerson2 match{
      case Some(person) => person.display
      case None => /* Do nothing */
    }
  }
}

现在假设,该方法getPerson1返回null …

我正在寻找一些非常简单,易于掌握的递归方案和核心运动方案(catamorphisms,anorporphisms,hylomorphisms等)的解释,这些解释不需要跟随大量的链接,或者打开类别理论教科书.我确信我已经无意识地重新设计了许多这些方案,并在编码过程中将它们"应用"在我的头脑中(我相信我们很多人都有),但我不知道(共同)递归方案我是什么使用被称为.(好吧,我撒了谎.我刚刚读了一些这些,这引发了这个问题.但在今天之前,我一无所知.)

我认为这些概念在编程社区中的传播受到了令人生畏的解释和例子的阻碍 - 例如在维基百科上,而且在其他地方.

它们的名字也可能受到阻碍.我认为有一些替代的,较少的数学名称(关于香蕉和带刺铁丝网的东西？)但是我不知道我使用的递归方案的名称是什么.

我认为使用表示简单实际问题的数据类型的示例,而不是抽象数据类型(如二叉树)会有所帮助.

"泄漏抽象"一词是什么意思？(请用例子解释.我经常很难完成一个理论.)

我认识到,有在这里大约几个问题是什么钻营和部分应用功能,但我问他们是如何不同.举个简单的例子,这是一个用于查找偶数的curry函数:

def filter(xs: List[Int], p: Int => Boolean): List[Int] =
   if (xs.isEmpty) xs
   else if (p(xs.head)) xs.head :: filter(xs.tail, p)
   else filter(xs.tail, p)

def modN(n: Int)(x: Int) = ((x % n) == 0)

所以你可以编写以下内容来使用它:

val nums = List(1,2,3,4,5,6,7,8)
println(filter(nums, modN(2))

返回:List(2,4,6,8).但我发现我可以用这种方式做同样的事情:

def modN(n: Int, x: Int) = ((x % n) == 0)

val p = modN(2, _: Int)
println(filter(nums, p))

还返回:List(2,4,6,8).

所以我的问题是,两者之间的主要区别是什么,何时使用一个而不是另一个？这是一个过于简单的例子来说明为什么一个人会被用在另一个上面？