Có gì đặc biệt về cà ri hoặc ứng dụng một phần?

Tôi đã đọc các bài viết về lập trình chức năng hàng ngày và đang cố gắng áp dụng một số thực tiễn càng nhiều càng tốt. Nhưng tôi không hiểu những gì là duy nhất trong cà ri hoặc ứng dụng một phần.

Lấy mã Groovy này làm ví dụ:

def mul = { a, b -> a * b }
def tripler1 = mul.curry(3)
def tripler2 = { mul(3, it) }

Tôi không hiểu sự khác biệt giữa tripler1và tripler2. Cả hai không giống nhau sao? 'Cà ri' được hỗ trợ bằng các ngôn ngữ chức năng thuần túy hoặc một phần như Groovy, Scala, Haskell, v.v. hàm hoặc đóng sẽ chuyển tiếp các tham số đến hàm ban đầu (như tripler2) trong hầu hết các ngôn ngữ (thậm chí C.)

Am i thiếu cái gì ở đây? Có những nơi tôi có thể sử dụng ứng dụng currying và một phần trong ứng dụng Grails của mình nhưng tôi ngần ngại làm điều đó bởi vì tôi đang tự hỏi mình "Nó khác nhau như thế nào?"

Vui lòng làm sáng tỏ cho tôi.

EDIT: Các bạn có nói rằng ứng dụng / currying một phần đơn giản là hiệu quả hơn so với việc tạo / gọi một hàm khác chuyển các tham số mặc định thành hàm gốc?

Currying là về việc biến / biểu diễn một hàm trong đó có n đầu vào thành n hàm mà mỗi hàm lấy 1 đầu vào. Ứng dụng một phần là về việc sửa một số đầu vào cho một chức năng.

Động lực cho ứng dụng một phần chủ yếu là nó giúp việc viết các thư viện hàm bậc cao dễ dàng hơn. Ví dụ, các thuật toán trong C ++ STL hầu hết đều sử dụng các biến vị ngữ hoặc hàm unary, bind1st cho phép người dùng thư viện móc vào các hàm không đơn nguyên có giá trị bị ràng buộc. Do đó, người viết thư viện không cần cung cấp các hàm quá tải cho tất cả các thuật toán có các hàm đơn nguyên để cung cấp các phiên bản nhị phân

Bản thân Currying rất hữu ích vì nó cung cấp cho bạn một phần ứng dụng bất cứ nơi nào bạn muốn nó miễn phí, tức là bạn không còn cần một chức năng như bind1stáp dụng một phần.

Nhưng tôi có thể làm điều tương tự (cà ri trái, cà ri phải, cà ri n hoặc ứng dụng một phần) bằng cách đơn giản tạo một hàm hoặc tên ẩn danh khác hoặc chuyển tiếp các tham số đến hàm ban đầu (như tripler2) trong hầu hết các ngôn ngữ ( thậm chí C.)

Và trình tối ưu hóa sẽ xem xét điều đó và nhanh chóng đi đến một cái gì đó mà nó có thể hiểu được. Currying là một mẹo nhỏ hay cho người dùng cuối, nhưng có lợi ích tốt hơn nhiều từ quan điểm thiết kế ngôn ngữ. Đó là thực sự tốt đẹp để xử lý tất cả các phương pháp như unary A -> Bnơi Bcó thể phương pháp khác.

Nó đơn giản hóa những phương thức bạn phải viết để xử lý các hàm bậc cao hơn. Phân tích tĩnh và tối ưu hóa trong ngôn ngữ của bạn chỉ có một đường dẫn để làm việc với hành vi đó theo cách đã biết. Liên kết tham số chỉ rơi ra khỏi thiết kế chứ không yêu cầu hoops thực hiện hành vi phổ biến này.

Như @jk. ám chỉ, cà ri có thể giúp làm cho mã tổng quát hơn.

Ví dụ: giả sử bạn có ba chức năng này (trong Haskell):

> let q a b = (2 + a) * b

> let r g = g 3

> let f a b = b (a 1)

Hàm fở đây nhận hai hàm làm đối số, chuyển 1đến hàm thứ nhất và chuyển kết quả của lệnh gọi đầu tiên sang hàm thứ hai.

Nếu chúng ta gọi fbằng cách sử dụng qvà rlàm đối số, thì nó thực sự sẽ được thực hiện:

> r (q 1)

nơi qsẽ được áp dụng 1và trả về một chức năng khác (như qđược chế biến); hàm trả về này sau đó sẽ được chuyển đến rlàm đối số của nó để được đưa ra một đối số 3. Kết quả của điều này sẽ là một giá trị của 9.

Bây giờ, giả sử chúng ta có hai chức năng khác:

> let s a = 3 * a

> let t a = 4 + a

