加载中...

Racket

其中 Y=racket

源代码下载： learnracket-zh.rkt

Racket是Lisp/Scheme家族中的一个通用的，多范式的编程语言。 非常期待您的反馈！你可以通过@th3rac25或以用户名为 th3rac25 的Google邮箱服务和我取得联系

  1. #lang racket ; 声明我们使用的语言
  3. ;;; 注释
  5. ;; 单行注释以分号开始
  7. #| 块注释
  8.    可以横跨很多行而且...
  9.     #|
  10.        可以嵌套
  11.     |#
  12. |#
  14. ;; S表达式注释忽略剩下的表达式
  15. ;; 在调试的时候会非常有用
  16. #; (被忽略的表达式)
  18. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  19. ;; 1\. 原始数据类型和操作符
  20. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  22. ;;; 数字
  23. 9999999999999999999999 ; 整数
  24. #b111                  ; 二进制数字 => 7
  25. #o111                  ; 八进制数字 => 73
  26. #x111                  ; 十六进制数字 => 273
  27. 3.14                   ; 实数
  28. 6.02e+23
  29. 1/2                    ; 有理数
  30. 1+2i                   ; 复数
  32. ;; 函数调用写作(f x y z ...)
  33. ;; 在这里 f 是一个函数， x, y, z, ... 是参数
  34. ;; 如果你想创建一个列表数据的字面量, 使用 ' 来阻止它们
  35. ;; 被求值
  36. '(+ 1 2) ; => (+ 1 2)
  37. ;; 接下来，是一些数学运算
  38. (+ 1 1)  ; => 2
  39. (- 8 1)  ; => 7
  40. (* 10 2) ; => 20
  41. (expt 2 3) ; => 8
  42. (quotient 5 2) ; => 2
  43. (remainder 5 2) ; => 1
  44. (/ 35 5) ; => 7
  45. (/ 1 3) ; => 1/3
  46. (exact->inexact 1/3) ; => 0.3333333333333333
  47. (+ 1+2i  2-3i) ; => 3-1i
  49. ;;; 布尔类型
  50. #t ; 为真
  51. #f ; 为假，#f 之外的任何值都是真
  52. (not #t) ; => #f
  53. (and 0 #f (error "doesn't get here")) ; => #f
  54. (or #f 0 (error "doesn't get here"))  ; => 0
  56. ;;; 字符
  57. #\A ; => #\A
  58. #\λ ; => #\λ
  59. #\u03BB ; => #\λ
  61. ;;; 字符串是字符组成的定长数组
  62. "Hello, world!"
  63. "Benjamin \"Bugsy\" Siegel"   ; \是转义字符
  64. "Foo\tbar\41\x21\u0021\a\r\n" ; 包含C语言的转义字符，和Unicode
  65. "λx:(μα.α→α).xx"              ; 字符串可以包含Unicode字符
  67. ;; 字符串可以相加
  68. (string-append "Hello " "world!") ; => "Hello world!"
  70. ;; 一个字符串可以看做是一个包含字符的列表
  71. (string-ref "Apple" 0) ; => #\A
  73. ;; format 可以用来格式化字符串
  74. (format "~a can be ~a" "strings" "formatted")
  76. ;; 打印字符串非常简单
  77. (printf "I'm Racket. Nice to meet you!\n")
  79. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  80. ;; 2\. 变量
  81. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  82. ;; 你可以使用 define 定义一个变量
  83. ;; 变量的名字可以使用任何字符除了: ()[]{}",'`;#|\
  84. (define some-var 5)
  85. some-var ; => 5
  87. ;; 你也可以使用Unicode字符
  88. (define ⊆ subset?)
  89. (⊆ (set 3 2) (set 1 2 3)) ; => #t
  91. ;; 访问未赋值的变量会引发一个异常
  92. ; x ; => x: undefined ...
  94. ;; 本地绑定: `me' 被绑定到 "Bob"，并且只在 let 中生效
  95. (let ([me "Bob"])
  96.   "Alice"
  97.   me) ; => "Bob"
  99. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  100. ;; 3\. 结构和集合
  101. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  103. ;; 结构体
  104. (struct dog (name breed age))
  105. (define my-pet
  106.   (dog "lassie" "collie" 5))
  107. my-pet ; => #<dog>
  108. (dog? my-pet) ; => #t
  109. (dog-name my-pet) ; => "lassie"
  111. ;;; 对 (不可变的)
  112. ;; `cons' 返回对, `car' 和 `cdr' 从对中提取第1个
  113. ;; 和第2个元素
  114. (cons 1 2) ; => '(1 . 2)
  115. (car (cons 1 2)) ; => 1
  116. (cdr (cons 1 2)) ; => 2
  118. ;;; 列表
  120. ;; 列表由链表构成, 由 `cons' 的结果
  121. ;; 和一个 `null' (或者 '()) 构成，后者标记了这个列表的结束
  122. (cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
  123. ;; `list' 给列表提供了一个非常方便的可变参数的生成器
  124. (list 1 2 3) ; => '(1 2 3)
  125. ;; 一个单引号也可以用来表示一个列表字面量
  126. '(1 2 3) ; => '(1 2 3)
  128. ;; 仍然可以使用 `cons' 在列表的开始处添加一项
  129. (cons 4 '(1 2 3)) ; => '(4 1 2 3)
  131. ;; `append' 函数可以将两个列表合并
  132. (append '(1 2) '(3 4)) ; => '(1 2 3 4)
  134. ;; 列表是非常基础的类型，所以有*很多*操作列表的方法
  135. ;; 下面是一些例子:
  136. (map add1 '(1 2 3))          ; => '(2 3 4)
  137. (map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
  138. (filter even? '(1 2 3 4))    ; => '(2 4)
  139. (count even? '(1 2 3 4))     ; => 2
  140. (take '(1 2 3 4) 2)          ; => '(1 2)
  141. (drop '(1 2 3 4) 2)          ; => '(3 4)
  143. ;;; 向量
  145. ;; 向量是定长的数组
  146. #(1 2 3) ; => '#(1 2 3)
  148. ;; 使用 `vector-append' 方法将2个向量合并
  149. (vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
  151. ;;; Set(翻译成集合也不太合适，所以不翻译了..)
  153. ;; 从一个列表创建一个Set
  154. (list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
  156. ;; 使用 `set-add' 增加一个成员
  157. ;; (函数式特性: 这里会返回一个扩展后的Set，而不是修改输入的值)
  158. (set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
  160. ;; 使用 `set-remove' 移除一个成员
  161. (set-remove (set 1 2 3) 1) ; => (set 2 3)
  163. ;; 使用 `set-member?' 测试成员是否存在
  164. (set-member? (set 1 2 3) 1) ; => #t
  165. (set-member? (set 1 2 3) 4) ; => #f
  167. ;;; 散列表
  169. ;; 创建一个不变的散列表 (可变散列表的例子在下面)
  170. (define m (hash 'a 1 'b 2 'c 3))
  172. ;; 根据键取得值
  173. (hash-ref m 'a) ; => 1
  175. ;; 获取一个不存在的键是一个异常
  176. ; (hash-ref m 'd) => 没有找到元素
  178. ;; 你可以给不存在的键提供一个默认值
  179. (hash-ref m 'd 0) ; => 0
  181. ;; 使用 `hash-set' 来扩展一个不可变的散列表
  182. ;; (返回的是扩展后的散列表而不是修改它)
  183. (define m2 (hash-set m 'd 4))
  184. m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3))
  186. ;; 记住，使用 `hash` 创建的散列表是不可变的
  187. m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
  189. ;; 使用 `hash-remove' 移除一个键值对 (函数式特性，m并不变)
  190. (hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
  192. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  193. ;; 3\. 函数
  194. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  196. ;; 使用 `lambda' 创建函数
  197. ;; 函数总是返回它最后一个表达式的值
  198. (lambda () "Hello World") ; => #<procedure>
  199. ;; 也可以使用 Unicode 字符 `λ'
  200. (λ () "Hello World")     ; => 同样的函数
  202. ;; 使用括号调用一个函数，也可以直接调用一个 lambda 表达式
  203. ((lambda () "Hello World")) ; => "Hello World"
  204. ((λ () "Hello World"))      ; => "Hello World"
  206. ;; 将函数赋值为一个变量
  207. (define hello-world (lambda () "Hello World"))
  208. (hello-world) ; => "Hello World"
  210. ;; 你可以使用函数定义的语法糖来简化代码
  211. (define (hello-world2) "Hello World")
  213. ;; `()`是函数的参数列表
  214. (define hello
  215.   (lambda (name)
  216.     (string-append "Hello " name)))
  217. (hello "Steve") ; => "Hello Steve"
  218. ;; 同样的，可以使用语法糖来定义:
  219. (define (hello2 name)
  220.   (string-append "Hello " name))
  222. ;; 你也可以使用可变参数， `case-lambda'
  223. (define hello3
  224.   (case-lambda
  225.     [() "Hello World"]
  226.     [(name) (string-append "Hello " name)]))
  227. (hello3 "Jake") ; => "Hello Jake"
  228. (hello3) ; => "Hello World"
  229. ;; ... 或者给参数指定一个可选的默认值
  230. (define (hello4 [name "World"])
  231.   (string-append "Hello " name))
  233. ;; 函数可以将多余的参数放到一个列表里
  234. (define (count-args . args)
  235.   (format "You passed ~a args: ~a" (length args) args))
  236. (count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
  237. ;; ... 也可以使用不带语法糖的 `lambda' 形式:
  238. (define count-args2
  239.   (lambda args
  240.     (format "You passed ~a args: ~a" (length args) args)))
  242. ;; 你可以混用两种用法
  243. (define (hello-count name . args)
  244.   (format "Hello ~a, you passed ~a extra args" name (length args)))
  245. (hello-count "Finn" 1 2 3)
  246. ; => "Hello Finn, you passed 3 extra args"
  247. ;; ... 不带语法糖的形式:
  248. (define hello-count2
  249.   (lambda (name . args)
  250.     (format "Hello ~a, you passed ~a extra args" name (length args))))
  252. ;; 使用关键字
  253. (define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args)
  254.   (format "~a ~a, ~a extra args" g name (length args)))
  255. (hello-k)                 ; => "Hello World, 0 extra args"
  256. (hello-k 1 2 3)           ; => "Hello World, 3 extra args"
  257. (hello-k #:greeting "Hi") ; => "Hi World, 0 extra args"
  258. (hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args"
  259. (hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6)
  260.                                          ; => "Hi Finn, 6 extra args"
  262. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  263. ;; 4\. 判断是否相等
  264. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  266. ;; 判断数字使用 `='
  267. (= 3 3.0) ; => #t
  268. (= 2 1) ; => #f
  270. ;; 判断对象使用 `eq?'
  271. (eq? 3 3) ; => #t
  272. (eq? 3 3.0) ; => #f
  273. (eq? (list 3) (list 3)) ; => #f
  275. ;; 判断集合使用 `equal?'
  276. (equal? (list 'a 'b) (list 'a 'b)) ; => #t
  277. (equal? (list 'a 'b) (list 'b 'a)) ; => #f
  279. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  280. ;; 5\. 控制结构
  281. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  283. ;;; 条件判断
  285. (if #t               ; 测试表达式
  286.     "this is true"   ; 为真的表达式
  287.     "this is false") ; 为假的表达式
  288. ; => "this is true"
  290. ;; 注意, 除 `#f` 之外的所有值都认为是真
  291. (member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo)
  292. (if (member 'Groucho '(Harpo Groucho Zeppo))
  293.     'yep
  294.     'nope)
  295. ; => 'yep
  297. ;; `cond' 会进行一系列的判断来选择一个结果
  298. (cond [(> 2 2) (error "wrong!")]
  299.       [(< 2 2) (error "wrong again!")]
  300.       [else 'ok]) ; => 'ok
  302. ;;; 模式匹配
  304. (define (fizzbuzz? n)
  305.   (match (list (remainder n 3) (remainder n 5))
  306.     [(list 0 0) 'fizzbuzz]
  307.     [(list 0 _) 'fizz]
  308.     [(list _ 0) 'buzz]
  309.     [_          #f]))
  311. (fizzbuzz? 15) ; => 'fizzbuzz
  312. (fizzbuzz? 37) ; => #f
  314. ;;; 循环
  316. ;; 循环可以使用递归(尾递归)
  317. (define (loop i)
  318.   (when (< i 10)
  319.     (printf "i=~a\n" i)
  320.     (loop (add1 i))))
  321. (loop 5) ; => i=5, i=6, ...
  323. ;; 类似的，可以使用 `let` 定义
  324. (let loop ((i 0))
  325.   (when (< i 10)
  326.     (printf "i=~a\n" i)
  327.     (loop (add1 i)))) ; => i=0, i=1, ...
  329. ;; 看上面的例子怎么增加一个新的 `loop' 形式, 但是 Racket 已经有了一个非常
  330. ;; 灵活的 `for' 了:
  331. (for ([i 10])
  332.   (printf "i=~a\n" i)) ; => i=0, i=1, ...
  333. (for ([i (in-range 5 10)])
  334.   (printf "i=~a\n" i)) ; => i=5, i=6, ...
  336. ;;; 其他形式的迭代
  337. ;; `for' 允许在很多数据结构中迭代:
  338. ;; 列表, 向量, 字符串, Set, 散列表, 等...
  340. (for ([i (in-list '(l i s t))])
  341.   (displayln i))
  343. (for ([i (in-vector #(v e c t o r))])
  344.   (displayln i))
  346. (for ([i (in-string "string")])
  347.   (displayln i))
  349. (for ([i (in-set (set 'x 'y 'z))])
  350.   (displayln i))
  352. (for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))])
  353.   (printf "key:~a value:~a\n" k v))
  355. ;;; 更多复杂的迭代
  357. ;; 并行扫描多个序列 (遇到长度小的就停止)
  358. (for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j))
  359. ; => 0:x 1:y 2:z
  361. ;; 嵌套循环
  362. (for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j))
  363. ; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z
  365. ;; 带有条件判断的 `for`
  366. (for ([i 1000]
  367.       #:when (> i 5)
  368.       #:unless (odd? i)
  369.       #:break (> i 10))
  370.   (printf "i=~a\n" i))
  371. ; => i=6, i=8, i=10
  373. ;;; 更多的例子帮助你加深理解..
  374. ;; 和 `for' 循环非常像 -- 收集结果
  376. (for/list ([i '(1 2 3)])
  377.   (add1 i)) ; => '(2 3 4)
  379. (for/list ([i '(1 2 3)] #:when (even? i))
  380.   i) ; => '(2)
  382. (for/list ([i 10] [j '(x y z)])
  383.   (list i j)) ; => '((0 x) (1 y) (2 z))
  385. (for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10))
  386.   i) ; => '(6 8 10)
  388. (for/hash ([i '(1 2 3)])
  389.   (values i (number->string i)))
  390. ; => '#hash((1 . "1") (2 . "2") (3 . "3"))
  392. ;; 也有很多其他的内置方法来收集循环中的值:
  393. (for/sum ([i 10]) (* i i)) ; => 285
  394. (for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000
  395. (for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t
  396. (for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t
  397. ;; 如果需要合并计算结果, 使用 `for/fold'
  398. (for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10
  399. ;; (这个函数可以在大部分情况下替代普通的命令式循环)
  401. ;;; 异常
  403. ;; 要捕获一个异常，使用 `with-handlers' 形式
  404. (with-handlers ([exn:fail? (lambda (exn) 999)])
  405.   (+ 1 "2")) ; => 999
  406. (with-handlers ([exn:break? (lambda (exn) "no time")])
  407.   (sleep 3)
  408.   "phew") ; => "phew", 如果你打断了它，那么结果 => "no time"
  410. ;; 使用 `raise' 抛出一个异常后者其他任何值
  411. (with-handlers ([number?    ; 捕获抛出的数字类型的值
  412.                  identity]) ; 将它们作为普通值
  413.   (+ 1 (raise 2))) ; => 2
  415. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  416. ;; 6\. 可变的值
  417. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  419. ;; 使用 `set!' 给一个已经存在的变量赋一个新值
  420. (define n 5)
  421. (set! n (add1 n))
  422. n ; => 6
  424. ;; 给那些明确地需要变化的值使用 `boxes` (在其他语言里类似指针
  425. ;; 或者引用)
  426. (define n* (box 5))
  427. (set-box! n* (add1 (unbox n*)))
  428. (unbox n*) ; => 6
  430. ;; 很多 Racket 诗句类型是不可变的 (对，列表，等)，有一些既是可变的
  431. ;; 又是不可变的 (字符串，向量，散列表
  432. ;; 等...)
  434. ;; 使用 `vector' 或者 `make-vector' 创建一个可变的向量
  435. (define vec (vector 2 2 3 4))
  436. (define wall (make-vector 100 'bottle-of-beer))
  437. ;; 使用 `vector-set!` 更新一项
  438. (vector-set! vec 0 1)
  439. (vector-set! wall 99 'down)
  440. vec ; => #(1 2 3 4)
  442. ;; 创建一个空的可变散列表，然后操作它
  443. (define m3 (make-hash))
  444. (hash-set! m3 'a 1)
  445. (hash-set! m3 'b 2)
  446. (hash-set! m3 'c 3)
  447. (hash-ref m3 'a)   ; => 1
  448. (hash-ref m3 'd 0) ; => 0
  449. (hash-remove! m3 'a)
  451. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  452. ;; 7\. 模块
  453. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  455. ;; 模块让你将你的代码组织为多个文件，成为可重用的模块，
  456. ;; 在这里，我们使用嵌套在本文的整个大模块
  457. ;; 里的子模块(从 "#lang" 这一行开始)
  459. (module cake racket/base ; 基于 racket/base 定义一个 `cake` 模块
  461.   (provide print-cake) ; 这个模块导出的函数
  463.   (define (print-cake n)
  464.     (show "   ~a   " n #\.)
  465.     (show " .-~a-. " n #\|)
  466.     (show " | ~a | " n #\space)
  467.     (show "---~a---" n #\-))
  469.   (define (show fmt n ch) ; 内部函数
  470.     (printf fmt (make-string n ch))
  471.     (newline)))
  473. ;; 使用 `require` 从模块中得到所有 `provide` 的函数
  474. (require 'cake) ; 这里的 `'`表示是本地的子模块
  475. (print-cake 3)
  476. ; (show "~a" 1 #\A) ; => 报错, `show' 没有被导出，不存在
  478. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  479. ;; 8\. 类和对象
  480. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  482. ;; 创建一个 fish% 类(%是给类绑定用的)
  483. (define fish%
  484.   (class object%
  485.     (init size) ; 初始化的参数
  486.     (super-new) ; 父类的初始化
  487.     ;; 域
  488.     (define current-size size)
  489.     ;; 公共方法
  490.     (define/public (get-size)
  491.       current-size)
  492.     (define/public (grow amt)
  493.       (set! current-size (+ amt current-size)))
  494.     (define/public (eat other-fish)
  495.       (grow (send other-fish get-size)))))
  497. ;; 创建一个 fish% 类的示例
  498. (define charlie
  499.   (new fish% [size 10]))
  501. ;; 使用 `send' 调用一个对象的方法
  502. (send charlie get-size) ; => 10
  503. (send charlie grow 6)
  504. (send charlie get-size) ; => 16
  506. ;; `fish%' 是一个普通的值，我们可以用它来混入
  507. (define (add-color c%)
  508.   (class c%
  509.     (init color)
  510.     (super-new)
  511.     (define my-color color)
  512.     (define/public (get-color) my-color)))
  513. (define colored-fish% (add-color fish%))
  514. (define charlie2 (new colored-fish% [size 10] [color 'red]))
  515. (send charlie2 get-color)
  516. ;; 或者，不带名字
  517. (send (new (add-color fish%) [size 10] [color 'red]) get-color)
  519. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  520. ;; 9\. 宏
  521. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  523. ;; 宏让你扩展这门语言的语法
  525. ;; 让我们定义一个while循环
  526. (define-syntax-rule (while condition body ...)
  527.   (let loop ()
  528.     (when condition
  529.       body ...
  530.       (loop))))
  532. (let ([i 0])
  533.   (while (< i  10)
  534.     (displayln i)
  535.     (set! i (add1 i))))
  537. ;; 宏是安全的，你不能修改现有的变量
  538. (define-syntax-rule (swap! x y) ; !表示会修改
  539.   (let ([tmp x])
  540.     (set! x y)
  541.     (set! y tmp)))
  543. (define tmp 2)
  544. (define other 3)
  545. (swap! tmp other)
  546. (printf "tmp = ~a; other = ~a\n" tmp other)
  547. ;; 变量 `tmp` 被重命名为 `tmp_1`
  548. ;; 避免名字冲突
  549. ;; (let ([tmp_1 tmp])
  550. ;;   (set! tmp other)
  551. ;;   (set! other tmp_1))
  553. ;; 但它们仍然会导致错误代码，比如:
  554. (define-syntax-rule (bad-while condition body ...)
  555.   (when condition
  556.     body ...
  557.     (bad-while condition body ...)))
  558. ;; 这个宏会挂掉，它产生了一个无限循环，如果你试图去使用它
  559. ;; 编译器会进入死循环
  561. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  562. ;; 10\. 契约
  563. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  565. ;; 契约限制变量从模块中导入
  567. (module bank-account racket
  568.   (provide (contract-out
  569.             [deposit (-> positive? any)] ; 数量一直是正值
  570.             [balance (-> positive?)]))
  572.   (define amount 0)
  573.   (define (deposit a) (set! amount (+ amount a)))
  574.   (define (balance) amount)
  575.   )
  577. (require 'bank-account)
  578. (deposit 5)
  580. (balance) ; => 5
  582. ;; 客户端尝试存储一个负值时会出错
  583. ;; (deposit -5) ; => deposit: contract violation
  584. ;; expected: positive?
  585. ;; given: -5
  586. ;; more details....

进一步阅读

想知道更多吗？ 尝试 Getting Started with Racket

还没有评论.