Đó là quá trình lấy một hàm nhận nhiều đối số và biến nó thành một hàm nhận một đối số và trả về một hàm khác nhận ít đối số hơn. Ví dụ: hãy xem chức năng bên dưới
def add[a, b]:
return a + b
Một phiên bản được chỉnh sửa của chức năng sẽ trông như thế này
def add[a]:
def add_a[b]:
return a + b
return add_a
hoặc như thế này
add = lambda a: lambda b: a + b
Bây giờ
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
Đây là một cách mà lập trình viên chức năng lưu và chuyển trạng thái. Đây cũng là một cách tuyệt vời để giảm tính toán tốn kém, đặc biệt là khi các hàm được xử lý thuần túy. Đôi khi nó cũng có thể là một lựa chọn phong cách cho các chức năng cà ri. Đối với một người, tôi thích giao diện của
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
Tôi nên lưu ý ở đây rằng trong một ngôn ngữ mà các hàm là các đối tượng hạng nhất và hỗ trợ các bao đóng [các hàm được định nghĩa bên trong các hàm khác nắm bắt hoặc có quyền truy cập vào các biến cục bộ của hàm kèm theo], chẳng hạn như Python, Haskell, Scheme . , các chức năng được xử lý có thể mạnh mẽ như các phiên bản không được xử lý của chúng, vì có thể xử lý bất kỳ hàm không được xử lý nào và ngược lại. Sau đây là một bằng chứng khá đơn giản về điều này bằng quy nạp
Nếu một hàm $f_n$ nhận các đối số $n$ thì bạn có thể biến hàm đó thành một hàm $c_n$ nhận một đối số và trả về một hàm $c_{n-1}$ nhận các đối số $n-1$ và có . Bạn có thể tiếp tục làm điều này cho đến khi bạn đạt đến $c_1$, nhận một đối số và gọi $f_n$ trên các đối số $n$ nhận được bởi $c_{n}, c_{n-1}, \ldots, c_1$, do đó . Dưới đây là một ví dụ về điều đó
def add[a]:
def add_a[b]:
return a + b
return add_a
Và tất nhiên, nếu bạn có hàm $c_n$, thì bạn có thể nhận được $f_n$ từ hàm đó bằng cách gọi $c_n$ $n$ lần với các đối số được cung cấp cho $f_n$, như minh họa bên dưới
def add[a]:
def add_a[b]:
return a + b
return add_a
Điều này chứng tỏ rằng có một sự tương ứng một đối một giữa các hàm được sắp xếp và các hàm nhận đối số $n$ cho bất kỳ số tự nhiên dương nào $n$
Còn những hàm không có đối số thì sao? . Và các hàm không thuần túy có thể tạo ra các kỳ lân khó phân tích hơn nhiều nên tôi không nói về chúng ở đây
Cà ri mọi thứ trong Pythontừ chối trách nhiệm. Làm điều này theo quyết định của riêng bạn và chỉ với các chức năng thuần túy
Mặc dù tôi cực kỳ thích xem
add = lambda a: lambda b: a + b
def add[a]:
def add_a[b]:
return a + b
return add_a
nhưng điều đó cũng không có vẻ đặc biệt hấp dẫn. Chỉ có Haskell là một cách viết gọn gàng
def add[a]:
def add_a[b]:
return a + b
return add_a
Nhưng nó vẫn làm lu mờ bản chất thực sự của hàm
add = lambda a: lambda b: a + b
def add[a]:
def add_a[b]:
return a + b
return add_a
Nhưng chờ đã, bây giờ
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
def add[a]:
def add_a[b]:
return a + b
return add_a
add = lambda a: lambda b: a + b
Mặc dù đây là một cách để lấy tương đương với việc cà ri ra khỏi một chức năng không được cà ri, nhưng theo ý kiến của tôi thì nó hơi dài dòng. Điều gì sẽ xảy ra nếu chúng ta có thể thêm một trình trang trí vào định nghĩa của
add = lambda a: lambda b: a + b
add = lambda a: lambda b: a + b
Bây giờ chúng ta cần đưa ra một số quyết định thiết kế. Python là một ngôn ngữ rất linh hoạt. Người dùng có thể gọi một hàm với các đối số vị trí hoặc từ khóa. Một số đối số là tùy chọn, vì vậy người dùng có thể không bao giờ cung cấp chúng. Ngoài ra, lý do lớn nhất tại sao currying hữu ích là nó cho phép lập trình viên lưu trạng thái khi cần, và đôi khi bạn chỉ muốn gọi một hàm Curried như
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Tôi đã quyết định xác định một hàm
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
add = lambda a: lambda b: a + b
def add[a]:
def add_a[b]:
return a + b
return add_a
Để xem thêm ví dụ về điều này, vui lòng xem doctests của
def add[a]:
def add_a[b]:
return a + b
return add_a
Đang lưu trạng thái và một phần ứng dụng
Hãy thử thực hiện
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Nếu
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Lưu ý rằng phương thức ma thuật
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Chúng ta thực sự có thể đơn giản hóa mã này hơn một chút, vì một đối tượng
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Điều này sẽ giúp bạn đánh giá cao những gì đang thực sự xảy ra khi chúng ta đang cà ri. chúng tôi đang lưu trữ trạng thái và truyền nó đi khắp nơi, và đó là lý do tại sao đôi khi nó chính xác như những gì bạn muốn
Một định nghĩa chức năng thuần túy
Nếu bạn xem kỹ đoạn mã trên, bạn sẽ nhận thấy rằng các đối tượng
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Lưu ý rằng
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Bất chấp những thiếu sót về phong cách của việc triển khai chức năng, tôi đưa nó vào đây để đưa ra một điểm rất quan trọng. có thể chuyển trạng thái không chỉ trong các đối tượng mà còn trong các chức năng [chính xác hơn là các bao đóng]. Trường hợp cụ thể, chúng ta có thể thay thế đối tượng
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
def add[a]:
def add_a[b]:
return a + b
return add_a
Mặc dù Python không mặc định các chức năng của nó [không giống như Haskell], nhưng có một cách rõ ràng, thanh lịch để triển khai chức năng tương tự. Điều này cũng gợi ý rằng các hàm có thể tự lưu và chuyển trạng thái và các lớp chỉ là đường cú pháp cho một số loại hàm nhất định. Cuối cùng, nó phản ánh thực tế rằng phép tính Lambda, một khung trong đó khai báo biến, định nghĩa hàm và ứng dụng là những hành động khả thi duy nhất, đủ để lập mô hình cho tất cả quá trình tính toán
Bạn có thể tìm thấy tất cả các mã trong bài đăng này tại đây. Tôi thực sự khuyên bạn nên đọc các tài liệu để hiểu các quyết định thiết kế mà tôi đã đưa ra và tất cả các tính năng mà trình trang trí cà ri cung cấp