1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
---
language: Paren
filename: learnparen-de.paren
contributors:
- ["KIM Taegyoon", "https://github.com/kimtg"]
- ["Claudson Martins", "https://github.com/claudsonm"]
translators:
- ["Dennis Keller", "https://github.com/denniskeller"]
lang: de-de
---
[Paren](https://bitbucket.org/ktg/paren) ist ein Dialekt von Lisp.
Es ist als eingebettete Sprache konzipiert.
Manche Beispiele sind von <http://learnxinyminutes.com/docs/racket/>.
```scheme
;;; Kommentare
# Kommentare
;; Einzeilige Kommentare starten mit einem Semikolon oder einem Hashtag
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 1. Primitive Datentypen und Operatoren
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Zahlen
123 ; int
3.14 ; double
6.02e+23 ; double
(int 3.14) ; => 3 : int
(double 123) ; => 123 : double
;; Funktionsapplikationen werden so geschrieben: (f x y z ...)
;; Dabei ist f eine Funktion und x, y, z sind die Operatoren.
;; Wenn du eine Literalliste von Daten erstelllen möchtest,
;; verwende (quote) um zu verhindern, dass sie ausgewertet zu werden.
(quote (+ 1 2)) ; => (+ 1 2)
;; Nun einige arithmetische Operationen
(+ 1 1) ; => 2
(- 8 1) ; => 7
(* 10 2) ; => 20
(^ 2 3) ; => 8
(/ 5 2) ; => 2
(% 5 2) ; => 1
(/ 5.0 2) ; => 2.5
;;; Wahrheitswerte
true ; for Wahr
false ; for Falsch
(! true) ; => Falsch
(&& true false (prn "doesn't get here")) ; => Falsch
(|| false true (prn "doesn't get here")) ; => Wahr
;;; Zeichen sind Ints.
(char-at "A" 0) ; => 65
(chr 65) ; => "A"
;;; Zeichenketten sind ein Array von Zahlen mit fester Länge.
"Hello, world!"
"Benjamin \"Bugsy\" Siegel" ; Backslash ist ein Escape-Zeichen
"Foo\tbar\r\n" ; beinhaltet C Escapes: \t \r \n
;; Zeichenketten können auch verbunden werden!
(strcat "Hello " "world!") ; => "Hello world!"
;; Eine Zeichenketten kann als Liste von Zeichen behandelt werden
(char-at "Apple" 0) ; => 65
;; Drucken ist ziemlich einfach
(pr "Ich bin" "Paren. ") (prn "Schön dich zu treffen!")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 2. Variablen
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Du kannst Variablen setzen indem du (set) verwedest
;; eine Variable kann alle Zeichen besitzen außer: ();#"
(set some-var 5) ; => 5
some-var ; => 5
;; Zugriff auf eine zuvor nicht zugewiesene Variable erzeugt eine Ausnahme
; x ; => Unknown variable: x : nil
;; Lokale Bindung: Verwende das Lambda Calculus! 'a' und 'b'
;; sind nur zu '1' und '2' innerhalb von (fn ...) gebunden.
((fn (a b) (+ a b)) 1 2) ; => 3
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3. Sammlungen
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Listen
;; Listen sind Vektrorartige Datenstrukturen. (Zufälliger Zugriff ist O(1).
(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
;; 'list' ist ein komfortabler variadischer Konstruktor für Listen
(list 1 2 3) ; => (1 2 3)
;; und ein quote kann als literaler Listwert verwendet werden
(quote (+ 1 2)) ; => (+ 1 2)
;; Du kannst 'cons' verwenden um ein Element an den Anfang einer Liste hinzuzufügen.
(cons 0 (list 1 2 3)) ; => (0 1 2 3)
;; Listen sind ein sehr einfacher Typ, daher gibt es eine Vielzahl an Funktionen
;; für Sie. Ein paar Beispiele:
(map inc (list 1 2 3)) ; => (2 3 4)
(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4)
(length (list 1 2 3 4)) ; => 4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3. Funktionen
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Verwende 'fn' um Funktionen zu erstellen.
;; eine Funktion gibt immer den Wert ihres letzten Ausdrucks zurück
(fn () "Hello World") ; => (fn () Hello World) : fn
;; Verwende Klammern um alle Funktionen aufzurufen, inklusive Lambda Ausdrücke
((fn () "Hello World")) ; => "Hello World"
;; Zuweisung einer Funktion zu einer Variablen
(set hello-world (fn () "Hello World"))
(hello-world) ; => "Hello World"
;; Du kannst dies mit syntaktischen Zucker für die Funktionsdefinition verkürzen:
(defn hello-world2 () "Hello World")
;; Die () von oben ist eine Liste von Argumente für die Funktion.
(set hello
(fn (name)
(strcat "Hello " name)))
(hello "Steve") ; => "Hello Steve"
;; ... oder gleichwertig, unter Verwendung mit syntaktischen Zucker:
(defn hello2 (name)
(strcat "Hello " name))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 4. Gleichheit
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Für Zahlen verwende '=='
(== 3 3.0) ; => wahr
(== 2 1) ; => falsch
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 5. Kontrollfluss
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Bedingungen
(if true ; test Ausdruck
"this is true" ; then Ausdruck
"this is false") ; else Ausdruck
; => "this is true"
;;; Schleifen
;; for Schleifen ist für Zahlen
;; (for SYMBOL START ENDE SCHRITT AUSDRUCK ..)
(for i 0 10 2 (pr i "")) ; => schreibt 0 2 4 6 8 10
(for i 0.0 10 2.5 (pr i "")) ; => schreibt 0 2.5 5 7.5 10
;; while Schleife
((fn (i)
(while (< i 10)
(pr i)
(++ i))) 0) ; => schreibt 0123456789
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 6. Mutation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Verwende 'set' um einer Variablen oder einer Stelle einen neuen Wert zuzuweisen.
(set n 5) ; => 5
(set n (inc n)) ; => 6
n ; => 6
(set a (list 1 2)) ; => (1 2)
(set (nth 0 a) 3) ; => 3
a ; => (3 2)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 7. Makros
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Makros erlauben es dir die Syntax der Sprache zu erweitern.
;; Parens Makros sind einfach.
;; Tatsächlich ist (defn) ein Makro.
(defmacro setfn (name ...) (set name (fn ...)))
(defmacro defn (name ...) (def name (fn ...)))
;; Lass uns eine Infix Notation hinzufügen
;; Let's add an infix notation
(defmacro infix (a op ...) (op a ...))
(infix 1 + 2 (infix 3 * 4)) ; => 15
;; Makros sind nicht hygenisch, Du kannst bestehende Variablen überschreiben!
;; Sie sind Codetransformationenen.
```
|
