Phong cách "điểm tự do" (trong Lập trình chức năng) là gì?

Một cụm từ mà tôi nhận thấy gần đây là khái niệm về phong cách "point free" ...

Đầu tiên, có câu hỏi này , và cũng là câu hỏi này .

Sau đó, tôi phát hiện ra ở đây họ đề cập đến "Một chủ đề khác có thể đáng thảo luận là việc các tác giả không thích phong cách tự do điểm."

Phong cách "điểm miễn phí" là gì? Ai đó có thể đưa ra một lời giải thích ngắn gọn? Nó có liên quan gì đến cách nấu cà ri "tự động" không?

Để có được ý tưởng về trình độ của mình - tôi đã tự học về Scheme, và đã viết một trình thông dịch Đề án đơn giản ... Tôi hiểu cà ri "ngầm" là gì, nhưng tôi không biết bất kỳ Haskell hay ML nào.

Chỉ cần xem bài viết trên Wikipedia để biết định nghĩa của bạn:

Lập trình Tacit (lập trình không điểm) là một mô hình lập trình trong đó định nghĩa hàm không bao gồm thông tin liên quan đến các đối số của nó, sử dụng tổ hợp và thành phần hàm [...] thay vì các biến.

Ví dụ về Haskell:

Thông thường (bạn chỉ định các đối số một cách rõ ràng):

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

Không có dấu chấm ( sumkhông có bất kỳ đối số rõ ràng nào - nó chỉ là một phần với +bắt đầu bằng 0):

 sum = foldr (+) 0

Hoặc đơn giản hơn: Thay vì g(x) = f(x), bạn chỉ có thể viết g = f.

Vì vậy, có: Nó liên quan chặt chẽ đến cà ri (hoặc các hoạt động như thành phần chức năng).

Kiểu không điểm có nghĩa là các đối số của hàm đang được định nghĩa không được đề cập rõ ràng, rằng hàm được xác định thông qua thành phần hàm.

Nếu bạn có hai chức năng, như

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

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

và nếu bạn muốn kết hợp hai hàm này thành một hàm để tính toán x*x+1, bạn có thể định nghĩa nó "toàn điểm" như sau:

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

Sự thay thế không có điểm sẽ không nói về lập luận x:

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

Một mẫu 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'

Tài liệu tham khảo

Kiểu điểm tự do có nghĩa là mã không đề cập rõ ràng đến các đối số của nó, mặc dù chúng tồn tại và đang được sử dụng.

Điều này hoạt động trong Haskell vì cách các chức năng hoạt động.

Ví dụ:

myTake = take

trả về một hàm nhận một đối số, do đó không có lý do gì để nhập đối số một cách rõ ràng trừ khi bạn chỉ muốn.

Đây là một ví dụ trong TypeScript mà không có bất kỳ thư viện nào khác:

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;
    }
  }
}

Bạn có thể thấy point-free style "trôi chảy" hơn và dễ đọc hơn.