JavaScript curry: quais são as aplicações práticas?

Eu não acho que eu grocou currying ainda. Eu entendo o que faz e como fazê-lo. Eu simplesmente não consigo pensar em uma situação que eu usaria.

Onde você está usando o curry em JavaScript (ou onde as principais bibliotecas estão usando)? Manipulação de DOM ou exemplos gerais de desenvolvimento de aplicativos são bem-vindos.

Uma das respostas menciona animação. Funções como slideUp, fadeIntomam um elemento como argumento e são normalmente uma função curry retornando a função de ordem superior com a “função de animação” padrão incorporada. Por que isso é melhor do que apenas aplicar a função superior com alguns padrões?

Existem desvantagens em usá-lo?

Conforme solicitado, aqui estão alguns bons recursos para currying JavaScript:

• http://www.dustindiaz.com/javascript-curry/
• Crockford, Douglas (2008) JavaScript: As Boas Peças
• http://www.svendtofte.com/code/curried_javascript/ (Desvia para o ML, pule a seção inteira de "Um curso intensivo no ML" e comece novamente em "Como escrever JavaScript ao curry")
• http://web.archive.org/web/20111217011630/http://blog.morrisjohns.com:80/javascript_closures_for_dummies
• Como funcionam os fechamentos de JavaScript?
• http://ejohn.org/blog/partial-functions-in-javascript (Sr. Resig sobre o dinheiro, como de costume)
• http://benalman.com/news/2010/09/partial-application-in-javascript/

Vou adicionar mais à medida que surgem nos comentários.

Portanto, de acordo com as respostas, curry e aplicação parcial em geral são técnicas de conveniência.

Se você está freqüentemente “refinando” uma função de alto nível chamando-a com a mesma configuração, pode curry (ou usar a função de nível superior da Resig) para criar métodos auxiliares concisos e simples.

@Hank Gay

Em resposta ao comentário de EmbiggensTheMind:

Não consigo pensar em uma instância em que o curry - por si só - seja útil em JavaScript; é uma técnica para converter chamadas de função com vários argumentos em cadeias de chamadas de função com um único argumento para cada chamada, mas o JavaScript suporta vários argumentos em uma única chamada de função.

No JavaScript - e eu assumo a maioria das outras linguagens reais (não o cálculo lambda) -, ele é geralmente associado à aplicação parcial. John Resig explica melhor , mas o essencial é que tenha alguma lógica que será aplicada a dois ou mais argumentos, e você só conhece o (s) valor (es) de alguns desses argumentos.

Você pode usar aplicação / curry parcial para corrigir esses valores conhecidos e retornar uma função que aceita apenas as incógnitas, a ser invocada posteriormente quando você realmente tiver os valores que deseja passar. Isso fornece uma maneira bacana de evitar se repetir quando você chamaria os mesmos built-ins JavaScript repetidamente, com os mesmos valores, exceto um. Para roubar o exemplo de João:

String.prototype.csv = String.prototype.split.partial(/,\s*/);
var results = "John, Resig, Boston".csv();
alert( (results[1] == "Resig") + " The text values were split properly" );

Aqui está um uso interessante e prático de currying em JavaScript que usa fechamentos :

function converter(toUnit, factor, offset, input) {
    offset = offset || 0;
    return [((offset + input) * factor).toFixed(2), toUnit].join(" ");
}

var milesToKm = converter.curry('km', 1.60936, undefined);
var poundsToKg = converter.curry('kg', 0.45460, undefined);
var farenheitToCelsius = converter.curry('degrees C', 0.5556, -32);

milesToKm(10);            // returns "16.09 km"
poundsToKg(2.5);          // returns "1.14 kg"
farenheitToCelsius(98);   // returns "36.67 degrees C"

Isso depende de uma curryextensão de Function, embora, como você pode ver, ele use apenas apply(nada demais):

