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
|
---
language: Paren
filename: learnparen-ru.paren
contributors:
- ["KIM Taegyoon", "https://github.com/kimtg"]
translators:
- ["Dmitry Bessonov", "https://github.com/TheDmitry"]
lang: ru-ru
---
[Paren](https://bitbucket.org/ktg/paren) - это диалект языка Лисп. Он спроектирован как встроенный язык.
Примеры взяты <http://learnxinyminutes.com/docs/racket/>.
```scheme
;;; Комментарии
# комментарии
;; Однострочные комментарии начинаются с точки с запятой или символа решетки
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 1. Примитивные типы данных и операторы
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Числа
123 ; int
3.14 ; double
6.02e+23 ; double
(int 3.14) ; => 3 : int
(double 123) ; => 123 : double
;; Обращение к функции записывается так: (f x y z ...),
;; где f - функция, а x, y, z, ... - операнды
;; Если вы хотите создать буквальный список данных, используйте (quote), чтобы
;; предотвратить ненужные вычисления
(quote (+ 1 2)) ; => (+ 1 2)
;; Итак, некоторые арифметические операции
(+ 1 1) ; => 2
(- 8 1) ; => 7
(* 10 2) ; => 20
(^ 2 3) ; => 8
(/ 5 2) ; => 2
(% 5 2) ; => 1
(/ 5.0 2) ; => 2.5
;;; Логический тип
true ; обозначает истину
false ; обозначает ложь
(! true) ; => false
(&& true false (prn "досюда не доходим")) ; => false
(|| false true (prn "досюда не доходим")) ; => true
;;; Символы - это числа (int).
(char-at "A" 0) ; => 65
(chr 65) ; => "A"
;;; Строки - это массив символов с фиксированной длиной.
"Привет, мир!"
"Benjamin \"Bugsy\" Siegel" ; обратная косая черта экранирует символ
"Foo\tbar\r\n" ; включает управляющие символы в стиле Cи: \t \r \n
;; Строки тоже могут объединяться!
(strcat "Привет " "мир!") ; => "Привет мир!"
;; Строка может трактоваться подобно списку символов
(char-at "Apple" 0) ; => 65
;; Выводить информацию достаточно легко
(pr "Я" "Paren. ") (prn "Приятно познакомиться!")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 2. Переменные
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Вы можете создать или инициализировать переменную, используя (set)
;; имя переменной может содержать любой символ, исключая: ();#"
(set some-var 5) ; => 5
some-var ; => 5
;; Обращение к переменной, прежде не определенной, вызовет исключение
; x ; => Неизвестная переменная: x : nil
;; Локальное связывание: Используйте лямбда-вычисление! `a' и `b' связывается
;; с `1' и `2' только в пределах (fn ...)
((fn (a b) (+ a b)) 1 2) ; => 3
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3. Коллекции
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Списки
;; Списки подобны динамическому массиву (vector). (произвольный доступ равен O(1).)
(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
;; `list' - это удобный конструктор списков с переменным числом элементов
(list 1 2 3) ; => (1 2 3)
;; и quote может также использоваться для литеральных значений списка
(quote (+ 1 2)) ; => (+ 1 2)
;; Можно еще использовать `cons', чтобы добавить элемент в начало списка
(cons 0 (list 1 2 3)) ; => (0 1 2 3)
;; Списки являются основным типом, поэтому для них предусмотрено *много* функций
;; немного примеров из них:
(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. Функции
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Используйте `fn' для создания функций.
;; Функция всегда возвращает значение своего последнего выражения
(fn () "Привет Мир") ; => (fn () Привет Мир) : fn
;; Используйте скобки, чтобы вызвать все функции, в том числе лямбда-выражение
((fn () "Привет Мир")) ; => "Привет Мир"
;; Назначить функцию переменной
(set hello-world (fn () "Привет Мир"))
(hello-world) ; => "Привет Мир"
;; Вы можете сократить это, используя синтаксический сахар определения функции:
(defn hello-world2 () "Привет Мир")
;; Как и выше, () - это список аргументов для функции
(set hello
(fn (name)
(strcat "Привет " name)))
(hello "Стив") ; => "Привет Стив"
;; ... или, что эквивалентно, используйте синтаксический сахар определения:
(defn hello2 (name)
(strcat "Привет " name))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 4. Равенство
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; для чисел используйте `=='
(== 3 3.0) ; => true
(== 2 1) ; => false
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 5. Поток управления
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Условный оператор
(if true ; проверка выражения
"это - истина" ; тогда это выражение
"это - ложь") ; иначе другое выражение
; => "это - истина"
;;; Циклы
;; Цикл for для чисел
;; (for ИДЕНТИФИКАТОР НАЧАЛО КОНЕЦ ШАГ ВЫРАЖЕНИЕ ..)
(for i 0 10 2 (pr i "")) ; => печатает 0 2 4 6 8 10
(for i 0.0 10 2.5 (pr i "")) ; => печатает 0 2.5 5 7.5 10
;; Цикл while
((fn (i)
(while (< i 10)
(pr i)
(++ i))) 0) ; => печатает 0123456789
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 6. Изменение
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Используйте `set', чтобы назначить новое значение переменной или памяти
(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. Макросы
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Макросы позволяют вам расширять синтаксис языка.
;; Paren-макросы легкие.
;; Фактически, (defn) - это макрос.
(defmacro setfn (name ...) (set name (fn ...)))
(defmacro defn (name ...) (def name (fn ...)))
;; Давайте добавим инфиксную нотацию
(defmacro infix (a op ...) (op a ...))
(infix 1 + 2 (infix 3 * 4)) ; => 15
;; Макросы приводят к неясному коду, т.е. вы можете затереть существующие переменные!
;; Они являются кодопреобразующей конструкцией.
```
|
