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
|
---
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 "doesn't get here")) ; => false
(|| false true (prn "doesn't get here")) ; => 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 () "Hello World") ; => (fn () Hello World) : fn
;; Используйте скобки, чтобы вызвать все функции, в том числе лямбда выражение
((fn () "Привет Мир")) ; => "Привет Мир"
;; Назначить функцию переменной
(set hello-world (fn () "Привет Мир"))
(hello-world) ; => "Привет Мир"
;; Вы можете сократить это, используя синтаксический сахар определения функции:
(defn hello-world2 () "Привет Мир")
;; Как и выше () - это список аргументов для функции
(set hello
(fn (name)
(strcat "Привет " name)))
(hello "Стив") ; => "Привет Стив"
;; ... or equivalently, using a sugared definition:
(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
;; Макросы приводят к неясному коду, т.е. вы можете затереть существующие переменные!
;; Они приобразуют код.
```
|