Function.prototype.curry = function() {
    if (arguments.length < 1) {
        return this; //nothing to curry with - return function
    }
    var __method = this;
    var args = toArray(arguments);
    return function() {
        return __method.apply(this, args.concat([].slice.apply(null, arguments)));
    }
}

Encontrei funções que se assemelham ao python functools.partialmais útil em JavaScript:

function partial(fn) {
  return partialWithScope.apply(this,
    Array.prototype.concat.apply([fn, this],
      Array.prototype.slice.call(arguments, 1)));
}

function partialWithScope(fn, scope) {
  var args = Array.prototype.slice.call(arguments, 2);
  return function() {
    return fn.apply(scope, Array.prototype.concat.apply(args, arguments));
  };
}

Por que você gostaria de usá-lo? Uma situação comum em que você deseja usar isso é quando deseja vincular thisuma função a um valor:

var callback = partialWithScope(Object.function, obj);

Agora, quando o retorno de chamada é chamado, thisaponte para obj. Isso é útil em situações de evento ou para economizar espaço, pois geralmente reduz o código.

O curry é semelhante ao parcial, com a diferença de que a função que o curry retorna apenas aceita um argumento (tanto quanto eu o entendo).

Concordando com Hank Gay - é extremamente útil em certas linguagens de programação funcionais verdadeiras - porque é uma parte necessária. Por exemplo, em Haskell, você simplesmente não pode levar vários parâmetros a uma função - você não pode fazer isso em programação funcional pura. Você pega um parâmetro de cada vez e cria sua função. No JavaScript, é simplesmente desnecessário, apesar de exemplos inventados como "conversor". Aqui está o mesmo código do conversor, sem a necessidade de currying:

var converter = function(ratio, symbol, input) {
    return (input*ratio).toFixed(2) + " " + symbol;
}

var kilosToPoundsRatio = 2.2;
var litersToUKPintsRatio = 1.75;
var litersToUSPintsRatio = 1.98;
var milesToKilometersRatio = 1.62;

converter(kilosToPoundsRatio, "lbs", 4); //8.80 lbs
converter(litersToUKPintsRatio, "imperial pints", 2.4); //4.20 imperial pints
converter(litersToUSPintsRatio, "US pints", 2.4); //4.75 US pints
converter(milesToKilometersRatio, "km", 34); //55.08 km

Desejo muito que Douglas Crockford, em "JavaScript: The Good Parts", tenha mencionado alguma coisa sobre a história e o uso real do curry, em vez de suas observações irrelevantes. Durante muito tempo depois de ler isso, fiquei confuso, até estudar a programação funcional e perceber que é de onde veio.

Depois de pensar um pouco mais, afirmo que há um caso de uso válido para currying em JavaScript: se você estiver tentando escrever usando técnicas de programação funcional pura usando JavaScript. Parece um caso de uso raro.

Não é mágica nem nada ... apenas uma abreviação agradável para funções anônimas.

partial(alert, "FOO!") é equivalente a function(){alert("FOO!");}

partial(Math.max, 0) corresponde a function(x){return Math.max(0, x);}

As chamadas para parcial ( terminologia MochiKit . Acho que algumas outras bibliotecas dão às funções um método .curry que faz a mesma coisa) parecem um pouco mais agradáveis ​​e menos barulhentas que as funções anônimas.

Quanto às bibliotecas que o utilizam, há sempre Funcional .

Quando é útil em JS? Provavelmente, nas mesmas ocasiões, é útil em outras linguagens modernas, mas a única vez em que consigo me ver usando é em conjunto com a aplicação parcial.

Eu diria que, provavelmente, toda a biblioteca de animação em JS está usando currying. Em vez de precisar passar para cada chamada, um conjunto de elementos impactados e uma função, descrevendo como o elemento deve se comportar, para uma função de ordem superior que garantirá todo o tempo necessário, geralmente é mais fácil para o cliente liberar, como API pública funções como "slideUp", "fadeIn" que usa apenas elementos como argumentos e que são apenas algumas funções ao curry que retornam a função de ordem superior com a "função de animação" padrão incorporada.

