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

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

Во-первых, был этот вопрос, а тоже этот.

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

Что такое "точечный" стиль? Может ли кто-нибудь дать краткое объяснение? Связано ли это с "автоматическим" каррированием?

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

Ответ 1

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

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

Пример Haskell:

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

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

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

 sum = foldr (+) 0

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

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

Ответ 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

Ответ 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'

Ссылка

Ответ 4

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

Это работает в Haskell из-за того, как работают функции.

Например:

myTake = take

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

Ответ 5

Вот один пример в TypeScript без какой-либо другой библиотеки:

  Интерфейс Transaction { количество: число;
}

class Test { public getPositiveNumbers (транзакции: транзакция []) {   return transaction.filter(this.isPositive);
   //return  transaction.filter((транзакция: {сумма: число} = > transaction.amount > 0)); }
 public getBigNumbers (транзакции: транзакция []) {   // без точек   return transaction.filter(this.moreThan(10));
   // не без точек   //return  transaction.filter((transaction: any) = > transaction.amount > 10); }
 private isPositive (транзакция: транзакция) {   return transaction.amount > 0; }
 private moreThan (количество: число) {   return (transaction: Transaction) = > {     return transaction.amount > количество;   } }
}
Код>

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