lambdaway :: reduce3

6 | list | login |load

| |

_h1 map & reduce {sup {sup (2022/12/30)}}

{prewrap
'{map    {lambda {:x} :x:x}    a b c d}
-> {map    {lambda {:x} :x:x}    a b c d}
'{reduce {lambda {:x :y} :x:y} a b c d}
-> {reduce {lambda {:x :y} :x:y} a b c d}

'{map {lambda {:x} {* :x :x}}    
     {S.serie 0 10}}
-> {map    {lambda {:x} {* :x :x}}    {S.serie 0 10}}

factorial:
'{reduce {lambda {:x :y} {* :x :y}}
        {S.serie 1 10}}
-> {reduce {lambda {:x :y} {* :x :y}} {S.serie 1 10}}

fibonacci:
'{A.last 
 {reduce {{lambda {:x :y}
                  {A.set! 0 {A.get 1 :x} 
                  {A.set! 1 {+ {A.get 0 :x} {A.get 1 :x}} :x}}
          } {A.new 1 1}} 
         {S.serie 1 100}}} 
-> {A.last
 {reduce {{lambda {:x :y}
                  {A.set! 0 {A.get 1 :x} 
                  {A.set! 1 {+ {A.get 0 :x} {A.get 1 :x}} :x}}
          } {A.new 1 1}} 
         {S.serie 1 100}}}
}

_p Notes:
_ul map & reduce are equivalent to S.map & S.reduce, just slightly improved,
_ul map returns a sentence,
_ul in reduce {b :x} is the accumulator initialized with the first value,
_ul S.serie is unchanged and thus can be any sentence.

{pre °°
LAMBDATALK.DICT['map'] = function () {                          // {map sqr 0 1 2 ...}
  var args = LAMBDATALK.supertrim(arguments[0]).split(' ');     // [sqr,0,1,2,...]
  var func = args.shift();                                      // sqr & [0,1,2,...]
  var r = '';
  for (var i=0; i< args.length; i++)
    r += "{" + func + " " + args[i] + "} "                      // r = "r {sqr args[i]}"
  return r
};

LAMBDATALK.DICT['reduce'] = function () {                       // {reduce mul 1 2 3 ...}
  var args = LAMBDATALK.supertrim(arguments[0]).split(' ');     // [mul 1 2 3 ...]
  var func = args.shift();                                      // mul & [1,2,3,...]
  var r = args[0];                                              // r=1 & [2,3,...]
  for (var i=1; i< args.length; i++)
    r = "{" + func + " " + r + " " + args[i] + "}"              // r = {mul r args[i]}
  return r
}; 
°°}

{script 
LAMBDATALK.DICT['map'] = function () {                          // {map sqr 0 1 2 ...}
  var args = LAMBDATALK.supertrim(arguments[0]).split(' ');     // [sqr,0,1,2,...]
  var func = args.shift();                                      // sqr & [0,1,2,...]
  var r = '';
  for (var i=0; i< args.length; i++)
    r += "{" + func + " " + args[i] + "} "                      // r = "r {sqr args[i]}"
  return r
};

}

°°°
{prewrap
'{def iter
 {lambda {:f :n}
  {A.last 
   {reduce {:f.compute {:f.init}} 
             {S.serie 1 :n}}}}}    
-> {def iter
 {lambda {:f :n}
  {A.last {reduce {:f.compute {:f.init}} {S.serie 1 :n}}}}}

1) fac

'{def fac
 {def fac.init {A.new 1}}                       // a = [0]
 {def fac.compute
  {lambda {:a :i}
   {A.set! 0 {long_mult :i {A.get 0 :a}} :a}}}  // a[0] = i*a[0]
}
-> {def fac
 {def fac.init {A.new 1}}
 {def fac.compute
  {lambda {:a :i}
   {A.set! 0 {long_mult :i {A.get 0 :a}} :a}}}
}
 
 {map {fac.compute {A.new 1}} {S.serie 1 6}}

'{iter fac 500}
-> {iter fac 500}

2) fib

'{def fib
 {def fib.init {A.new 0 1}}                         // a = [0,1]
 {def fib.compute
  {lambda {:a :i}
   {A.set! 1 {long_add {A.get 0 :a} {A.get 1 :a}}   // a[1] = a[0]+a[1]
   {A.set! 0 {A.get 1 :a} :a}}}}                    // a[0] = a[1]
}
-> {def fib
 {def fib.init {A.new 0 1}}
 {def fib.compute
  {lambda {:a :i}
   {A.set! 1 {long_add {A.get 0 :a} {A.get 1 :a}} 
   {A.set! 0 {A.get 1 :a} :a}}}}
}

{A.last {reduce {fib.compute {A.new 0 1}} {S.serie 1 10}} }

'{iter fib 500}
-> {iter fib 500}  
}
°°°