Aqui está um exemplo.

Estou instrumentando vários campos com o JQuery para que eu possa ver o que os usuários estão fazendo. O código fica assim:

$('#foo').focus(trackActivity);
$('#foo').blur(trackActivity);
$('#bar').focus(trackActivity);
$('#bar').blur(trackActivity);

(Para usuários não-JQuery, estou dizendo que sempre que alguns campos obtêm ou perdem o foco, desejo que a função trackActivity () seja chamada. Também poderia usar uma função anônima, mas precisaria duplicá-la. 4 vezes, então eu o peguei e o nomeei.)

Agora acontece que um desses campos precisa ser tratado de maneira diferente. Gostaria de passar um parâmetro em uma dessas chamadas a serem repassadas para nossa infraestrutura de rastreamento. Com curry, eu posso.

Funções JavaScript é chamado lamda em outra linguagem funcional. Ele pode ser usado para compor uma nova API (função mais poderosa ou complext) com base na entrada simples de outro desenvolvedor. O curry é apenas uma das técnicas. Você pode usá-lo para criar uma API simplificada para chamar uma API complexa. Se você é o desenvolvedor que usa a API simplificada (por exemplo, você usa o jQuery para fazer manipulação simples), não precisa usar curry. Mas se você deseja criar a API simplificada, o curry é seu amigo. Você precisa escrever uma estrutura javascript (como jQuery, mootools) ou biblioteca, para poder apreciar seu poder. Eu escrevi uma função aprimorada de curry, em http://blog.semanticsworks.com/2011/03/enhanced-curry-method.html. Você não precisa do método curry para currying, apenas ajuda a currying, mas sempre pode fazê-lo manualmente, escrevendo uma função A () {} para retornar outra função B () {}. Para torná-lo mais interessante, use a função B () para retornar outra função C ().

Eu conheço seu thread antigo, mas terei que mostrar como isso está sendo usado nas bibliotecas javascript:

Usarei a biblioteca lodash.js para descrever esses conceitos concretamente.

Exemplo:

