Flory Function Prototype

[flory]

ich hab ein schönes Beispiel für funktionales
Programmieren gefunden, passt auch zum Thema XML:

function addTag(tag) {
  var stag='<'+tag+'>';
  var etag='</'+tag+'>';
  return function(x) {
    return stag+x+etag;
  }
}  
 
Function.prototype.after=function(g) {
  var f=this;
  return function(x) {
    return f(g(x));
  }
}
 
trace(addTag("b").after(addTag("i"))("helo")); 

[Gnut]

Elegant und nützlich flory.

[hOk]

Das Teil ist ja abgefahren, flory,
muss ich aber erstmal verdauen,
netten Gruß, Holger

[bokel]

Tolles Beispiel,
das erinnert mich an lang zurückliegende Lisp-Vorlesungen.

Da muss man wirklich zweimal hinschauen,
um zu kapieren, was überhaupt passiert.

Und so was wie die Funktion, die von addTag geliefert wird,
ist dann wohl ein Lambda, oder wie war das ?

Merci für die Auffrischung,
mfg r.


Edit:
Hier gibt es einen kleinen Kurs in Lisp
http://apsymac33.uni-trier.de:8080/art/pp

[flory]

um ehrlich zu sein, habe ich das mit den Lambdas auch
noch nicht 100%ig kapiert, ich glaube das ist noch
etwas komplizierter.

Hier nochmal dasselbe Beispiel mit flexiblen Parametern:

Function.prototype.after=function(g) {
        var f=this;
        return function() {
                return f(g(arguments));
        }
}
 
function addTag(tag,attributes) {
        var stag='<'+tag+" "+attributes+'>';
        var etag='</'+tag+'>';
        return function(x) {
                return stag+x+etag;
        }
}
 
res=addTag("b","class=\"classname\"").after(addTag("b"))("helo"); 

und Schleife mal anders:

Function.prototype.loop=function(x) {
  var f=this;
  return function() {
    for (var i=0; i<x; i++) {
        f.apply(f,arguments);      
    }
  }
}
 
a=function(x,y) {
    trace(x+" "+y);
}
 
a.loop(10)("helo","world"); 

Sonnige Grüsse
Florian

[bokel]

Ja, herrlich nicht wahr ?

Btw. das mit der Schleife muesste man noch rekursiv lösen,
damit es richtig passt. Und schon wieder stossen wir an die
256-Barriere

mfg r.

[flory]

wieso müsste man das rekursiv lösen? für einen Loop passt
das doch so.

Florian

[bokel]

"muss" man natürlich nicht,
aber ich dachte wir wollen
funktionale Programmierung simulieren

mfg r.

[flory]

>aber ich dachte wir wollen
>funktionale Programmierung simulieren

ok, wenn man es streng auslegt, sind Schleifen da
natürlich nicht erlaubt.
Mal schauen, wohin das alles führt, Function.prototype-
Erweiterungen werden ja noch kaum benutzt.

Florian

[bokel]

Rekursiv könnte das so ausehen,
auch nicht unbedingt schöner
Ausserdem muesste man dann
strenggenommen das if auch noch
ersetzen.

Function.prototype.loop = function(x) {
    if(x-- <= 0) return null;
    //
    var f = this;
    return function () {
        f.apply(f, arguments);
        f.loop(x).apply(f, arguments);
    };
};
a = function (x, y) {
    trace(x + " " + y);
};
a.loop(10)("helo", "world"); 

mfg r.

[flory]

ja, schön!
so wäre es denke ich erlaubt, weil ? : ja eine Expression ist:

Function.prototype.loop = function(x) {
    x--;
    var f = this;      
    return (x<0) ? null : function () {
                f.apply(f, arguments);
                f.loop(x).apply(f, arguments);
        }
}; 

und noch ein interessanter Code-Schnipsel:

Function.prototype.keepArguments=function() {
    var f=this;
    var args=arguments;
    return function() {
       return f.apply(f, args);
    }
}
z=function(x,y) {
  return x*y;   
}
z1=z.keepArguments(2,3);
trace(z1()); 

[k7c4]

@flory

Das letzte ist ja ideal, um callBacks und Event-Handler mit Parametern hinzukriegen

Function.prototype.callWith=function() {
        var f=this;
        var args=arguments;
        return function() {
                return f.apply(f, args);
        }
}
 
this.onEnterFrame = trace.callWith(10) 

[flory]

genau - schönes Beispiel.

Da kann man noch viel mehr mit machen...

Florian

[bokel]

Hier noch ein Schnipsel aus der 4-Gewinnt-Engine

Function.prototype.executeLater = function(timeToWait, obj, paramArray) {
    var func = this;
    var intervalId = setInterval(function (obj) {
        func.apply(obj, paramArray);
        clearInterval(intervalId);
    }, timeToWait, obj);
}; 

Damit kann man eine Funktion einfach später
ausführen lassen.

function test(){
      trace("test " + arguments);
}
 
test.executeLater(1000, this, "bokel", "was", "here"); 

mfg r .

[dassoud]

sehr schön, danke!

@bokel: hast du hier schon aufgeräumt?

dassoud