登录查看更多内容

What is currying in functional programming and how can you use it?

由人工智能和领英社区提供技术支持

Currying is a technique in functional programming that allows you to transform a function that takes multiple arguments into a sequence of functions that each take one argument. This can make your code more readable, reusable, and modular, as well as enable partial application and higher-order functions. In this article, you will learn what currying is, how it works, and how you can use it in different programming languages.

此文章中的业界达人

由社区从 8 条内容中精选。了解更多

Amine Benaddi

Technical Lead | Front-end Enthusiast
Mozammil Rizwan

Hyper Automation | Azure AI Services | OCR | Document Processing | GenAI | ERP, CRM, HCM, EDI, SCM, E-Commerce…
Aristoteles Lopes

Software Engineer

1 The idea of currying

Currying is named after the mathematician Haskell Curry, who popularized the concept, but it was originally discovered by Moses Sch?nfinkel and Gottlob Frege. Currying is based on the idea that any function that takes multiple arguments can be rewritten as a series of nested functions that each take one argument and return another function, until the final function returns the result. For example, a function that adds three numbers can be written as: add(x, y, z) = x + y + z or as: add(x) = (y) => (z) => x + y + z The second version is the curried form of the first one. It returns a function that takes y as an argument and returns another function that takes z as an argument and returns the sum of x, y, and z. You can call the curried function by applying each argument separately, such as: add(1)(2)(3) // returns 6 or by storing intermediate functions in variables, such as:

addOne = add(1) // returns a function that takes y
addTwo = addOne(2) // returns a function that takes z
addThree = addTwo(3) // returns 6

添加您的观点

Mozammil Rizwan

Hyper Automation | Azure AI Services | OCR | Document Processing | GenAI | ERP, CRM, HCM, EDI, SCM, E-Commerce, Healthcare Automation Specialist
举报内容
Currying is a technique in functional programming where a function with multiple arguments is transformed into a series of unary functions. It allows partial application, where you can fix some arguments and generate a new function. This enhances code modularity, reusability, and simplifies function composition in functional programming.

已翻译

赞
Aristoteles Lopes

Software Engineer
举报内容
In my experience currying allows you to break down functions into smaller, reusable building blocks. These curried functions can be composed and combined in various ways to create new functions, making your code more modular and easier to maintain.

已翻译

赞
Eduardo Moreno

??TOP 10 at WorldSkills Portugal #09 IT Software Solutions for Business | ? Outsystems Developer | ???? Japanese Language / 日本語 CEFR A1+
举报内容
Currying is a technique in functional programming where a function that takes multiple arguments is transformed into a series of functions, each taking a single argument, which allows for the partial application of a function, meaning you can call it with some arguments and receive a new function that expects the remaining arguments. Currying is also useful for creating more reusable and specialized functions because it lets you fix some arguments and later supply the remaining ones, which can be helpful in scenarios like function composition, where you want to create complex functions by combining simpler ones. It's a fundamental concept in many functional programming languages and libraries.

已翻译

赞

2 The benefits of currying

Currying can offer several benefits for functional programming, such as improving readability and clarity, enabling partial application, and supporting higher-order functions. For instance, currying can make your code more expressive and concise by avoiding repetition and nesting of arguments. Additionally, it allows you to create new functions by fixing some arguments of an existing function and leaving the rest to be supplied later. This can help you customize and reuse functions for different scenarios. Furthermore, currying allows you to pass functions as arguments to other functions and return functions as results. This can help you create more abstract and powerful functions that can manipulate and compose other functions.

添加您的观点

Amine Benaddi

Technical Lead | Front-end Enthusiast
举报内容
Currying is a useful technique to refactor some parts of code: instead of multiple implementations (func1(data), func2(data) ...), we can introduction an abstraction to better localize business logic (func(case)(data))

已翻译

赞

加载更多内容

3 The implementation of currying