var fn = function(a,b,c){ 
return a+b+c+(this.greet || ‘'); 
}

Aplicação parcial:

var partialFnA = _.partial(fn, 1,3);

Escovando:

var curriedFn = _.curry(fn);

Obrigatório:

var boundFn = _.bind(fn,object,1,3 );//object= {greet: ’!'}

uso:

curriedFn(1)(3)(5); // gives 9 
or 
curriedFn(1,3)(5); // gives 9 
or 
curriedFn(1)(_,3)(2); //gives 9


partialFnA(5); //gives 9

boundFn(5); //gives 9!

diferença:

após o curry, obtemos uma nova função sem parâmetros pré-vinculados.

após aplicação parcial, obtemos uma função que é vinculada a alguns parâmetros pré-encadeados.

na vinculação, podemos vincular um contexto que será usado para substituir 'this'; se não vinculado, o padrão de qualquer função será o escopo da janela.

Aconselhar: Não há necessidade de reinventar a roda. Aplicação parcial / encadernação / currying estão muito relacionados. Você pode ver a diferença acima. Use esse significado em qualquer lugar e as pessoas reconhecerão o que você está fazendo sem problemas de compreensão, além de ter que usar menos código.

Concordo que, às vezes, você gostaria de fazer a bola rolar criando uma pseudo-função que sempre terá o valor do primeiro argumento preenchido. Felizmente, me deparei com uma nova biblioteca JavaScript chamada jPaq (h ttp: // jpaq.org/ ), que fornece essa funcionalidade. A melhor coisa da biblioteca é o fato de que você pode fazer o download de sua própria compilação, que contém apenas o código necessário.

Acabei de escrever um exemplo de jPaq que mostra algumas aplicações interessantes da função curry. Confira aqui: Currying Up String Funtions

Só queria adicionar alguns recursos para Functional.js:

Palestra / conferência explicando algumas aplicações http://www.youtube.com/watch?v=HAcN3JyQoyY

Biblioteca Functional.js atualizada: https://github.com/loop-recur/FunctionalJS Alguns bons ajudantes (desculpe, novo aqui, sem reputação: p): / loop-recur / PreludeJS

Eu tenho usado essa biblioteca muito recentemente para reduzir a repetição em uma biblioteca auxiliar de clientes js IRC. É ótimo - realmente ajuda a limpar e simplificar o código.

Além disso, se o desempenho se tornar um problema (mas essa biblioteca é bastante leve), é fácil reescrever usando uma função nativa.

Você pode usar a ligação nativa para uma solução rápida de uma linha

function clampAngle(min, max, angle) {
    var result, delta;
    delta = max - min;
    result = (angle - min) % delta;
    if (result < 0) {
        result += delta;
    }
    return min + result;
};

var clamp0To360 = clampAngle.bind(null, 0, 360);

console.log(clamp0To360(405)) // 45

Outra facada, por trabalhar com promessas.

(Isenção de responsabilidade: JS noob, proveniente do mundo Python. Mesmo lá, o curry não é muito usado, mas pode ser útil de vez em quando.

Primeiro, estou começando com uma chamada ajax. Eu tenho algum processamento específico para fazer com sucesso, mas com falha, eu só quero dar ao usuário o feedback de que chamar algo resultou em algum erro . No meu código real, eu exibo o feedback de erro em um painel de inicialização, mas estou apenas usando o log aqui.

Modifiquei meu URL ativo para fazer com que isso falhe.

function ajax_batch(e){
    var url = $(e.target).data("url");

    //induce error
    url = "x" + url;

    var promise_details = $.ajax(
        url,
        {
            headers: { Accept : "application/json" },
            // accepts : "application/json",
            beforeSend: function (request) {
                if (!this.crossDomain) {
                    request.setRequestHeader("X-CSRFToken", csrf_token);
                }
        },
        dataType : "json",
        type : "POST"}
    );
    promise_details.then(notify_batch_success, fail_status_specific_to_batch);
}

Agora, aqui, para informar ao usuário que um lote falhou, preciso escrever essas informações no manipulador de erros, porque tudo o que está recebendo é uma resposta do servidor.

Ainda tenho apenas as informações disponíveis no momento da codificação - no meu caso, tenho vários lotes possíveis, mas não sei qual deles falhou ao analisar a resposta do servidor sobre o URL com falha.

function fail_status_specific_to_batch(d){
    console.log("bad batch run, dude");
    console.log("response.status:" + d.status);
}

Vamos fazer isso. A saída do console é:

console:

bad batch run, dude utility.js (line 109) response.status:404

Agora, vamos mudar um pouco as coisas e usar um manipulador de falhas genérico reutilizável, mas também um que é acessado em tempo de execução com o contexto de chamada conhecido no momento do código e as informações de tempo de execução disponíveis no evento.

    ... rest is as before...
    var target = $(e.target).text();
    var context = {"user_msg": "bad batch run, dude.  you were calling :" + target};
    var contexted_fail_notification = curry(generic_fail, context); 

    promise_details.then(notify_batch_success, contexted_fail_notification);
}

function generic_fail(context, d){
    console.log(context);
    console.log("response.status:" + d.status);
}

function curry(fn) {
     var slice = Array.prototype.slice,
        stored_args = slice.call(arguments, 1);
     return function () {
        var new_args = slice.call(arguments),
              args = stored_args.concat(new_args);
        return fn.apply(null, args);
     };
}

console:

Object { user_msg="bad batch run, dude. you were calling :Run ACL now"} utility.js (line 117) response.status:404 utility.js (line 118)

De maneira mais geral, considerando o uso generalizado de retorno de chamada em JS, o curry parece ser uma ferramenta bastante útil.

https://javascriptweblog.wordpress.com/2010/04/05/curry-cooking-up-tastier-functions/ http://www.drdobbs.com/open-source/currying-and-partial-functions-in- javasc / 231001821? pgno = 2