chúng ta cũng có thể chuyển những thứ này đến fvà nhận được giá trị 7hoặc 15, tùy thuộc vào việc các đối số của chúng ta là s thay t s. Vì các hàm này đều trả về một giá trị thay vì một hàm, nên không có ứng dụng một phần nào diễn ra trong f s thoặc f t s.

Nếu chúng ta đã viết fvới qvà rtrong tâm trí chúng ta có thể đã sử dụng một lambda (chức năng ẩn danh) thay vì áp dụng một phần, ví dụ như:

> let f' a b = b (\x -> a 1 x)

nhưng điều này sẽ hạn chế tính tổng quát của f'. fcó thể được gọi với các đối số qvà rhoặc svà t, nhưng f'chỉ có thể được gọi với qvà r- f' s tvà f' t scả hai đều dẫn đến một lỗi.

HƠN

Nếu f'được gọi với một q'/ r'cặp trong đó q'lấy hơn hai đối số, q'thì cuối cùng vẫn sẽ được áp dụng một phần f'.

Ngoài ra, bạn có thể quấn qbên ngoài fthay vì bên trong, nhưng điều đó sẽ để lại cho bạn một lambda lồng nhau khó chịu:

f (\x -> (\y -> q x y)) r

đó là cơ bản những gì qđã được curried ở nơi đầu tiên!

Có hai điểm chính về ứng dụng một phần. Đầu tiên là cú pháp / tiện lợi - một số định nghĩa trở nên dễ dàng hơn và ngắn hơn để đọc và viết, như @jk đã đề cập. (Kiểm tra lập trình Pointfree để biết thêm về mức độ tuyệt vời của nó!)

Thứ hai, như @telastyn đã đề cập, là về một mô hình chức năng và không chỉ đơn thuần là thuận tiện. Trong phiên bản Haskell, từ đó tôi sẽ lấy ví dụ của mình vì tôi không quen với các ngôn ngữ khác với ứng dụng một phần, tất cả các hàm chỉ có một đối số. Có, thậm chí các chức năng như:

(:) :: a -> [a] -> [a]

lấy một đối số duy nhất; bởi vì tính kết hợp của hàm tạo kiểu hàm ->, ở trên tương đương với:

(:) :: a -> ([a] -> [a])

đó là một hàm lấy avà trả về một hàm [a] -> [a].

Điều này cho phép chúng ta viết các hàm như:

($) :: (a -> b) -> a -> b

có thể áp dụng bất kỳ hàm nào cho một đối số của loại thích hợp. Ngay cả những người điên như:

f :: (t, t1) -> t -> t1 -> (t2 -> t3 -> (t, t1)) -> t2 -> t3 -> [(t, t1)]
f q r s t u v = q : (r, s) : [t u v]

f' :: () -> Char -> (t2 -> t3 -> ((), Char)) -> t2 -> t3 -> [((), Char)]
f' = f $ ((), 'a')  -- <== works fine

Được rồi, đó là một ví dụ giả định. Nhưng một cách hữu ích hơn liên quan đến lớp Loại ứng dụng , bao gồm phương thức này:

(<*>) :: Applicative f => f (a -> b) -> f a -> f b

Như bạn có thể thấy, kiểu này giống hệt như $nếu bạn lấy đi Applicative fbit và trên thực tế, lớp này mô tả ứng dụng hàm trong ngữ cảnh. Vì vậy, thay vì ứng dụng chức năng bình thường:

ghci> map (+3) [1..5]  
[4,5,6,7,8]

Chúng ta có thể áp dụng các hàm trong ngữ cảnh Áp dụng; ví dụ: trong bối cảnh Có thể trong đó một cái gì đó có thể là hiện tại hoặc thiếu:

ghci> Just map <*> Just (+3) <*> Just [1..5]
Just [4,5,6,7,8]

ghci> Just map <*> Nothing <*> Just [1..5]
Nothing

Bây giờ phần thực sự thú vị là lớp Loại ứng dụng không đề cập bất cứ điều gì về các hàm của nhiều hơn một đối số - tuy nhiên, nó có thể xử lý chúng, thậm chí là các hàm của 6 đối số như f:

fA' :: Maybe (() -> Char -> (t2 -> t3 -> ((), Char)) -> t2 -> t3 -> [((), Char)])
fA' = Just f <*> Just ((), 'a')

Theo như tôi biết, lớp Loại ứng dụng ở dạng chung sẽ không thể thực hiện được nếu không có một số khái niệm về ứng dụng một phần. (Đối với bất kỳ chuyên gia lập trình nào ngoài đó - vui lòng sửa lỗi cho tôi nếu tôi sai!) Tất nhiên, nếu ngôn ngữ của bạn thiếu ứng dụng một phần, bạn có thể xây dựng nó ở một dạng nào đó, nhưng ... nó không giống nhau ? :)