mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 10:01:38 +00:00
Merge pull request #1941 from xou/haskell-umlaut-fix
[haskell/de] [yaml/de] Fix umlauts
This commit is contained in:
commit
df82b37a36
@ -59,7 +59,7 @@ not False -- True
|
|||||||
-- Strings und Zeichen
|
-- Strings und Zeichen
|
||||||
"Das ist ein String."
|
"Das ist ein String."
|
||||||
'a' -- Zeichen
|
'a' -- Zeichen
|
||||||
'Einfache Anfuehrungszeichen gehen nicht.' -- error!
|
'Einfache Anführungszeichen gehen nicht.' -- error!
|
||||||
|
|
||||||
-- Strings können konkateniert werden.
|
-- Strings können konkateniert werden.
|
||||||
"Hello " ++ "world!" -- "Hello world!"
|
"Hello " ++ "world!" -- "Hello world!"
|
||||||
@ -90,11 +90,11 @@ not False -- True
|
|||||||
-- Der "!!"-Operator extrahiert das Element an einem bestimmten Index:
|
-- Der "!!"-Operator extrahiert das Element an einem bestimmten Index:
|
||||||
[1..10] !! 3 -- 4
|
[1..10] !! 3 -- 4
|
||||||
|
|
||||||
-- Haskell unterstuetzt unendliche Listen!
|
-- Haskell unterstützt unendliche Listen!
|
||||||
[1..] -- Die Liste aller natuerlichen Zahlen
|
[1..] -- Die Liste aller natürlichen Zahlen
|
||||||
|
|
||||||
-- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation"
|
-- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation"
|
||||||
-- unterstuetzt. Haskell evaluiert erst etwas, wenn es benötigt wird.
|
-- unterstützt. Haskell evaluiert erst etwas, wenn es benötigt wird.
|
||||||
-- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir:
|
-- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir:
|
||||||
|
|
||||||
[1..] !! 999 -- 1000
|
[1..] !! 999 -- 1000
|
||||||
@ -106,7 +106,7 @@ not False -- True
|
|||||||
-- Zwei Listen konkatenieren
|
-- Zwei Listen konkatenieren
|
||||||
[1..5] ++ [6..10]
|
[1..5] ++ [6..10]
|
||||||
|
|
||||||
-- Ein Element als Head hinzufuegen
|
-- Ein Element als Head hinzufügen
|
||||||
0:[1..5] -- [0, 1, 2, 3, 4, 5]
|
0:[1..5] -- [0, 1, 2, 3, 4, 5]
|
||||||
|
|
||||||
-- Weitere Listenoperationen
|
-- Weitere Listenoperationen
|
||||||
@ -152,7 +152,7 @@ add 1 2 -- 3
|
|||||||
(//) a b = a `div` b
|
(//) a b = a `div` b
|
||||||
35 // 4 -- 8
|
35 // 4 -- 8
|
||||||
|
|
||||||
-- Guards sind eine einfache Möglichkeit fuer Fallunterscheidungen.
|
-- Guards sind eine einfache Möglichkeit für Fallunterscheidungen.
|
||||||
fib x
|
fib x
|
||||||
| x < 2 = 1
|
| x < 2 = 1
|
||||||
| otherwise = fib (x - 1) + fib (x - 2)
|
| otherwise = fib (x - 1) + fib (x - 2)
|
||||||
@ -186,7 +186,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
|
|||||||
-- 4. Mehr Funktionen
|
-- 4. Mehr Funktionen
|
||||||
----------------------------------------------------
|
----------------------------------------------------
|
||||||
|
|
||||||
-- currying: Wenn man nicht alle Argumente an eine Funktion uebergibt,
|
-- currying: Wenn man nicht alle Argumente an eine Funktion übergibt,
|
||||||
-- so wird sie eine neue Funktion gebildet ("curried").
|
-- so wird sie eine neue Funktion gebildet ("curried").
|
||||||
-- Es findet eine partielle Applikation statt und die neue Funktion
|
-- Es findet eine partielle Applikation statt und die neue Funktion
|
||||||
-- nimmt die fehlenden Argumente auf.
|
-- nimmt die fehlenden Argumente auf.
|
||||||
@ -209,7 +209,7 @@ foo = (*4) . (+10)
|
|||||||
foo 5 -- 60
|
foo 5 -- 60
|
||||||
|
|
||||||
|
|
||||||
-- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchfuehrt.
|
-- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchführt.
|
||||||
-- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
|
-- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
|
||||||
-- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
|
-- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
|
||||||
-- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
|
-- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
|
||||||
@ -238,14 +238,14 @@ even . fib $ 7 -- false
|
|||||||
True :: Bool
|
True :: Bool
|
||||||
|
|
||||||
-- Funktionen haben genauso Typen.
|
-- Funktionen haben genauso Typen.
|
||||||
-- `not` ist Funktion die ein Bool annimmt und ein Bool zurueckgibt:
|
-- `not` ist Funktion die ein Bool annimmt und ein Bool zurückgibt:
|
||||||
-- not :: Bool -> Bool
|
-- not :: Bool -> Bool
|
||||||
|
|
||||||
-- Eine Funktion die zwei Integer Argumente annimmt:
|
-- Eine Funktion die zwei Integer Argumente annimmt:
|
||||||
-- add :: Integer -> Integer -> Integer
|
-- add :: Integer -> Integer -> Integer
|
||||||
|
|
||||||
-- Es ist guter Stil zu jeder Funktionsdefinition eine
|
-- Es ist guter Stil zu jeder Funktionsdefinition eine
|
||||||
-- Typdefinition darueber zu schreiben:
|
-- Typdefinition darüber zu schreiben:
|
||||||
double :: Integer -> Integer
|
double :: Integer -> Integer
|
||||||
double x = x * 2
|
double x = x * 2
|
||||||
|
|
||||||
@ -317,7 +317,7 @@ data Maybe a = Nothing | Just a
|
|||||||
-- Diese sind alle vom Typ Maybe:
|
-- Diese sind alle vom Typ Maybe:
|
||||||
Just "hello" -- vom Typ `Maybe String`
|
Just "hello" -- vom Typ `Maybe String`
|
||||||
Just 1 -- vom Typ `Maybe Int`
|
Just 1 -- vom Typ `Maybe Int`
|
||||||
Nothing -- vom Typ `Maybe a` fuer jedes `a`
|
Nothing -- vom Typ `Maybe a` für jedes `a`
|
||||||
|
|
||||||
----------------------------------------------------
|
----------------------------------------------------
|
||||||
-- 8. Haskell IO
|
-- 8. Haskell IO
|
||||||
@ -326,8 +326,8 @@ Nothing -- vom Typ `Maybe a` fuer jedes `a`
|
|||||||
-- IO kann nicht völlig erklärt werden ohne Monaden zu erklären,
|
-- IO kann nicht völlig erklärt werden ohne Monaden zu erklären,
|
||||||
-- aber man kann die grundlegenden Dinge erklären.
|
-- aber man kann die grundlegenden Dinge erklären.
|
||||||
|
|
||||||
-- Wenn eine Haskell Programm ausgefuehrt wird, so wird `main` aufgerufen.
|
-- Wenn eine Haskell Programm ausgeführt wird, so wird `main` aufgerufen.
|
||||||
-- Diese muss etwas vom Typ `IO ()` zurueckgeben. Zum Beispiel:
|
-- Diese muss etwas vom Typ `IO ()` zurückgeben. Zum Beispiel:
|
||||||
|
|
||||||
main :: IO ()
|
main :: IO ()
|
||||||
main = putStrLn $ "Hello, sky! " ++ (say Blue)
|
main = putStrLn $ "Hello, sky! " ++ (say Blue)
|
||||||
@ -355,10 +355,10 @@ sayHello = do
|
|||||||
-- an die Variable "name" gebunden
|
-- an die Variable "name" gebunden
|
||||||
putStrLn $ "Hello, " ++ name
|
putStrLn $ "Hello, " ++ name
|
||||||
|
|
||||||
-- Uebung: Schreibe deine eigene Version von `interact`,
|
-- Übung: Schreibe deine eigene Version von `interact`,
|
||||||
-- die nur eine Zeile einliest.
|
-- die nur eine Zeile einliest.
|
||||||
|
|
||||||
-- `sayHello` wird niemals ausgefuehrt, nur `main` wird ausgefuehrt.
|
-- `sayHello` wird niemals ausgeführt, nur `main` wird ausgeführt.
|
||||||
-- Um `sayHello` laufen zulassen kommentiere die Definition von `main`
|
-- Um `sayHello` laufen zulassen kommentiere die Definition von `main`
|
||||||
-- aus und ersetze sie mit:
|
-- aus und ersetze sie mit:
|
||||||
-- main = sayHello
|
-- main = sayHello
|
||||||
@ -376,7 +376,7 @@ action = do
|
|||||||
input1 <- getLine
|
input1 <- getLine
|
||||||
input2 <- getLine
|
input2 <- getLine
|
||||||
-- Der Typ von `do` ergibt sich aus der letzten Zeile.
|
-- Der Typ von `do` ergibt sich aus der letzten Zeile.
|
||||||
-- `return` ist eine Funktion und keine Schluesselwort
|
-- `return` ist eine Funktion und keine Schlüsselwort
|
||||||
return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
|
return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
|
||||||
|
|
||||||
-- Nun können wir `action` wie `getLine` benutzen:
|
-- Nun können wir `action` wie `getLine` benutzen:
|
||||||
@ -387,7 +387,7 @@ main'' = do
|
|||||||
putStrLn result
|
putStrLn result
|
||||||
putStrLn "This was all, folks!"
|
putStrLn "This was all, folks!"
|
||||||
|
|
||||||
-- Der Typ `IO` ist ein Beispiel fuer eine Monade.
|
-- Der Typ `IO` ist ein Beispiel für eine Monade.
|
||||||
-- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit
|
-- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit
|
||||||
-- eine rein funktional Sprache zu sein.
|
-- eine rein funktional Sprache zu sein.
|
||||||
-- Jede Funktion die mit der Außenwelt interagiert (z.B. IO)
|
-- Jede Funktion die mit der Außenwelt interagiert (z.B. IO)
|
||||||
@ -404,7 +404,7 @@ main'' = do
|
|||||||
|
|
||||||
-- Starte die REPL mit dem Befehl `ghci`
|
-- Starte die REPL mit dem Befehl `ghci`
|
||||||
-- Nun kann man Haskell Code eingeben.
|
-- Nun kann man Haskell Code eingeben.
|
||||||
-- Alle neuen Werte muessen mit `let` gebunden werden:
|
-- Alle neuen Werte müssen mit `let` gebunden werden:
|
||||||
|
|
||||||
let foo = 5
|
let foo = 5
|
||||||
|
|
||||||
@ -413,7 +413,7 @@ let foo = 5
|
|||||||
>:t foo
|
>:t foo
|
||||||
foo :: Integer
|
foo :: Integer
|
||||||
|
|
||||||
-- Auch jede `IO ()` Funktion kann ausgefuehrt werden.
|
-- Auch jede `IO ()` Funktion kann ausgeführt werden.
|
||||||
|
|
||||||
> sayHello
|
> sayHello
|
||||||
What is your name?
|
What is your name?
|
||||||
@ -437,6 +437,6 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
|
|||||||
Haskell ist sehr einfach zu installieren.
|
Haskell ist sehr einfach zu installieren.
|
||||||
Hohl es dir von [hier](http://www.haskell.org/platform/).
|
Hohl es dir von [hier](http://www.haskell.org/platform/).
|
||||||
|
|
||||||
Eine sehr viele langsamere Einfuehrung findest du unter:
|
Eine sehr viele langsamere Einführung findest du unter:
|
||||||
[Learn you a Haskell](http://learnyouahaskell.com/) oder
|
[Learn you a Haskell](http://learnyouahaskell.com/) oder
|
||||||
[Real World Haskell](http://book.realworldhaskell.org/).
|
[Real World Haskell](http://book.realworldhaskell.org/).
|
||||||
|
@ -30,7 +30,7 @@ null_Wert: null
|
|||||||
Schlüssel mit Leerzeichen: value
|
Schlüssel mit Leerzeichen: value
|
||||||
# Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber:
|
# Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber:
|
||||||
jedoch: "Ein String in Anführungzeichen"
|
jedoch: "Ein String in Anführungzeichen"
|
||||||
"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schluessel haben willst."
|
"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schlüssel haben willst."
|
||||||
|
|
||||||
# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
|
# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
|
||||||
# oder ein 'folded block' (> gefolgt vom text).
|
# oder ein 'folded block' (> gefolgt vom text).
|
||||||
@ -64,7 +64,7 @@ eine_verschachtelte_map:
|
|||||||
hallo: hallo
|
hallo: hallo
|
||||||
|
|
||||||
# Schlüssel müssen nicht immer String sein.
|
# Schlüssel müssen nicht immer String sein.
|
||||||
0.25: ein Float-Wert als Schluessel
|
0.25: ein Float-Wert als Schlüssel
|
||||||
|
|
||||||
# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
|
# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
|
||||||
? |
|
? |
|
||||||
|
Loading…
Reference in New Issue
Block a user