JavaScript curry:¿cuáles son las aplicaciones prácticas?

StackOverflow https://stackoverflow.com/questions/113780

Pregunta

Creo que no me he grokked alarmada todavía.Entiendo lo que hace, y cómo hacerlo.Simplemente no puedo pensar en una situación en que yo usaría.

Dónde estás usando alarmada en JavaScript (o donde están las principales librerías a usar)?Manipulación del árbol DOM o general de desarrollo de aplicaciones ejemplos de bienvenida.

Una de las respuestas menciona animación.Funciones como slideUp, fadeIn tomar un elemento como argumentos y son normalmente un curry de la función de devolución de la alta orden de la función con el valor de "animación a la función" built-in.¿Por qué es mejor que la aplicación de la alto-función con algunos valores predeterminados?

¿Hay alguna desventaja de usar?

Como se pide aquí están algunos buenos recursos en JavaScript alarmada:

Voy a añadir más a medida que los cultivos en los comentarios.

Así, de acuerdo a las respuestas, alarmada y parcial de la aplicación en general son de conveniencia técnicas.

Si usted está con frecuencia "refinación" una función de alto nivel por medio de una llamada con la misma configuración, usted puede curry (o el uso de Resig parcial) el nivel superior de la función para crear de forma simple, concisa métodos auxiliares.

¿Fue útil?

Solución

@Hank Gay

En respuesta a EmbiggensTheMind comentario:

No puedo pensar en una instancia donde alarmada—por sí mismo—es útil en JavaScript;es una técnica para convertir las llamadas de función con múltiples argumentos en las cadenas de llamadas a la función con un argumento único para cada llamada, pero JavaScript soporta múltiples argumentos en una sola llamada a la función.

En JavaScript—y supongo que la mayoría de los otros idiomas (no cálculo lambda)—es comúnmente asociados con la aplicación parcial, aunque.John Resig lo explica mejor, pero lo esencial es que tiene cierta lógica que se aplica a dos o más argumentos, y sólo usted sabe el valor de(s) para algunos de los argumentos.

Puede utilizar la aplicación parcial/alarmada a fijar los valores conocidos y de retorno de una función que sólo acepta las incógnitas, para ser invocada más tarde, cuando en realidad tienen los valores que se deseen transmitir.Esto proporciona una ingeniosa manera de evitar la repetición de sí mismo cuando usted hubiera sido llamar a la misma JavaScript construido-ins más y más con los mismos valores, pero en uno.Robar John ejemplo:

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

Otros consejos

He aquí un muy interesante Y práctico el uso de alarmada en JavaScript que utiliza cierres:

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"

Este se basa en un curry la extensión de Function, aunque como se puede ver solo se utiliza la apply (nada demasiado sofisticado):

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)));
    }
}

He encontrado las funciones que se asemejan a los de python functools.partial más útil en 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 qué quieres usar?Una situación común en la que desee utilizar esto es cuando usted desea enlazar this en una función para un valor de:

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

Ahora, cuando callback es llamado, this puntos a obj.Esto es útil en caso de situaciones o para ahorrar algo de espacio, ya que por lo general hace el código más corto.

Alarmada es similar a la parcial, con la diferencia de que la función de la alarmada devuelve sólo acepta un argumento (como tengo entendido que).

De acuerdo con Hank Gay - Es muy útil en ciertas verdadero lenguajes de programación funcional - porque es una parte necesaria.Por ejemplo, en Haskell usted simplemente no puede tomar varios parámetros a una función - no puedes hacer eso en puro programación funcional.La toma de un parámetro en un tiempo y construir su función.En JavaScript es simplemente innecesario, a pesar de las ingenió ejemplos como "convertidor".Aquí está el convertidor de código, sin la necesidad de alarmada:

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

Tenía un gran deseo de Douglas Crockford, en "JavaScript:Las Partes Buenas", había dado alguna mención de la historia y el uso real de los alarmada lugar de su offhanded comentarios.Para el tiempo más largo después de leer eso, yo estaba sorprendido, hasta que yo estaba estudiando programación Funcional y se dio cuenta de que es de donde vino.

Después de algo más de pensamiento, que me planteas no es una válidos el caso de uso para alarmada en JavaScript:si usted está tratando de escribir con puras funcionales técnicas de programación con JavaScript.Parece un raro caso de uso, aunque.

He aquí un ejemplo.

Estoy instrumentar un montón de campos con JQuery para que yo pueda ver lo que los usuarios están haciendo.El código es este:

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

(Para los no-JQuery los usuarios, estoy diciendo que en cualquier momento de un par de campos de obtener o perder el foco, y quiero que el trackActivity() función.Yo también podría utilizar una función anónima, pero tendría que duplicar 4 veces, así que lo sacó y lo nombró.)

Ahora resulta que uno de los campos debe ser manejado de manera diferente.Me gustaría ser capaz de pasar de un parámetro en una de esas llamadas que se pasan junto a nuestra infraestructura de seguimiento.Con alarmada, me puede.

No es magia ni nada...sólo una agradable abreviatura de funciones anónimas.

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

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

Las llamadas a parcial (MochiKit la terminología.Creo que algunas otras bibliotecas dar funciones de una .curry método que hace la misma cosa) se ven un poco mejor y menos ruidosos que las funciones anónimas.

Como para las bibliotecas de uso, siempre hay Funcional.

Cuando es útil en JS?Probablemente el mismo de los tiempos es útil en otras lenguas modernas, pero la única vez que puedo ver a mí mismo que es de uso en conjunción con la aplicación parcial.

