Что такое стиль без точек в функциональном программировании?

Question

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

Сначала был этот вопрос, а также этот .

Затем я обнаружил здесь они упоминают "Еще одна тема, которую стоит обсудить, - это неприязнь авторов к стилю без точек".

Что такое стиль "без очков"? Может кто-нибудь дать краткое объяснение? Это как-то связано с «автоматическим» карри?

Чтобы понять мой уровень - я учил себя Схеме и написал простой интерпретатор Схемы ... Я понимаю, что такое "неявное" карри, но я не знаю ни Haskell, ни ML.

Answer 1

Просто посмотрите на статью Википедии , чтобы получить определение:

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

Пример Haskell:

Обычный (вы указываете аргументы явно):

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

Бессмысленно (sum не имеет явных аргументов - это просто сгиб с +, начинающимся с 0):

 sum = foldr (+) 0

Или даже проще: вместо g(x) = f(x) вы можете просто написать g = f.

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

Answer 2

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

Если у вас есть две функции, например

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

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

Вот один пример в 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;
    }
  }
}

Вы можете видеть, что стиль без точек более "беглый" и его легче читать.