什么是“无积分”？ 风格（在函数式编程中）？

Question

我最近注意到的一个短语是“point free”风格的概念......

首先，有 这个问题，以及还有这个。

然后，我发现这里他们提到“另一个可能值得讨论的主题是作者的不喜欢无点风格。”

什么是“无点”风格？ 有人可以给出简洁的解释吗？ 它与“自动”柯里化有关吗？

为了了解我的水平 - 我一直在自学Scheme，并编写了一个简单的Scheme解释器......我理解什么是“隐式”柯里化，但我不知道任何Haskell或ML。

Answer 1

只需查看维基百科文章即可获得定义：

默认编程（无点编程）是一种编程范例，其中函数定义不包含有关其参数的信息，使用组合器和函数组合[...]而不是变量。

Haskell 示例：

常规（显式指定参数）：

sum (x:xs) = x + (sum xs)
sum [] = 0

Point-free（sum 没有任何显式参数 - 它只是以 0 开头的 + 的折叠）：

 sum = foldr (+) 0

或者更简单：您可以只写 g = f，而不是 g(x) = f(x)。

所以是的：它与柯里化（或函数组合等操作）密切相关。

Answer 2

无点风格意味着所定义的函数的参数没有明确提及，该函数是通过函数组合来定义的。

如果您有两个函数，例如

square :: a -> a
square x = x*x

inc :: a -> a
inc x = x+1

和 如果您想将这两个函数组合成一个计算 x*x+1 的函数，您可以将其定义为“point-full”，如下所示

f :: a -> a
f x = inc (square x)

：不会谈论参数x：

f :: a -> a
f = inc . square

Answer 3

JavaScript 示例：

//not pointfree cause we receive args
var initials = function(name) {
  return name.split(' ').map(compose(toUpperCase, head)).join('. ');
};

const compose = (...fns) => (...args) => fns.reduceRight((res, fn) => [fn.call(null, ...res)], args)[0];
const join = m => m.join();

//pointfree
var initials = compose(join('. '), map(compose(toUpperCase, head)), split(' '));

initials("hunter stockton thompson");
// 'H. S. T'

参考

Answer 4

点自由风格意味着代码没有明确提及它的参数，即使它们存在并且正在使用。

由于函数的工作方式，这在 Haskell 中有效。

例如：

myTake = take

返回一个接受一个参数的函数，因此没有理由显式键入该参数，除非您也想要。

Answer 5

对此最好的解释是 Haskell wiki （摘录如下），由 < a href="https://stackoverflow.com/q/944446/1814970">Petr 在评论中。

在声明中

fx = x + 1 
  

我们根据函数 f 对任意点 x 的作用来定义函数 f。 将此与无积分版本进行对比：

f = (+ 1) 
  

其中没有提及函数所作用的值。

该点是一个数学点（上面的x），因此是“无点”符号。 如果您需要，该链接提供了更多详细信息。

Answer 6

我无法使 Brunno 提供的 javascript 示例工作，尽管代码清楚地说明了 pointfree 想法（即没有参数）。 因此，我使用 ramda.js 提供另一个示例。

假设我需要找出句子中最长的单词，给定一个字符串 "Lorem ipsum dolor sat amet consectetur adipiscing elit" 我需要输出类似 { word: 'consectetur', length: 11 }

如果我使用纯 JS 风格代码，我将像这样编写代码，使用映射和化简函数

let str = 'Lorem ipsum dolor sit amet consectetur adipiscing elit'
let strArray = str.split(' ').map((item) => ({ word: item, length: item.length }))
let longest = strArray.reduce(
    (max, cur) => (cur.length > max.length ? cur : max), 
    strArray[0])
console.log(longest)

对于 ramda，我仍然使用映射和化简函数。 我

const R = require('ramda')
let longest = R.pipe(
  R.split(' '),
  R.map((item) => ({ word: item, length: item.length })),
  R.reduce((max, cur) => (max.length > cur.length ? max : cur), { length: 0 })
)
let tmp = longest(str)
console.log(tmp)

认为我的 ramda 代码的要点是将我的函数链接在一起的管道，它使我的目的更加清晰。 不需要创建临时变量 strArray 是一个奖励（如果我在管道中有超过 3 个步骤，那么它将成为一个真正的奖励）。

Answer 7

这是一个没有任何其他库的 TypeScript 示例：

interface Transaction {
  amount: number;
}

class Test {
  public getPositiveNumbers(transactions: Transaction[]) {
    return transactions.filter(this.isPositive);

    //return transactions.filter((transaction: {amount: number} => transaction.amount > 0));
  }

  public getBigNumbers(transactions: Transaction[]) {
    // point-free
    return transactions.filter(this.moreThan(10));

    // not point-free
    // return transactions.filter((transaction: any) => transaction.amount > 10);
  }

  private isPositive(transaction: Transaction) {
    return transactions.amount > 0;
  }

  private moreThan(amount: number) {
    return (transaction: Transaction) => {
      return transactions.amount > amount;
    }
  }
}

您可以看到无点样式更“流畅”并且更易于阅读。