Flory Function Prototype

[flory]

ok. das kommt dem gängigen FP-Arsenal ja schon ziemlich nahe.
Listenverarbeitung ist dabei ja sehr gefragt. In AS heissen Listen
natürlich Arrays.
Hier ein Link dazu:
http://www.crosswinds.net/~agauld/tutfctnl.htm

und die Umsetzung in AS:

Array.prototype.map=function(fct) {
  var result=[];
  for (var i=0; i<this.length; i++) {
      result.push(fct(this[i]));
  }
  return result;
}
 
Array.prototype.filter=function(fct) {
  var result=[];
  for (var i=0; i<this.length; i++) {
      if (fct(this[i])==true) result.push(this[i]);
  }
  return result;
}
 
Array.prototype.reduce=function(fct) {
    var result=this[0];
    for (var i=1; i<this.length; i++) {
        result=fct(result,this[i]); 
    }
    return result;
} 

une eine Beispielanwendung:

function FunctionMultiplyBy(factor) {
  // var factor
  return function(n) {
    return n*factor;  
  }
}
 
x4=FunctionMultiplyBy(4);
 
function isOdd(n) {
  return n%2==0;    
}
 
a=[2,5,7,8];
b=a.filter(isOdd).map(x4);
trace(b); 

Was tut das ganze?
Filtert erst die geraden Zahlen raus und multipliziert diese dann mit 4.

Das schöne ist die Flexibilität, die dadurch entsteht, daß man beliebige
Funktionen übergeben kann. siehe auch Array.sort - da gibts ja auch
die Comparefunction als Parameter.

Vielleicht findet jemand mal ein sinnvolles Beispiel
z.B. mit Strings - finde alle Elemente die mit "F" anfangen und hänge "_xyz" hintendran o.s.ä

Gtx
Florian

[flory]

ok, mach ich´s gleich selber

// zählt die Anzahl der Aufrufe einer Funktion und übergibt die
// Zahl wahlweise auch gleich als Parameter
 
Function.prototype.countCalls=function(n,passAsArgument) {
    var f=this;
 
    if (passAsArgument) {
        var f2=function() {
            f2.calls++;
            arguments.push(f2.calls);
            return f.apply(null,arguments);  
        }
    } else {
        var f2=function() {
            f2.calls++;   
            return f.apply(null,arguments);  
        }
    }
    f2.calls=n;
    return f2;
}
 
// hänge beim Aufruf Argumente dran
Function.prototype.addArguments=function() {
    var f=this;
    var args=arguments;
    return function() {
        return f.apply(null,arguments.concat(args));  
    }
}
 
startsWith=function(str,letter) { return str.charAt(0)==letter; }
connectWithAnd=function(a,b) {  return a+" and "+b;}
addIndex=function(s,cnt){return s+" is "+cnt+"."};
 
trace(["Fred","Peter","Heinz","Horst","Frieda"].filter(startsWith.addArguments("F")).map(addIndex.countCalls(0,true)).reduce(connectWithAnd)); 

besonders im Zusammenhang mit RecordSet und Datenbank
abfragen fällt mir da einiges zu ein ...

[bokel]

saweeeet !

mfg r.

[flory]

jo!

wenn man verstanden hat, was map, filter und reduce tun, ist es auch
gar nicht so unverständlich.

ist nur ein anderer blickwinkel

[dassoud]

klasse!

[Dominic H.]

Ahhh! Wie herbe! Echt klasse!
Vielen Dank!

Viele Grüße
Dominic

[flory]

kleines Update:
in RecordSet gibts schon von Hause genau diese Methode "filter", die eine Funktion als Parameter erwartet.
In der neuen iX steht ein Artikel über funktionales Programmieren mit Python. Zwischen Python
und AS/ECMA-Scripte gibt es einige Parallelen, auch wenn der Syntax zunächst etwas anders ist.

[Madokan]

Ah noch jemand der sich mit Python auseinandersetzt - yup flory da kann ich nur zustimmen. Bin gespannt wie sich Python so machen wird, selbst bei einigen Providern wird Python bereits angeboten.

Liebe Grüsse
Matze K.

[dassoud]

python?

habe ich auch installiert, brauche ich aber nur für winCVS. ich werde aber auch mal 'nen blick darauf werfen...

dassoud

[Madokan]

dassoud es lohnt sich.

Liebe Grüsse
Matze K.

[pheidrias]

Boah Jungs !

Thread gerade erst entdeckt...

Super Idee, auch mal den function.prototype etwas zu bemühen !

mehr ,
pheidrias

[bokel]

Ein alter Thread aus der Versenkung
Ich habe gerade gelesen, dass das nächste Python 2.5 die "teilweise Funktionsanwendung" unterstützt. (LOL, die deutsche Übersetzung hört sich echt bescheiden an gegenüber "partial function application"). Das passt ganz gut in das Thema hier, weil das eigentlich aus der funktionalen Programmierwelt kommt.
Wenn man eine Funktion mit 7 Parametern hat, und sie mit 3 Parametern aufruft, dann bekommt man als Ergebnis eine Funktion, die die restlichen 4 Parameter nimmt. Sowas können wir mit AS relativ einfach nachbauen. Die Funktion partial liefert eine Funktion, die als argumente die Argumente von partial selbst plus die aktuellen Argumente bekommt.

Function.prototype.partial():Function{
    var args:Array = arguments.slice(1);
    return function(){
        return this.apply( null, args.concat( arguments));
    }
} 

Als Beispiel benutzen wir eine Funktion, die zwei Parameter bekommt und setzen mit partial den ersten Parameter fest.

function addNumbers(v1:Number, v2:Number):Number{
    trace("addNumbers " + [v1,v2]);
    return v1 + v2;
}
trace(addNumbers(3,4)); //7
var add5:Function = addNumbers.partial(5);
trace(add5(6)); //11 
 

Wer weiss, vielleicht kann man es ja irgendwann mal brauchen
mfg Ralf.

[Janoscharlipp]

Lustige Sache das!
So könnte man auch fehlende Parameter ergänzen, bzw. Fehler schmeißen, wenn Parameter fehlen … oder überladen … oder oder
Nur einsetzen würde ich es nicht da fehlt mir die Typensicherheit, aber um Code unleserlich zu machen, ist es allemal tauglich