Weiterentwicklung von JavaScript orientiert sich an Python

[Leonidas]

OK, aber was mache ich wenn ich a bis z haben will? li = [a..z] wäre da geil oder gleich li = [a..z..] + [A..Z] + [1..100]

Also so kompliziert ist das nun auch wieder nicht:

Code: Alles auswählen

import string
li = list(string.ascii_lowercase)
ls += list(string.ascii_uppercase) + range(1, 101)

Vor allem ignoriert es sowieso die deutschen Umlaute, also wäre a..z nur bedingt erweiterbar.

[BlackJack]

mit skin meine ich wie der code aussieht. mit AST meine ich die semantik des codes. der gleiche code kann in php so aussehen, in js anders und in python wieder ganz anders. so verstaendlich?

Das funktioniert aber nicht wirklich, weil eine Sprache nicht nur aus Syntax, sondern eben auch aus Semantik besteht. Und die lässt sich bei unterschiedlichen Sprachen vielleicht noch in einen gemeinsamen Bytecode übersetzen, aber die Rücktransformierung in eine andere Sprache ist nicht immer möglich.

Wie übersetzt man zum Beispiel Bytecode oder AST mit dynamischem Scope (REXX oder Perl) in eine Sprache die nur lexikografischen Scope kennt, wie Python oder Java.

muss noch was loswerden. wenn man in einer sprache ausdruecken koennte, dass die argumente vor dem call nicht evaluiert werden sollen, sondern als callable oder AST, dann koennte man sowas machen:

Code: Alles auswählen

# macro() nimmt ne funktion, macht ein macro draus
while = macro( (condition, block) {
    loop = {
        if (condition()) {
            block()
            loop()
        }
    }
    loop()
})

a = 0
while(a < 10,
    print a**2
    a += 1
)

das bringt natuerlich wieder ganz andere probleme mit sich (bloecke muessten dann expressions sein, usw), ich weiss. waere aber ne ueberlegung wert, hm?

Solche Sprachen gibt's. Neben der Übergabe von Codeblöcken die erst in der aufgerufenen Funktion ausgewertet werden, kann man das auch per Metaprogrammierung lösen, also wirklich ein Makro das bei der Übersetzung ausgeführt und ersetzt wird. Mit Lisp oder Scheme kann man so etwas machen. Und bei D mit Templates oder dem ``lazy`` Schlüsselwort bei in der Argumentliste. Bei Nemerle ginge eine Makrolösung. Und in Io sieht die `while`-Schleife fast genau so aus. Io hat unheimlich wenige Schlüsselworte, alle Flusskontrollstukturen sind Methoden, die auf dem "Ur-Objekt" definiert sind. Hier ist die `while`-Schleife selbst implementiert:

Code: Alles auswählen

myWhile := method(
    loop(
        call evalArgAt(0) ifFalse(break)
        call evalArgAt(1)
    )
)

a := 0
myWhile(a < 10,
    a pow(2) linePrint
    a = a + 1
)

Jetzt möchte ich mal sehen wie das in einen AST übersetzt und dann in Python "rückübersetzt" aussehen soll!?

[cracki]

erstmal wird hier garnichts in bytecode uebersetzt. bytecode ist schon zu spaet.

so soll das dann sein: der AST ist die idealform des codes und ist so high level wie es geht. "code" wiederholt sich nicht mehr im AST.

die faehigkeiten von "skins" begreife ich selber nicht ganz, auch weil ich in die richtung erstmal nicht weiter denken will.
mein vorheriges beispiel php/c waere aber mit skins eher nicht machbar (so viel versteh ich mittlerweile). grund: die semantik der kernsprache (in dem fall die noch nicht erfundene idealsprache) scheint in jedem fall durch. wenn man also variablen vor dem gebrauch deklarieren muss oder *kann/darf*, dann ist das teil der semantik.
lediglich die parser regeln liessen sich veraendern, so dass man z.b. einem lisp einige der klammern abschneiden kann, einige infix-operatoren zur syntax hinzufuegen kann, gescheite syntax fuer lambda und blockstruktur dazumischt, etc...

was ich mit alledem eigentlich ausdruecken will:
es gibt keine sprache, die heute jeden menschen befriedigen kann. skins waeren eine moeglichkeit, eine sprache fuer alles zu erschaffen und diese dann fuer jeden anwendungsbereich zu verkleiden [1]


[1] es gibt genug high level sprachen, die sehr optimierten code ausspucken. maschinenperformance ist kein argument, schon garnicht bei den immer schnelleren prozessoren. viel mehr zaehlt, wie schnell, einfach und fehlerfrei der mensch ein programm schreiben kann. das erreicht man bekanntermassen weniger mit assembly als mit echten hochsprachen.

[BlackJack]

was ich mit alledem eigentlich ausdruecken will:
es gibt keine sprache, die heute jeden menschen befriedigen kann. skins waeren eine moeglichkeit, eine sprache fuer alles zu erschaffen und diese dann fuer jeden anwendungsbereich zu verkleiden

So eine Sprache die alle toll finden wird es auch in Zukunft nicht geben. Bzw. ist das was Du beschreibst, die Sprache für alles, eigentlich Assembler und die Skins sind Compiler für die verschiedensten Programmiersprachen.

Hier nochmal Deine Idee von einer eigenen ``while``-Schleife in D:

Code: Alles auswählen

import std.stdio;

void myWhile(lazy bool test, void delegate () statement)
{
loop:
    if (! test()) return;
    statement();
    goto loop;
}

void main()
{
    ubyte a = 0;

    myWhile(a < 10, { writefln(a); ++a; });
}

[Leonidas]

Hier nochmal Deine Idee von einer eigenen ``while``-Schleife in D:

Ist übrigens inzwischen in Version 1.0 erschienen, grad heute auf Golem gelesen, nachdem sie hier in den letzten Tagen ein Thema war.

[sape]

RTFM, mein Junge

Schau dir mal die Konstanten im Modul `string` an.

1. Bin nicht dein Junge!
2. Habe ich schon
3. OMG, wäre hätte das gedachnt das `string` Konstanten definiert hat -> Ja weiß ich, darum geht es aber nciht das war nur ein Beispiel wo noch sowas sinnvol wäre
4. [X..Y] wäre genauso "Sinnvoll" wie [1..100]
5. Nochmal ab den Post von Leonidas den Rest lesen!
6. SELF OWNED! (Wo wir gerade dabei sind schwachsinnige Akronyme wie RTFM zu nutzen)
7. Ich denke es ist angekommen oder?

[Leonidas]

Hey, sape, nur mit der Ruhe!

4. [X..Y] wäre genauso "Sinnvoll" wie [1..100]

Nicht ganz. Ich brauche wesentlich öfter Ranges mit Zahlen als mit Buchstaben. Vor allem geht es in a..z darum alle Kleinbuchstaben zu bekommen aber in 1..100 nicht darum alle Zahlen zu bekommen.

6. SELF OWNED! (Wo wir gerade dabei sind schwachsinnige Akronyme wie RTFM zu nutzen)
7. Ich denke es ist angekommen oder?

Hey, sind wir heute aggressiv? Ist irgendwie lächerlich, eine sachliche Diskussion auf ein Persönliches Flamen runterzuziehen.

Also, einmal mis zehn zählen, alternativ auch bis Zwanzigeins oder Zehnvierzig und durchatmen.