Yo diría que, más probablemente, de toda la animación de la biblioteca en JS está utilizando alarmada.En lugar de tener que pasar por cada llamada de un conjunto de elementos afectados y una función, que describe cómo el elemento debe comportarse, a un orden más alto de la función que se asegurará de que todos los temporización cosas, generalmente es más fácil para el cliente a la liberación, como la API pública alguna función como "slideUp", "fadeIn" que sólo toma elementos como argumentos, y que son sólo algunos al curry función que devuelve el alto de la orden de la función con el valor de "animación a la función" built-in.

Las funciones de JavaScript que se llama lamda en otro lenguaje funcional.Puede ser utilizado para componer una nueva api (más potente o complext función) a basado en otro del desarrollador de simple entrada.El Curry es sólo una de las técnicas.Se puede utilizar para crear una api simplificada para llamar a un complejo de la api.Si usted es el develper que utilizan la api simplificada (por ejemplo utilizar jQuery para hacer una simple manipulación), no es necesario el uso de curry.Pero si usted desea crear la api simplificada, el curry es su amigo.Usted tiene que escribir un framework javascript (como jQuery, mootools) o en la biblioteca, a continuación, se puede apreciar su poder.Escribí un mejor curry de la función, en http://blog.semanticsworks.com/2011/03/enhanced-curry-method.html .Usted no necesita el curry método para hacer alarmada, sólo ayuda a hacer alarmada, pero siempre se puede hacer de forma manual mediante la escritura de una función A(){} para volver otra función B(){}.Para hacerlo más interesante, el uso de la función B() para volver otra función C().

Sé que su hilo viejo, pero voy a tener que demostrar cómo se utiliza en las bibliotecas de javascript:

Voy a utilizar lodash.js biblioteca para describir los conceptos de manera concreta.

Ejemplo:

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

Aplicación Parcial:

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

Alarmada: 

var curriedFn = _.curry(fn);

Enlace: 

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!

diferencia:

después alarmada se obtiene una nueva función sin parámetros pre atado.

después de la aplicación parcial tenemos una función que está enlazado con algunos parámetros prebound.

en el enlace podemos enlazar un contexto que va a ser utilizado para reemplazar a 'este', si no obligado por defecto de cualquier función será la ventana de alcance.

Asesorar:No hay necesidad de reinventar la rueda.Aplicación parcial/la unión/alarmada están muy relacionadas.Usted puede ver la diferencia anterior.El uso de este significado en cualquier lugar y la gente va a reconocer lo que está haciendo sin problemas en la comprensión de plus, usted tendrá que usar menos código.

Estoy de acuerdo en que a veces te gustaría conseguir el balanceo de la bola mediante la creación de un pseudo-función que siempre tendrá el valor del primer argumento lleno.Afortunadamente, me encontré con una nueva biblioteca de JavaScript llamado jPaq (http://jpaq.org/) que proporciona esta funcionalidad.La mejor cosa acerca de la biblioteca es el hecho de que usted puede descargar su propia construcción, que sólo contiene el código que se necesita.

Acabo de escribir un jPaq ejemplo que muestra algunos de los geniales aplicaciones del curry de la función.Échale un vistazo aquí: Alarmada Hasta Funciones De Cadena

Sólo quería añadir algunos recursos para Functional.js:

Charla/conferencia explicando algunas aplicaciones http://www.youtube.com/watch?v=HAcN3JyQoyY

Actualizado Functional.js biblioteca:https://github.com/loop-recur/FunctionalJS Algunos buenos ayudantes (lo siento de nuevo aquí, no hay reputación :p):/bucle se repita/PreludeJS

He estado usando esta biblioteca recientemente para reducir la repetición en un js clientes de IRC de biblioteca auxiliar.Es una gran cosa - realmente ayuda a limpiar y simplificar el código.

Además, si el rendimiento se convierte en un problema (pero este lib es bastante luz), es fácil acaba de escribir usando una función nativa.

Usted puede utilizar los enlazar de forma rápida, a una línea de solución

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

Otra puñalada en ella, desde el trabajo con las promesas.

(Descargo de responsabilidad:JS noob, procedentes de los Python mundo.Incluso allí, alarmada no se utiliza mucho, pero puede ser útil en alguna ocasión.Así que me cribbed el alarmada función - ver los enlaces)

En primer lugar, estoy empezando con una llamada ajax.Tengo algunas específicas de procesamiento de hacer en caso de éxito, pero en caso de error, solo quiero dar al usuario la retroalimentación que llamar algo resultó en algunos de error.En mi código, me muestra el error de retroalimentación en un arranque de panel, pero estoy usando el registro aquí.

He modificado mi vivir url para hacer de este error.

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);
}

Ahora, en este orden de avisar al usuario de que un lote error, necesito escribir esa información en el controlador de errores, porque todo lo que está consiguiendo es una respuesta desde el servidor.

Todavía sólo tenemos la información disponible en el tiempo de codificación - en mi caso, tengo un número de posibles lotes, pero no sé que uno ha fallado w.o.el análisis de la respuesta del servidor sobre el error de url.

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

Vamos a hacer.Salida de la consola es:

consola:

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

Ahora, vamos a cambiar un poco las cosas y el uso genérico reutilizable fallo del controlador, pero también uno que es al curry en tiempo de ejecución con el conocido-en-el código de tiempo de contexto de llamada y el tiempo de ejecución de información disponible a partir de 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);
     };
}

consola:

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

Más en general, dado lo extendido de devolución de llamada, el uso es en JS, alarmada parece una muy útil herramienta para tener.

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

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top