# Currying and Partial Application Currying and partial application are two core concepts in functional programming, both of them performs directly at functions with the propose to change its types. It is used mainly to fit a function in any type of composition. First of all, is necessary to understand how to show a function type. To do that, will be used a sintax similar to F# sintax, functional languagem of .NET platform. In F# a function type is defined as: `parameter -> returns` Therefore, a function with an `int` parameter that returns a `bool` value can be described as: `int -> bool` When there are multiples parameters the function type is represented by (different from F#): `int, int, int -> bool` Now, we can look at the problem to understand the power of these two features. Functional programming is based mainly on the **function** concept. A programação funcional é baseada principalmente no conceito de **funções**. By definition, a mathematical function must have only one parameter (domain) and a return (range). Therefore, this would imply that, all functions written in a functional code should contain only one parameter. It Seens impossible, so, how to do this? The answer is: **Currying**. ## Understanding Currying The *currying* process is defined by: Split multiple N parameters functions in N functions. Where each function will receive only one parameter and returns a new function that will receive another parameter, and so on. Therefore, a simple Add function described by: `int, int -> int` Can be described by: `int -> int -> int` After the currying process. The following sample will creates a step-by-step of the currying process in a simple Add function. First, the original function as described by: ```csharp Func add = (value, value2) => value + value2; ``` We can use this function normally, according code: ```csharp int result Func add = (value, value2) => value + value2; result = add(2, 3); //result = 5 ``` When executing the currying process in the `add` function the return will be a new function of type `Func>`, that is, it will be a function that will receive an integer value and return a new function waiting for the second integer value. When the second function receive the last parameter, it will perform the process proposed by `add`. See how to perform the currying with **Tango**. ```csharp Func add = (value, value2) => value + value2; Func> addCurried = Currying.Curry(add); curriedResult = addCurried(2)(3); //curriedResult = 5 ``` See how to inform the parameters to `addCurried` function is a bit different, because it generates a series of functions, where each expects only one parameter. A **Tango** also provides the `Curry` method as an extension methods for `Func` delegates, so you can also perform the above operation as follows: ```csharp Func add = (value, value2) => value + value2; //Func> addCurried = Currying.Curry(add); Func> addCurried = add.Curry(); curriedResult = addCurried(2)(3); //curriedResult = 5 ``` ## Understanding Partial Application A partial application is a little different from Currying, but it also involves the process of changing function type. Through the partial application it is possible to call a method without informing all the parameters. As a result of this operation, a new function will be returned waiting for all remaining parameters. Notice the differences between partial apply and curry a function. It will be uses an Add three values function described by: `int, int, int -> int` After apply the Currying process the returned function type can be described by: `int -> int -> int -> int` At this point, a partial application works completely different from the Currying process, we could even perform different partial applications in the same function. By inform only one parameter to the function, the obtained result would be: `int, int -> int` By informing two parameters, the obtained result would be: `int -> int` Similar to the Currying process, the fundamental operation described by the function is executed only when all the parameters are informed, regardless of the number of intermediate functions generated. See the following sample, first with Currying: ```csharp Func add = (value, value2) => value + value2; Func>> addCurried = add.Curry(); curriedResult = addCurried(2)(3)(5); //curriedResult = 10 ``` Partial application with one parameter: ```csharp Func add = (value, value2) => value + value2; Func addPartialApplied = add.PartialApply(2); partialAppliedResult = addPartialApplied (3,5); //partialAppliedResult = 10 ``` Partial application with two parameters: ```csharp Func add = (value, value2) => value + value2; Func addPartialApplied = add.PartialApply(2,3); partialAppliedResult = addPartialApplied(5); //partialAppliedResult = 10 ``` All methods available for partial application and Currying in **Tango** can used in methods of up to 4 parameters, being able to return any type, including `void`. In addition, they can be used as static methods of the `Currying` and`PartialApplication` classes or as extensions to `Func` and`Action` delegates. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://gabriel-schade-cardoso.gitbook.io/tango/fundamentals/currying-and-partial-application.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.