Ich möchte mich Leonidas anschliessen. Insbesondere wenn die Sprachen einem ganz anderen Paradigma folgen wie zum Beispiel funktionale Sprachen. Wie man vielleicht an dem Nemerle-Beispiel sehen kann. Oder hier in Haskell, einer reinen funktionalen Programmiersprache:
Code: Alles auswählen
listTest = unlines (map (show.(* 2)) [1..10])
var = 42
compareWith42 value = f (compare value 42)
where f LT = "kleiner"
f EQ = "weder grösser noch kleiner"
f GT = "grösser"
test42 = unwords ["Var ist", compareWith42 var, "als 42."]
main = putStrLn (listTest ++ test42)
Alles ist Funktion, alles hat einen Rückgabewert. Funktionen sind auch Werte. Nehmen wir mal den Teilausdruck ``show.(* 2)`` aus der ersten Zeile und schauen uns die Typen der Komponenten an:
Code: Alles auswählen
Prelude> :type (*)
(*) :: (Num a) => a -> a -> a
Prelude> :type 2
2 :: (Num t) => t
Prelude> :type (* 2)
(* 2) :: (Num a) => a -> a
Prelude> :type show
show :: (Show a) => a -> String
Prelude> :type show.(* 2)
show.(* 2) :: (Num a) => a -> String
``(*)`` ist also eine Funktion die zwei Argumente eines numerischen Typs entgegen nimmt und ein Ergebnis dieses Typs liefert. Auch `2` ist eine Funktion(!) die einen konstanten Wert liefert. Wenn man nun `(*)` auf `2` anwendet, dann ist das kein Syntaxfehler weil nur ein Argument übergeben wurde, sondern die Anwendung auf ein Argument ergibt automatische eine Funktion die nur noch das andere Argument benötigt. Sozusagen eine Funktion der man den Namen `verdoppeln` geben könnte:
Code: Alles auswählen
Prelude> let verdoppeln = (* 2)
Prelude> verdoppeln 42
84
Prelude> verdoppeln 23
46
`show` erwartet ein Argument das zur Typklasse `Show` gehört und liefert eine Zeichenkette. Es wandelt solche Argumente also um.
Mit dem Funktionskompositionsoperator, dem Punkt, kann man aus zwei Funktionen eine neue erschaffen die beide Funktionen nacheinander auf ein Argument anwenden. Es gilt also ``f.g x = f(g(x))``. So wird eine Funktion erzeugt die erst ein Element mit 2 multipliziert und dann in eine Zeichenkette umwandelt. Und diese Funktion wird auf jedes Element der Liste ``[1..10]`` angewandt.
Es gilt wie in der Mathematik, das man einer Variablen nur einmal etwas zuweisen kann und das steht dann im Laufe der Berechnung fest! Man könnte also nicht ein paar Zeilen später ``var = 23`` schreiben, das wäre ein Fehler der die Übersetzung abbricht. Es gibt in reinen funktionalen Sprachen keine Sprungbefehle oder Schleifen, nur Rekursion. Das ist alles andere als nur eine andere Syntax. Da muss man komplett umdenken.
Aber auch bei eher imperativen, objektorientierten Sprachen kann es gewaltige semantische Unterschiede zu Java oder Python geben. Zum Beispiel Sprachen bei denen es keine Klassen gibt, sondern nur Objekte die man klonen und verändern kann. Welche bei denen Argumente von Methodenaufrufen nicht grundsätzlich vor dem Aufruf ausgewertet werden, sondern wo der Empfänger entscheiden kann ob, wann und in welchem Kontext der jeweilige Ausdruck ausgewertet werden soll. So eine Sprache ist Io. ``if`` ist dort eine Methode die drei Argumente erhält die *nicht vor* dem Aufruf ausgewertet werden. Die Methode wertet erst das erste Argument aus und entscheidet dann, je nachdem ob dabei wahr oder falsch herausgekommen ist, ob das zweite ("then-Zweig") oder das dritte ("else-Zweig") Argument ausgewertet werden muss und liefert auch dessen Rückgabewert als Ergebnis.
Man sollte sich schon auf die jeweilige Programmiersprache einlassen und nicht nur fragen wie Kommentare gekennzeichnet werden und wo das Semikolon hinkommt, und ansonsten so weitermachen wie man es von der letzten Sprache gewohnt war. In comp.lang.python wurde mal jemandem, der versucht hat Python wie Java zu behandeln, gesagt: Wenn Du aufhörst die Sprache zu bekämpfen, dann hast Du mehr Zeit das Problem anzugehen das Du lösen willst. (Frei übersetzt)