?

¿seguro?

alert("I'd like some Spaghetti!");
alert("I'd like some Chocolate Moose!");

function SwedishChef( food )
{
    alert("I'd like some " + food + "!");
}
SwedishChef("Spaghetti");
SwedishChef("Chocolate Moose");

Cook( "lobster", 
      "water", 
      function(x) { alert("pot " + x); }  
);

Cook( "chicken", 
      "coconut", 
      function(x) { alert("boom " + x);} 
);

alert("get the lobster");
PutInPot("lobster");
PutInPot("water");

alert("get the chicken");
BoomBoom("chicken");
BoomBoom("coconut");

function Cook( i1, i2, f )
{
    alert("get the " + i1);
    f(i1);
    f(i2);
}

Cook( "lobster", "water", PutInPot );
Cook( "chicken", "coconut", BoomBoom );

funciones anónimas como argumentos

var a = [1,2,3];
	
for (i=0; i<a.length; i++)
{
    a[i] = a[i] * 2;
}

function map(fn, a)
{
    for (i = 0; i < a.length; i++)
    {
        a[i] = fn(a[i]);
    }
}

map( function(x){return x*2;}, a );
map( alert, a );

function sum(a)
{
    var s = 0;
    for (i = 0; i < a.length; i++)
        s += a[i];
    return s;
}
    
function join(a)
{
    var s = "";
    for (i = 0; i < a.length; i++)
        s += a[i];
    return s;
}
    
alert(sum([1,2,3]));
alert(join(["a","b","c"]));

function reduce(fn, a, init)
{   var s = init;
    for (i = 0; i < a.length; i++)
        s = fn( s, a[i] );
    return s;
}
function sum(a)
{    return reduce( 
        function(a, b){ return a + b; }, 
        a,
        0 );
}
function join(a)
{    return reduce( 
        function(a, b){ return a + b; },
        a, 
        "" );
}

function pair(a)
{   var s = [];
    for (i = 0; i < a.length; i++){
        if (a[i]%2==0){
            s.push(a[i]);
        }
    }
    return s;
}    
    
alert(pair([1,2,3]));

function filter(fn, a)
{   var s = init;
    for (i = 0; i < a.length; i++)
        s = fn( s, a[i] );
    return s;
}


function pair(a)
{    return filter( 
        function(x){ return (x%2==0); }, 
        a);
}

"se pueden pasar como argumento"

map( function(x){return x*2;}, a );
map( alert, a );

sin efectos colaterales

mismas salidas para mismas entradas

a = b + c

fáciles de concatenar

x = y + z

 a = x - b  

a = y + z - b

sin estado

inmutables

(x, y) → x + y

x → (y → x + y)

function(x) {
    return function(y) {
        return x + y;
    };
}

function(x, y) {
    return x + y;
}

(x, y) → x + y

x → (y → x + y)

function g(h) {
    return function(y) {
        return h(h(y));
    };
}

1000 === g(function(x) {
    return x * x;
})(10);

function g(h) {
    return function(y) {
        return h(h(y));
    };
}

var n = g(function(x) {
    return x * x;
});

1001000 === n(10) + n(100);

= 

funciones de orden superior

map

reduce

filter

muchos patrones son específicos del paradigma,

resuelven problemas específicos del paradigma...

...cada paradigma tiene sus patrones

- trabajar con funciones puras

- un lenguaje con funciones como first-class citizen

- funciones de orden superior

- paradigma declarativo

FRP = FP + RP

take input and produce output

input - transform- output

todo el tiempo

... pero las aplicaciones 

dan outputs diferentes ...

... porque en las aplicaciones

los inputs varian con el tiempo. 

aquí el programador indica qué hace la máquina en función de los inputs

un puñado de clicks

una secuencia de entrada

un array de eventos

stream

¿responderá correctamente la programación reactiva?

enorme cantidad de eventos en tiempo real que dan alta interactividad al usuario.

nos enfrentamos a enormes problemas de escala, expectativas y confianza en el software de nuestra vida cotidiana.

se puede ver como algunos paradigmas del pasado puede que no se escalen bien en el presente, y seguramente no en el futuro.

lo nuevo es todo lo demás