Currying is a common feature in some functional programming languages, such as Haskell, Clojure, and Scala, where functions are automatically curried and can be applied partially. For example, in Haskell, you can write:

add x y z = x + y + z
addOne = add 1
addTwo = addOne 2
addThree = addTwo 3

In other languages, such as JavaScript, Python, and Ruby, you can implement currying manually by using nested functions, closures, or helper functions. For example, in JavaScript, you can write:

function add(x) {
  return function(y) {
    return function(z) {
      return x + y + z;
    }
  }
}
let addOne = add(1);
let addTwo = addOne(2);
let addThree = addTwo(3);

or by using a helper function that takes a function and returns its curried version:

function curry(f) {
  return function(x) {
    return function(y) {
      return function(z) {
        return f(x, y, z);
      }
    }
  }
}
function add(x, y, z) {
  return x + y + z;
}
let addCurried = curry(add);
let addOne = addCurried(1);
let addTwo = addOne(2);
let addThree = addTwo(3);

添加您的观点

Jake Shilling

Senior Software Engineer at Functor Factory | Crafting Robust Solutions with Monadic Design
举报内容
This becomes a lot more readable when using arrow functions: ``` const add = (a: number) => (b: number) => a + b; const mul = (a: number) => (b: number) => a * b; ``` It might also be clearer to have a more practical example that shows how currying helps compose bigger functions out of these pieces: ``` const doStuff = (x) => pipe( x, mul(3), add(2), ); ``` At the end of the day, functional programming is about building composible abstractions out of functions, and currying is a way that makes functions easier to compose.

已翻译

赞

4 The challenges of currying

Currying can also present some challenges for functional programming. It can make code more complex and difficult to understand, as well as increase memory usage. Additionally, it can cause issues with functions that rely on the context or arity of the original function. For example, in JavaScript, you cannot curry a method that uses this to access an object property directly, since the this value will be lost. You need to use a helper function like bind to preserve the context. Similarly, if you have a function that uses the arguments object to access all the arguments, you cannot curry it directly since the arguments object will be different. You need to use a helper function like rest to collect all the arguments.

添加您的观点

Amine Benaddi

Technical Lead | Front-end Enthusiast
(已编辑)
举报内容
Generating functions is not memory efficient, mainly because functions are callable objects with many properties. However, regarding the concern of the conflicting behavior of using `this` and currying in JS, one can still use arrow functions ...

已翻译

赞

5 The alternatives to currying

Currying is not the only way to achieve functional programming goals, such as readability, reusability, and modularity. Other techniques that can be used instead of or in combination with currying include uncurrying, partial application, and composition. Uncurrying is the opposite of currying, where you transform a curried function into a function that takes multiple arguments. Partial application is a technique that allows you to create new functions by fixing some arguments of an existing function and leaving the rest to be supplied later. Composition is a technique that allows you to create new functions by combining two or more existing functions. All of these techniques can help make code simpler and more powerful, while avoiding intermediate variables and functions.

添加您的观点

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Aristoteles Lopes

Software Engineer
举报内容
Currying can promote lazy evaluation in some cases. Arguments are consumed one at a time, potentially leading to more efficient resource usage and improved performance in your application. Overall, currying is a valuable technique in functional programming, offering increased flexibility, reusability, and code clarity, facility to read which can lead to more maintainable and expressive software.

已翻译

赞

Computer Science

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

What is currying in functional programming and how can you use it?

1

2

3

4

5

6

1 The idea of currying

2 The benefits of currying

3 The implementation of currying

4 The challenges of currying

5 The alternatives to currying

6 Here’s what else to consider

Computer Science

给文章评分

感谢您的反馈

更多Computer Science相关文章

更多相关阅读内容

What is currying in functional programming and how can you use it?

1

2

3

4

5

6

1 The idea of currying

2 The benefits of currying

3 The implementation of currying

4 The challenges of currying

5 The alternatives to currying

6 Here’s what else to consider

Computer Science

给文章评分

感谢您的反馈

查看其他技能