Що таке "безточковий" стиль (у функціональному програмуванні)?

Фраза, яку я нещодавно помітив, - це поняття стилю "без точки" ...

По-перше, було це питання, а також це .

Потім я виявив, що тут вони згадують: "Ще однією темою, яку, можливо, варто обговорити, є неприязнь авторів до стилю" без точки ".

Що таке "безточковий" стиль? Хтось може дати коротке пояснення? Чи це пов’язано з «автоматичним» каррі?

Щоб отримати уявлення про свій рівень - я навчав себе Scheme і написав простий інтерпретатор Scheme ... Я розумію, що таке "неявне" каррінг, але я не знаю жодного Haskell або ML.

Просто перегляньте статтю Вікіпедії, щоб отримати своє визначення:

Мовчазне програмування (безточкове програмування) - це парадигма програмування, в якій визначення функції не включає інформацію щодо її аргументів, використовуючи комбінатори та склад функцій [...] замість змінних.

Приклад Haskell:

Звичайні (аргументи ви вказуєте явно):

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

Безточковий ( sumне має явних аргументів - це просто згортання, що +починається з 0):

 sum = foldr (+) 0

Або ще простіше: замість того g(x) = f(x), щоб ви могли просто писати g = f.

Так що так: це тісно пов’язано з каррірованием (або такими операціями, як склад функцій).

Безточковий стиль означає, що аргументи функції, що визначається, явно не згадуються, що функція визначається за допомогою композиції функції.

Якщо у вас є дві функції, наприклад

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

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

і якщо ви хочете поєднати ці дві функції з такою, яка обчислює x*x+1, ви можете визначити її "повною точкою" так:

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

Безточковою альтернативою було б не говорити про аргумент x:

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

Зразок 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'

Довідково

Безточковий стиль означає, що в коді явно не згадуються аргументи, хоча вони існують і використовуються.

Це працює в Haskell через те, як працюють функції.

Наприклад:

myTake = take

повертає функцію, яка приймає один аргумент, тому немає причин явно вводити аргумент, якщо ви просто цього теж не хочете.

Ось один приклад у 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;
    }
  }
}

Ви бачите, що безточковий стиль більш "вільний" і легший для читання.