From 054e017b1455d65f7d7a7e9e4c5d8b3ddd2745fd Mon Sep 17 00:00:00 2001 From: Andrea Longo Date: Fri, 12 Mar 2021 22:29:41 +0100 Subject: [PATCH 1/3] transalted article --- .../03-currying-partials/article.md | 104 +++++++++--------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/1-js/99-js-misc/03-currying-partials/article.md b/1-js/99-js-misc/03-currying-partials/article.md index d71ac23f8..d81d3f0bb 100644 --- a/1-js/99-js-misc/03-currying-partials/article.md +++ b/1-js/99-js-misc/03-currying-partials/article.md @@ -5,19 +5,19 @@ libs: # Currying -[Currying](https://en.wikipedia.org/wiki/Currying) is an advanced technique of working with functions. It's used not only in JavaScript, but in other languages as well. +Il [currying](https://en.wikipedia.org/wiki/Currying) è una tecnica avanzata che si applica durante lo sviluppo di funzioni. Non viene utilizzata solamente in JavaScript, ma anche in altri linguaggi di programmazione. -Currying is a transformation of functions that translates a function from callable as `f(a, b, c)` into callable as `f(a)(b)(c)`. +Il currying è una trasformazione delle funzioni, in cui si traduce una funzione invocabile come `f(a, b, c)` in una invocabile come `f(a)(b)(c)`. -Currying doesn't call a function. It just transforms it. +Il currying non invoca la funzione. Si occupa solamente della sua trasformazione. -Let's see an example first, to better understand what we're talking about, and then practical applications. +Come prima cosa vediamo un esempio, in modo da capire di cosa stiamo parlando, e le sue applicazioni nella pratica. -We'll create a helper function `curry(f)` that performs currying for a two-argument `f`. In other words, `curry(f)` for two-argument `f(a, b)` translates it into a function that runs as `f(a)(b)`: +Creeremo una funzione di supporto `curry(f)` che esegue il currying per una funzione a due argomenti `f`. In altre parole, `curry(f)`, trasformerà `f(a, b)` in una funzione invocabile come `f(a)(b)`: ```js run *!* -function curry(f) { // curry(f) does the currying transform +function curry(f) { // curry(f) esegue il currying return function(a) { return function(b) { return f(a, b); @@ -26,7 +26,7 @@ function curry(f) { // curry(f) does the currying transform } */!* -// usage +// utilizzo function sum(a, b) { return a + b; } @@ -36,30 +36,30 @@ let curriedSum = curry(sum); alert( curriedSum(1)(2) ); // 3 ``` -As you can see, the implementation is straightforward: it's just two wrappers. +Come potete vedere, l'implementazione è piuttosto semplice: sono due semplici wrappers. -- The result of `curry(func)` is a wrapper `function(a)`. -- When it is called like `curriedSum(1)`, the argument is saved in the Lexical Environment, and a new wrapper is returned `function(b)`. -- Then this wrapper is called with `2` as an argument, and it passes the call to the original `sum`. +- Il risultato di `curry(func)` è un wrapper `function(a)`. +- Quando viene invocato come `curriedSum(1)`, l'argomento viene memorizzato nel Lexical Environment, e viene ritornato un nuovo wrapper `function(b)`. +- Successivamente questo warepper viene invoccato con `2` come argomento, che passerà l'invocazione a `sum`. -More advanced implementations of currying, such as [_.curry](https://lodash.com/docs#curry) from lodash library, return a wrapper that allows a function to be called both normally and partially: +Implementazioni più avanzate del currying, come [_.curry](https://lodash.com/docs#curry) fornito dalla libreria lodash, ritorna un wrapper che consente di invocare una funzione sia nella forma standard che in quella parziale: ```js run function sum(a, b) { return a + b; } -let curriedSum = _.curry(sum); // using _.curry from lodash library +let curriedSum = _.curry(sum); // utilizzando _.curry della libreria lodash -alert( curriedSum(1, 2) ); // 3, still callable normally -alert( curriedSum(1)(2) ); // 3, called partially +alert( curriedSum(1, 2) ); // 3, riamane invocabile normalmente +alert( curriedSum(1)(2) ); // 3, invocata parzialmente ``` -## Currying? What for? +## Currying? Per quale motivo? -To understand the benefits we need a worthy real-life example. +Per poterne comprendere i benefici abbiamo bisogno di un esempio di applicazione reale. -For instance, we have the logging function `log(date, importance, message)` that formats and outputs the information. In real projects such functions have many useful features like sending logs over the network, here we'll just use `alert`: +Ad esempio, abbiamo una funzione di logging `log(date, importance, message)` che formatta e ritorna le informazioni. In un progetto reale una funzione del genere ha diverse funzionalità utili, come l'invio di log in rete, qui useremo semplicemente un `alert`: ```js function log(date, importance, message) { @@ -67,37 +67,37 @@ function log(date, importance, message) { } ``` -Let's curry it! +Eseguiamo il currying! ```js log = _.curry(log); ``` -After that `log` works normally: +Successivamente al `log`, funzionerà normalmente: ```js log(new Date(), "DEBUG", "some debug"); // log(a, b, c) ``` -...But also works in the curried form: +...Ma funzionerà anche nella forma parziale: ```js log(new Date())("DEBUG")("some debug"); // log(a)(b)(c) ``` -Now we can easily make a convenience function for current logs: +Ora possiamo creare una funzione utile per i logs attuali: ```js -// logNow will be the partial of log with fixed first argument +// logNow sarà la versione parziale di log con il primo argomento fisso let logNow = log(new Date()); -// use it +// utilizziamola logNow("INFO", "message"); // [HH:mm] INFO message ``` -Now `logNow` is `log` with fixed first argument, in other words "partially applied function" or "partial" for short. +Ora `logNow` equivale a `log` con il primo argomento fissato, in altre parole, una "funzione applicata parzialmente" o "parziale" (più breve). -We can go further and make a convenience function for current debug logs: +Possiamo anche andare oltre, e creare una funzione utile per i logs di debug attuali: ```js let debugNow = logNow("DEBUG"); @@ -105,15 +105,15 @@ let debugNow = logNow("DEBUG"); debugNow("message"); // [HH:mm] DEBUG message ``` -So: -1. We didn't lose anything after currying: `log` is still callable normally. -2. We can easily generate partial functions such as for today's logs. +Quindi: +1. Non perdiamo nulla dopo il currying: `log` rimane invocabile normalmente. +2. Possiamo generare molto semplicemente funzioni parziali per i logs quotidiani. -## Advanced curry implementation +## Implementazione avanzata del currying -In case you'd like to get in to the details, here's the "advanced" curry implementation for multi-argument functions that we could use above. +Nel caso in cui vogliate entrare più nel dettaglio, di seguito vediamo un'implementazione "avanzata" del currying per funzioni con più argomenti che avremmo potuto usare sopra. -It's pretty short: +E' piuttosto breve: ```js function curry(func) { @@ -131,7 +131,7 @@ function curry(func) { } ``` -Usage examples: +Esempi di utilizzo: ```js function sum(a, b, c) { @@ -140,17 +140,17 @@ function sum(a, b, c) { let curriedSum = curry(sum); -alert( curriedSum(1, 2, 3) ); // 6, still callable normally -alert( curriedSum(1)(2,3) ); // 6, currying of 1st arg -alert( curriedSum(1)(2)(3) ); // 6, full currying +alert( curriedSum(1, 2, 3) ); // 6, ancora invocabile normalmente +alert( curriedSum(1)(2,3) ); // 6, currying del primo argomento +alert( curriedSum(1)(2)(3) ); // 6, currying completo ``` -The new `curry` may look complicated, but it's actually easy to understand. +La funzione `curry` può sembrare complicata, ma in realtà è piuttosto semplice da capire. -The result of `curry(func)` call is the wrapper `curried` that looks like this: +Il risultato dell'invocazione `curry(func)` è il wrapper `curried` (che ha subito il processo di curryiong), ed appare in questo modo: ```js -// func is the function to transform +// func è la funzionie trasformata function curried(...args) { if (args.length >= func.length) { // (1) return func.apply(this, args); @@ -162,27 +162,27 @@ function curried(...args) { }; ``` -When we run it, there are two `if` execution branches: +Quando la eseguiamo, ci sono due percorsi di esecuzione `if`: -1. If passed `args` count is the same or more than the original function has in its definition (`func.length`) , then just pass the call to it using `func.apply`. -2. Otherwise, get a partial: we don't call `func` just yet. Instead, another wrapper is returned, that will re-apply `curried` providing previous arguments together with the new ones. +1. Se il numero di `args` forniti è uguale o maggiore rispetto a quelli che la funzione originale ha nella sua definizione (`func.length`), allora gli giriamo semplicemente l'invocazione utilizzando `func.apply`. +2. Altrimenti, otterremo un parziale: non invochiamo ancora `func`. Invece, un altro wrapper viene ritornato, che riapplicherà il `curried` fornendo gli argomenti precedenti insieme a quelli nuovi. -Then, if we call it, again, we'll get either a new partial (if not enough arguments) or, finally, the result. +Successivamente, se la invochiamo, di nuovo avremmo o una nuova funzione parziale (se non vengono forniti abbastanza argomenti) oppure otteremo il risultato. -```smart header="Fixed-length functions only" -The currying requires the function to have a fixed number of arguments. +```smart header="Solo funzioni di lunghezza fissa" +Il currying richiede che la funzione abbia un numero fissato di argomenti. -A function that uses rest parameters, such as `f(...args)`, can't be curried this way. +Una funzione che utilizza i parametri rest, come `f(...args)`, non può passare attraverso il processo di currying in questo modo. ``` -```smart header="A little more than currying" -By definition, currying should convert `sum(a, b, c)` into `sum(a)(b)(c)`. +```smart header="Un po' più del currying" +Per definizione, il currying dovrebbe convertire `sum(a, b, c)` in `sum(a)(b)(c)`. -But most implementations of currying in JavaScript are advanced, as described: they also keep the function callable in the multi-argument variant. +Ma la maggiora parte delle implementazioni in JavaScript sono più avanzate di così, come descritto: queste mantengono la funzione invocabile nella variante a più argomenti. ``` -## Summary +## Riepilogo -*Currying* is a transform that makes `f(a,b,c)` callable as `f(a)(b)(c)`. JavaScript implementations usually both keep the function callable normally and return the partial if the arguments count is not enough. +Il *currying* è una trasformazione che rende `f(a,b,c)` invocabile come `f(a)(b)(c)`. Le implementazioni in JavaScript, solitamente, mantengono entrambe le varianti, sia quella normale che quella parziale, se invoca con un numero di argomenti non sufficienti. -Currying allows us to easily get partials. As we've seen in the logging example, after currying the three argument universal function `log(date, importance, message)` gives us partials when called with one argument (like `log(date)`) or two arguments (like `log(date, importance)`). +Il currying permette di ottenere delle funzioni parziali molto semplicemente. Come abbiamo visto nell'esempio del logging, dopo il currying la funzione universale a tre argomenti `log(date, importance, message)` ci fornisce una funzione parziale quando invocata con un solo argomento (come `log(date)`) o due argomenti (come `log(date, importance)`). From fb9c615065118e17eec259b1f49747818d05a6fe Mon Sep 17 00:00:00 2001 From: Andrea <45577511+longo-andrea@users.noreply.github.com> Date: Sun, 14 Mar 2021 18:53:19 +0100 Subject: [PATCH 2/3] Apply suggestions from code review Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com> --- .../03-currying-partials/article.md | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/1-js/99-js-misc/03-currying-partials/article.md b/1-js/99-js-misc/03-currying-partials/article.md index d81d3f0bb..0751054a5 100644 --- a/1-js/99-js-misc/03-currying-partials/article.md +++ b/1-js/99-js-misc/03-currying-partials/article.md @@ -5,13 +5,13 @@ libs: # Currying -Il [currying](https://en.wikipedia.org/wiki/Currying) è una tecnica avanzata che si applica durante lo sviluppo di funzioni. Non viene utilizzata solamente in JavaScript, ma anche in altri linguaggi di programmazione. +Il [currying](https://en.wikipedia.org/wiki/Currying) è una tecnica avanzata che si applica alle funzioni. Non viene utilizzata solamente in JavaScript, ma anche in altri linguaggi di programmazione. -Il currying è una trasformazione delle funzioni, in cui si traduce una funzione invocabile come `f(a, b, c)` in una invocabile come `f(a)(b)(c)`. +Il currying è una trasformazione che traduce una funzione invocabile come `f(a, b, c)` in una invocabile come `f(a)(b)(c)`. Il currying non invoca la funzione. Si occupa solamente della sua trasformazione. -Come prima cosa vediamo un esempio, in modo da capire di cosa stiamo parlando, e le sue applicazioni nella pratica. +Come prima cosa vediamo un esempio, in modo da capire di cosa stiamo parlando, e le applicazioni nella pratica. Creeremo una funzione di supporto `curry(f)` che esegue il currying per una funzione a due argomenti `f`. In altre parole, `curry(f)`, trasformerà `f(a, b)` in una funzione invocabile come `f(a)(b)`: @@ -59,7 +59,7 @@ alert( curriedSum(1)(2) ); // 3, invocata parzialmente Per poterne comprendere i benefici abbiamo bisogno di un esempio di applicazione reale. -Ad esempio, abbiamo una funzione di logging `log(date, importance, message)` che formatta e ritorna le informazioni. In un progetto reale una funzione del genere ha diverse funzionalità utili, come l'invio di log in rete, qui useremo semplicemente un `alert`: +Ad esempio, abbiamo una funzione di logging `log(date, importance, message)` che formatta e ritorna le informazioni. In un progetto reale, una funzione del genere ha diverse funzionalità utili, come l'invio di log in rete, qui useremo semplicemente un `alert`: ```js function log(date, importance, message) { @@ -85,7 +85,7 @@ log(new Date(), "DEBUG", "some debug"); // log(a, b, c) log(new Date())("DEBUG")("some debug"); // log(a)(b)(c) ``` -Ora possiamo creare una funzione utile per i logs attuali: +Ora possiamo creare una funzione utile per registrare i logs: ```js // logNow sarà la versione parziale di log con il primo argomento fisso @@ -97,7 +97,7 @@ logNow("INFO", "message"); // [HH:mm] INFO message Ora `logNow` equivale a `log` con il primo argomento fissato, in altre parole, una "funzione applicata parzialmente" o "parziale" (più breve). -Possiamo anche andare oltre, e creare una funzione utile per i logs di debug attuali: +Possiamo anche andare oltre, e creare una funzione utile per registrare i logs di debug: ```js let debugNow = logNow("DEBUG"); @@ -111,7 +111,7 @@ Quindi: ## Implementazione avanzata del currying -Nel caso in cui vogliate entrare più nel dettaglio, di seguito vediamo un'implementazione "avanzata" del currying per funzioni con più argomenti che avremmo potuto usare sopra. +Nel caso in cui vogliate entrare più nel dettaglio, di seguito vediamo un'implementazione "avanzata" del currying per funzioni con più argomenti, che avremmo anche potuto usare sopra. E' piuttosto breve: @@ -147,7 +147,7 @@ alert( curriedSum(1)(2)(3) ); // 6, currying completo La funzione `curry` può sembrare complicata, ma in realtà è piuttosto semplice da capire. -Il risultato dell'invocazione `curry(func)` è il wrapper `curried` (che ha subito il processo di curryiong), ed appare in questo modo: +Il risultato dell'invocazione `curry(func)` è il wrapper `curried` (che ha subito il processo di currying), ed appare in questo modo: ```js // func è la funzionie trasformata @@ -165,9 +165,9 @@ function curried(...args) { Quando la eseguiamo, ci sono due percorsi di esecuzione `if`: 1. Se il numero di `args` forniti è uguale o maggiore rispetto a quelli che la funzione originale ha nella sua definizione (`func.length`), allora gli giriamo semplicemente l'invocazione utilizzando `func.apply`. -2. Altrimenti, otterremo un parziale: non invochiamo ancora `func`. Invece, un altro wrapper viene ritornato, che riapplicherà il `curried` fornendo gli argomenti precedenti insieme a quelli nuovi. +2. Altrimenti, otterremo un parziale: non invochiamo ancora `func`. Invece, viene ritornato un altro wrapper, che riapplicherà il `curried` passando gli argomenti precedenti insieme a quelli nuovi. -Successivamente, se la invochiamo, di nuovo avremmo o una nuova funzione parziale (se non vengono forniti abbastanza argomenti) oppure otteremo il risultato. +Quindi, se la invochiamo, di nuovo, avremo o una nuova funzione parziale (se non vengono forniti abbastanza argomenti) oppure otterremo il risultato. ```smart header="Solo funzioni di lunghezza fissa" Il currying richiede che la funzione abbia un numero fissato di argomenti. @@ -183,6 +183,6 @@ Ma la maggiora parte delle implementazioni in JavaScript sono più avanzate di c ## Riepilogo -Il *currying* è una trasformazione che rende `f(a,b,c)` invocabile come `f(a)(b)(c)`. Le implementazioni in JavaScript, solitamente, mantengono entrambe le varianti, sia quella normale che quella parziale, se invoca con un numero di argomenti non sufficienti. +Il *currying* è una trasformazione che rende `f(a,b,c)` invocabile come `f(a)(b)(c)`. Le implementazioni in JavaScript, solitamente, mantengono entrambe le varianti, sia quella normale che quella parziale, se il numero di argomenti non è sufficiente. Il currying permette di ottenere delle funzioni parziali molto semplicemente. Come abbiamo visto nell'esempio del logging, dopo il currying la funzione universale a tre argomenti `log(date, importance, message)` ci fornisce una funzione parziale quando invocata con un solo argomento (come `log(date)`) o due argomenti (come `log(date, importance)`). From dd3cc7042ff03244b0d8eeb1f3f80fbc8c4fd290 Mon Sep 17 00:00:00 2001 From: Andrea <45577511+longo-andrea@users.noreply.github.com> Date: Mon, 15 Mar 2021 21:44:46 +0100 Subject: [PATCH 3/3] Apply suggestions from code review Co-authored-by: Dorin David <70648503+Dorin-David@users.noreply.github.com> --- 1-js/99-js-misc/03-currying-partials/article.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/1-js/99-js-misc/03-currying-partials/article.md b/1-js/99-js-misc/03-currying-partials/article.md index 0751054a5..698e3b396 100644 --- a/1-js/99-js-misc/03-currying-partials/article.md +++ b/1-js/99-js-misc/03-currying-partials/article.md @@ -40,7 +40,7 @@ Come potete vedere, l'implementazione è piuttosto semplice: sono due semplici w - Il risultato di `curry(func)` è un wrapper `function(a)`. - Quando viene invocato come `curriedSum(1)`, l'argomento viene memorizzato nel Lexical Environment, e viene ritornato un nuovo wrapper `function(b)`. -- Successivamente questo warepper viene invoccato con `2` come argomento, che passerà l'invocazione a `sum`. +- Successivamente questo wrapper viene invocato con `2` come argomento, che passerà l'invocazione a `sum`. Implementazioni più avanzate del currying, come [_.curry](https://lodash.com/docs#curry) fornito dalla libreria lodash, ritorna un wrapper che consente di invocare una funzione sia nella forma standard che in quella parziale: @@ -59,7 +59,7 @@ alert( curriedSum(1)(2) ); // 3, invocata parzialmente Per poterne comprendere i benefici abbiamo bisogno di un esempio di applicazione reale. -Ad esempio, abbiamo una funzione di logging `log(date, importance, message)` che formatta e ritorna le informazioni. In un progetto reale, una funzione del genere ha diverse funzionalità utili, come l'invio di log in rete, qui useremo semplicemente un `alert`: +Ad esempio, abbiamo una funzione di logging `log(date, importance, message)` che formatta e ritorna le informazioni. In un progetto reale, una funzione del genere ha diverse funzionalità utili, come l'invio di log in rete; qui useremo semplicemente un `alert`: ```js function log(date, importance, message) { @@ -150,7 +150,7 @@ La funzione `curry` può sembrare complicata, ma in realtà è piuttosto semplic Il risultato dell'invocazione `curry(func)` è il wrapper `curried` (che ha subito il processo di currying), ed appare in questo modo: ```js -// func è la funzionie trasformata +// func è la funzione trasformata function curried(...args) { if (args.length >= func.length) { // (1) return func.apply(this, args); @@ -178,7 +178,7 @@ Una funzione che utilizza i parametri rest, come `f(...args)`, non può passare ```smart header="Un po' più del currying" Per definizione, il currying dovrebbe convertire `sum(a, b, c)` in `sum(a)(b)(c)`. -Ma la maggiora parte delle implementazioni in JavaScript sono più avanzate di così, come descritto: queste mantengono la funzione invocabile nella variante a più argomenti. +Ma la maggior parte delle implementazioni in JavaScript sono più avanzate di così, come descritto: queste mantengono la funzione invocabile nella variante a più argomenti. ``` ## Riepilogo