{"id":23552571,"url":"https://github.com/xlisp/fp-book","last_synced_at":"2025-04-28T14:02:18.735Z","repository":{"id":127744282,"uuid":"47856414","full_name":"xlisp/fp-book","owner":"xlisp","description":"对比学习Racket/Clojure/EmacsLisp/CommonLisp, 以及基本算法","archived":false,"fork":false,"pushed_at":"2020-04-21T05:27:52.000Z","size":78,"stargazers_count":7,"open_issues_count":0,"forks_count":4,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-03-30T10:11:29.316Z","etag":null,"topics":["algorithms","clojure","common-lisp","emacs-lisp","functional-programming","racket"],"latest_commit_sha":null,"homepage":"","language":"Scheme","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/xlisp.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2015-12-11T23:40:10.000Z","updated_at":"2024-03-20T03:13:39.000Z","dependencies_parsed_at":null,"dependency_job_id":"fed5541e-dc55-4664-b331-d98faab0e07d","html_url":"https://github.com/xlisp/fp-book","commit_stats":null,"previous_names":["xlisp/fp-book"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/xlisp%2Ffp-book","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/xlisp%2Ffp-book/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/xlisp%2Ffp-book/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/xlisp%2Ffp-book/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/xlisp","download_url":"https://codeload.github.com/xlisp/fp-book/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":251326793,"owners_count":21571632,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algorithms","clojure","common-lisp","emacs-lisp","functional-programming","racket"],"created_at":"2024-12-26T11:11:33.715Z","updated_at":"2025-04-28T14:02:18.604Z","avatar_url":"https://github.com/xlisp.png","language":"Scheme","funding_links":[],"categories":[],"sub_categories":[],"readme":"# 《 Functional Racket/Clojure/EmacsLisp/CommonLisp 》\n\n## 对比学习Racket/Clojure/EmacsLisp/CommonLisp, 以及基本算法\n\n*Declaration: Content forked form the http://hyperpolyglot.org/lisp, only for compare study lisp and record learning experience*\n\n## Show Version\n\n```common-lisp\n;; common-lisp\n$ sbcl --version\n```\n```racket\n;; racket\n$ racket --version\n```\n```clojure\n;; clojure\ndisplayed by repl on startup\n```\n```emacs-lisp\n;; emacs-lisp\n$ emacs --version\n```\n\n\n## Compiler\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n$ raco make module.rkt\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nM-x byte-compile-file\n```\n\n\n## Standalone Executable\n\n```common-lisp\n;; common-lisp\n(sb-ext:save-lisp-and-die  \"executable\"  :executable t  :toplevel 'function)\n```\n```racket\n;; racket\n$ mzc —exe executable file\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Interpreter\n\n```common-lisp\n;; common-lisp\n$ sbcl --script foo.lisp\n```\n```racket\n;; racket\n$ racket -r foo.racket\n```\n```clojure\n;; clojure\nspecify full path to clojure jar:\njava -cp clojure.jar clojure.main foo.clj\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Shebang\n```common-lisp\n\n;; common-lisp\n#!/usr/bin/env sbcl --script\n```\n```racket\n;; racket\n#!/usr/bin/env racket --script\n```\n```clojure\n;; clojure\nspecify full path to clojure jar:\n#!/usr/bin/env java -jar clojure.jar\n```\n```emacs-lisp\n;; emacs-lisp\n#!/usr/bin/env emacs --script\n```\n\n\n## Repl\n```common-lisp\n\n;; common-lisp\n$ sbcl\n```\n```racket\n;; racket\n$ racket\n```\n```clojure\n;; clojure\n$ java -jar /PATH/TO/clojure.jar\n```\n```emacs-lisp\n;; emacs-lisp\nM-x ielm\n```\n\n\n## Command Line Program\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n$ racket -e '(+ 1 1)'\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Word Separator\n\n```common-lisp\n;; common-lisp\nwhitespace\n```\n```racket\n;; racket\nwhitespace\n```\n```clojure\n;; clojure\nwhitespace and commas\n```\n```emacs-lisp\n;; emacs-lisp\nwhitespace\n```\n\n\n## End Of Line Comment\n\n```common-lisp\n;; common-lisp\n(+ 1 1) ; adding\n```\n```racket\n;; racket\n(+ 1 1) ; adding\n```\n```clojure\n;; clojure\n(+ 1 1) ; adding\n```\n```emacs-lisp\n;; emacs-lisp\n(+ 1 1) ; adding\n```\n\n\n## Multiple Line Comment\n\n```common-lisp\n;; common-lisp 和 emacs-lisp的区别, clisp 可以行中间注释, elisp不可以\n(+ 1 #| adding |# 1) ;;=\u003e 2\n```\n```racket\n;; racket\n(+ 1 #| adding |# 1)\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Identifier\n\n```common-lisp\n;; common-lisp\ncase insensitive, cannot start with digitexcluded characters:\nSP ( ) \" , ' ` : ; # | \\reserved for user macros:\n? ! [ ] { }\n```\n```racket\n;; racket\ncase sensitive, cannot start with digitexcluded characters:\nSP ( ) [ ] { } \" , ' ` ; # | \\\n```\n```clojure\n;; clojure\ncase sensitive, cannot start with digitpermitted characters:\nA-Z a-z 0-9 * + ! - _ ?these have special meaning or are reserved:\n/ . :\n```\n```emacs-lisp\n;; emacs-lisp\ncase sensitive, cannot start with digitexcluded characters:\nSP ( ) \" , ' ` ; # | \\ _ [ ]\n```\n\n\n## Quoted Identifierand Escaped Identifier\n\n```common-lisp\n;; common-lisp\n(setq |white space symbol| 3) ;;=\u003e 3\n(setq white\\ space\\ symbol 3) ;;\n```\n```racket\n;; racket\n(define |white space symbol| 3)\n(define white\\ space\\ symbol 3)\n```\n```clojure\n;; clojure\nnonenone\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n(setq white\\ space\\ symbol 3)\n```\n\n\n## Local Variable\n\n```common-lisp\n;; common-lisp\n; parallel assignment:\n(let ((x 3) (y 4)) (+ x y)) ; sequential assignment: 7\n(let* ((x 3) (y (* x x))) (+ x y)) ;;=\u003e 12\n```\n```racket\n;; racket\n; parallel assignment:\n(let ((x 3) (y 4))  (+ x y)); sequential assignment:\n(let* ((x 3) (y (* x x)))  (+ x y))\n```\n```clojure\n;; clojure\n(let [x 3 y 4]  (+ x y))\n(let [[x y] [3 4]]  (+ x y))\n(let [x 3 y (* x x)]  (+ x y))\n```\n```emacs-lisp\n;; emacs-lisp\n; parallel assignment:\n(lexical-let ((x 3) (y 4))  (+ x y)) ;; 7\n(lexical-let* ((x 3) (y (* x x)))  (+ x y)) ;; 12\n```\n\n\n## Global Variable\n\n```common-lisp\n;; common-lisp\n(defparameter *x* 3) ;; doesn't change x if already set, *X* =\u003e 3 , (setq *X* 312312) =\u003e *X* 还是312312?\n(defvar *x* 3)\n```\n```racket\n;; racket\n(define x 3); y is not global:\n(define (double z)  (define y 2)  (* y z))\n```\n```clojure\n;; clojure\n(def x 3)\n```\n```emacs-lisp\n;; emacs-lisp 即使是一个列表，也是可以作为变量名的\n(set 'x 3)\n(setq x 3)\n```\n\n\n## Remove Variable\n\n```common-lisp\n;; common-lisp\n(makunbound 'x) ;; (makunbound '*X*) 去除变量值\n```\n```racket\n;; racket\n(namespace-undefine-variable! 'x)\n```\n```clojure\n;; clojure\n(ns-unmap *ns* 'x)\n```\n```emacs-lisp\n;; emacs-lisp 这里是移除变量的操作\n(makunbound 'x)\n```\n\n\n## Null\n```common-lisp\n\n;; common-lisp\nnil '()\n```\n```racket\n;; racket\nnull '()\n```\n```clojure\n;; clojure\n; same value as null in Java:\nnil\n```\n```emacs-lisp\n;; emacs-lisp\nnil '()\n```\n\n\n## Null Test\n\n```common-lisp\n;; common-lisp\n(null x) ;; x 为nil时, 结果为T. 否则为NIL\n```\n```racket\n;; racket\n(null? x)\n```\n```clojure\n;; clojure\n(nil? x)\n```\n```emacs-lisp\n;; emacs-lisp\n(null x)\n```\n\n\n## Identifier As Value\n\n```common-lisp\n;; common-lisp\n'x\n(quote x) ;; (= (quote x) 'X) ? ==\u003e = 只能是数字\n```\n```racket\n;; racket\n'x\n(quote x)\n```\n```clojure\n;; clojure\n'x\n(quote x)\n```\n```emacs-lisp\n;; emacs-lisp\n'x\n(quote x)\n```\n\n\n## Identifier Test\n\n```common-lisp\n;; common-lisp\n(symbolp 'x) ;; T 判断是否为symbol类型\n```\n```racket\n;; racket\n(symbol? 'x)\n```\n```clojure\n;; clojure\n(symbol? 'x)\n```\n```emacs-lisp\n;; emacs-lisp p判断类型通常有着一个p\n(symbolp 'x)\n```\n\n\n## Identifier Equality Test\n\n```common-lisp\n;; common-lisp\n(eq 'x 'x) ;; =\u003e (eq (quote x) 'x) =\u003e T, eq通常用于测试是否相等的表达式,=测试是否相等的数字\n```\n```racket\n;; racket\n(eq? 'x 'x)\n```\n```clojure\n;; clojure\n(= 'x 'x)\n```\n```emacs-lisp\n;; emacs-lisp\n(eq 'x 'x)\n```\n\n\n## Non Referential Identifier\n\n```common-lisp\n;; common-lisp\n:foo ;;=\u003e :FOO\n```\n```racket\n;; racket\n#:foo\n```\n```clojure\n;; clojure\n:foo\n```\n```emacs-lisp\n;; emacs-lisp\n:foo\n```\n\n\n## Identifier Attributesset Get Remove\n\n```common-lisp\n;; common-lisp\n(set 'x 13)\n(setf (get 'x :desc) #|这里测试是NIL|# \"unlucky\") ;;=\u003e 结果输出unlucky, (get 'x :desc)变成了unlucky, setf 给:desc属性赋值为unlucky\n(get 'x :desc)\n(remprop 'x :desc) ;;=\u003e (:DESC \"unlucky\"), :desc属性去除后为零了\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n; value must be instance of clojure.lang.IObj:\n(def x (with-meta [13] {:desc \"unlucky\"}))\n(get (meta x) :desc); none\n```\n```emacs-lisp\n;; emacs-lisp 元数据的操作，移除和获取\n(set 'x 13)\n;; get is nil, setf is string\n(setf (get 'x :desc) \"unlucky\")\n(get 'x :desc) ;; string\n(remprop 'x :desc) ;; 移除元数据就没有字符串了\n```\n\n\n## True And False\n\n```common-lisp\n;; common-lisp\nt nil ;;=\u003e T, NIL\n```\n```racket\n;; racket\n#t #f\ntrue false\n```\n```clojure\n;; clojure\ntrue false\n```\n```emacs-lisp\n;; emacs-lisp\nt nil\n```\n\n\n## Falsehoods\n\n```common-lisp\n;; common-lisp\nnil ()\n```\n```racket\n;; racket\n#f false\n```\n```clojure\n;; clojure\nfalse nil\n```\n```emacs-lisp\n;; emacs-lisp\nnil ()\n```\n\n\n## Logical Operators\n\n```common-lisp\n;; common-lisp\n(or (not t) #|输出NIL|# (and t nil) #|输出NIL|#) ;;=\u003e NIL\n```\n```racket\n;; racket\n(or (not #t) (and #t #f))\n```\n```clojure\n;; clojure\n(or (not true) (and true false))\n```\n```emacs-lisp\n;; emacs-lisp\n(or (not t) (and t nil))\n```\n\n\n## Relational Operators\n\n```common-lisp\n;; common-lisp\n= /= \u003c \u003e \u003c= \u003e=\n```\n```racket\n;; racket\n= none \u003c \u003e \u003c= \u003e=\n```\n```clojure\n;; clojure\n= not= \u003c \u003e \u003c= \u003e=\n```\n```emacs-lisp\n;; emacs-lisp\n= /= \u003c \u003e \u003c= \u003e=\n```\n\n\n## Min And Max\n\n```common-lisp\n;; common-lisp\n(min 1 2 3) ;;=\u003e 1\n(max 1 2 3) ;;=\u003e 3\n```\n```racket\n;; racket\n(min 1 2 3)\n(max 1 2 3)\n```\n```clojure\n;; clojure\n(min 1 2 3)\n(max 1 2 3)\n```\n```emacs-lisp\n;; emacs-lisp\n(min 1 2 3)\n(max 1 2 3)\n```\n\n\n## Numeric Predicates\n\n```common-lisp\n;; common-lisp 数值和浮点型判断\nnumberp integerp\nrationalp floatp\nrealp complexp\n```\n```racket\n;; racket\nnumber? integer?\nrational? inexact?\nreal? complex?\n```\n```clojure\n;; clojure\nnumber? integer?\nrational? float?none none\n```\n```emacs-lisp\n;; emacs-lisp 基本上和clisp设计是一样的，类型的判断p\nnumberp integerpnone floatpnone none\n```\n\n\n## Arithmetic Operators\n\n```common-lisp\n;; common-lisp\n+ - * / mod\n```\n```racket\n;; racket\n+ - * / modulo\n```\n```clojure\n;; clojure\n+ - * / mod\n```\n```emacs-lisp\n;; emacs-lisp\n+ - * / %\n```\n\n\n## Integer Divisionand Remainder\n\n```common-lisp\n;; common-lisp\n(truncate 7 3) ;;=\u003e 2, 1\n(rem 7 3) ;;=\u003e 1\n```\n```racket\n;; racket\n(quotient 7 3)\n(remainder 7 3)\n```\n```clojure\n;; clojure\n(quot 7 3)\n(rem 7 3)\n```\n```emacs-lisp\n;; emacs-lisp\n(/ 7 3)\n(% 7 3)\n```\n\n\n## Integer Division By Zero\n\n```common-lisp\n;; common-lisp\ndivision-by-zero error\n```\n```racket\n;; racket\ndivision by zero error\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\narith-error\n```\n\n\n## Float Division\n\n```common-lisp\n;; common-lisp\nrational:\n(/ 7 3) ;;=\u003e float: =\u003e 7/3 (2.3333333) ;;;=\u003e (= (/ 7 3) 2) =\u003e NIL\n(/ 7 (* 3 1.0)) ;; =\u003e  2.3333333\n```\n```racket\n;; racket\nrational:\n(/ 7 3)float:\n(/ 7 (float 3))\n```\n```clojure\n;; clojure\nrational:\n(/ 7 3)float:\n(/ 7 (* 3 1.0))\n```\n```emacs-lisp\n;; emacs-lisp\ninteger quotient:\n(/ 7 3)float:\n(/ 7 (* 3 1.0))\n```\n\n\n## Float Division By Zero\n\n```common-lisp\n;; common-lisp\ndivision-by-zero error\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n-1.0e+INF, -0.0e+NaN, or 1.0e+INF\n```\n\n\n## Power\n```common-lisp\n\n;; common-lisp\n(expt 2 32) ;;=\u003e =\u003e 4294967296 (33 bits, #x100000000, #o40000000000, #b100000000000000000000000000000000)\n```\n```racket\n;; racket\n(expt 2 32)\n```\n```clojure\n;; clojure\nreturns float:\n(Math/pow 2 32)\n```\n```emacs-lisp\n;; emacs-lisp\n(expt 2 32) ;; 0, ?\n```\n\n\n## Sqrt\n```common-lisp\n\n;; common-lisp\n(sqrt 2) ;;=\u003e =\u003e 1.4142135\n```\n```racket\n;; racket\n(sqrt 2)\n```\n```clojure\n;; clojure\n(Math/sqrt 2)\n```\n```emacs-lisp\n;; emacs-lisp\n(sqrt 2)\n```\n\n\n## Sqrt  1\n```common-lisp\n\n;; common-lisp\n#c(0.0 1.0)\n```\n```racket\n;; racket\n0+1i\n```\n```clojure\n;; clojure\n(Math/sqrt -1): NaN\n```\n```emacs-lisp\n;; emacs-lisp\n-0.0e+NaN\n```\n\n\n## Transcendental Functions\n\n```common-lisp\n;; common-lisp\nexp log sin cos tan asin acos atan atan ;;=\u003e 周期函数,声波的机器学习,傅里叶分析\n```\n```racket\n;; racket\nexp log sin cos tan asin acos atan atan\n```\n```clojure\n;; clojure\nMath/exp Math/log Math/sin Math/cos Math/tan Math/asin Math/acos Math/atan Math/atan2\n```\n```emacs-lisp\n;; emacs-lisp 三角函数的，周期的建模\nexp log sin cos tan asin acos atan atan\n```\n\n\n## Float Truncation\n\n```common-lisp\n;; common-lisp\nreturn two values, first is integer:\ntruncate round ceiling floor\n```\n```racket\n;; racket\nreturn floats:\ntruncate round ceiling floor\n```\n```clojure\n;; clojure\nreturn integers:\nint Math/roundreturn floats:\nMath/ceil Math/floor\n```\n```emacs-lisp\n;; emacs-lisp\ntruncate round ceiling floor\nfround fceiling ffloortruncate returns integer\n```\n\n\n## Absolute Valueand Signum\n\n```common-lisp\n;; common-lisp\nabs signum\n```\n```racket\n;; racket\nabsracket: sgn\n```\n```clojure\n;; clojure\nMath/abs Math/signum\n```\n```emacs-lisp\n;; emacs-lisp\nabs signum\n```\n\n\n## Integer Overflow\n\n```common-lisp\n;; common-lisp\nnone; arbitrary-precision integers\n```\n```racket\n;; racket\nnone; arbitrary-precision integers\n```\n```clojure\n;; clojure\nclojure.lang.Numbers.throwIntOverflow exception\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Float Overflow\n\n```common-lisp\n;; common-lisp\nfloating-point-overflow error\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\nnot literals:\n-Infity NaN Infinity\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Rational Construction\n\n```common-lisp\n;; common-lisp\n(/ 3 7); literal:\n3/7\n```\n```racket\n;; racket\n(/ 3 7); literal:\n3/7; also rational:\n2.718\n(exp 1)\n```\n```clojure\n;; clojure\n(/ 3 7); literal:\n3/7\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Rational Decomposition\n\n```common-lisp\n;; common-lisp\n(numerator 3/7) ;;=\u003e 3\n(denominator 3/7) ;;=\u003e 7\n```\n```racket\n;; racket\n(numerator 3/7)\n(denominator 3/7)\n```\n```clojure\n;; clojure\n(numerator 3/7)\n(denominator 3/7)\n```\n```emacs-lisp\n;; emacs-lisp\nnone none\n```\n\n\n## Complex Construction\n\n```common-lisp\n;; common-lisp\n#c(1 2) ;;=\u003e ??\n```\n```racket\n;; racket\n1+2i\n(+ 1 +2i)\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Complex Decomposition\n\n```common-lisp\n;; common-lisp\n(realpart #c(1 2)) ;; =\u003e 1\n(imagpart #c(1 2)) ;;=\u003e 2\n(phase #c(1 2)) ;;=\u003e 1.1071488\n(abs #c(1 2)) ;;=\u003e 2.236068\n(conjugate #c(1 2)) ;;=\u003e #C(1 -2)\n```\n```racket\n;; racket\n(real-part 1+2i)\n(imag-part 1+2i)\n(angle 1+2i)\n(magnitude 1+2i)\n(conjugate 1+2i)\n```\n```clojure\n;; clojure\nnonenone\n```\n```emacs-lisp\n;; emacs-lisp\nnone none\n```\n\n\n## Random Numberuniform Integer Uniform Float Normal Float\n\n```common-lisp\n;; common-lisp\n(random 100) ;; =\u003e 92\n(random 1.0) ;; =\u003e 0.6700171\n```\n```racket\n;; racket\n(random 100)\n(random)none\n```\n```clojure\n;; clojure\n(def rnd (java.util.Random.))\n(.nextInt rnd 100)\n(.nextFloat rnd)\n(.nextGaussian rnd)\n```\n```emacs-lisp\n;; emacs-lisp\n(random 100)\n```\n\n\n## Random Seed\n\n```common-lisp\n;; common-lisp\n(setq *random-state*  (sb-ext:seed-random-state 17))\n```\n```racket\n;; racket\n(random-seed 17)\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Bit Operators\n\n```common-lisp\n;; common-lisp 位运算\nash left shift when 2nd argument positive logand logior logxor lognot\n```\n```racket\n;; racket\narithmetic-shift left shift when 2nd argument positive bitwise-and bitwise-ior bitwise-xor bitwise-not\n```\n```clojure\n;; clojure\nbit-shift-left bit-shift-right bit-and bit-or bit-xor bit-not\n```\n```emacs-lisp\n;; emacs-lisp 位的操作\nlsh left shift when 2nd argument positive logand logior logxor lognot\n```\n\n\n## Binary Octal And Hex Literals\n\n```common-lisp\n;; common-lisp\n#b101010 ;; =\u003e 42 (6 bits, #x2A, #o52, #b101010)\n#o52 ;;=\u003e 42 (6 bits, #x2A, #o52, #b101010)\n#x2a ;;=\u003e 42 (6 bits, #x2A, #o52, #b101010)\n```\n```racket\n;; racket\n#b101010\n#o52\n#x2a\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Radix\n```common-lisp\n\n;; common-lisp\n(format nil \"~7r\" 42) ;;=\u003e \"60\"\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## String Test\n\n```common-lisp\n;; common-lisp\n(stringp \"foo\") ;;=\u003e T, (symbolp :abc)=\u003e T\n```\n```racket\n;; racket\n(string? \"foo\")\n```\n```clojure\n;; clojure\n(string? \"foo\")\n```\n```emacs-lisp\n;; emacs-lisp p的类型判断\n(stringp \"foo\")\n```\n\n\n## String Literal\n\n```common-lisp\n;; common-lisp\n\"foo bar\"\n```\n```racket\n;; racket\n\"foo bar\"\n```\n```clojure\n;; clojure\n\"foo bar\"\n```\n```emacs-lisp\n;; emacs-lisp\n\"foo bar\"\n```\n\n\n## Newline In Literal\n\n```common-lisp\n;; common-lisp\nyes\n```\n```racket\n;; racket\nyes\n```\n```clojure\n;; clojure\nyes\n```\n```emacs-lisp\n;; emacs-lisp\nyes\n```\n\n\n## Literal Escapes\n\n```common-lisp\n;; common-lisp\n\\\" \\\\ ;; 特殊字符反引号\n```\n```racket\n;; racket\n\\t \\n \\r \\\" \\\\ \\ooo \\uhhhh\n```\n```clojure\n;; clojure\n\\b \\t \\n \\f \\r \\\" \\\\ \\ooo \\uhhhh\n```\n```emacs-lisp\n;; emacs-lisp 特殊字符如换行\n\\b \\t \\n \\f \\r \\\" \\\\ \\ooo \\uhhhh \\xh - \\xhhhhhh \\C-x \\M-x\n```\n\n\n## Constructor\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(string #\\f #\\o #\\o)\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp 列表转为字符串\n(string ?f ?o ?o) ;; foo\n```\n\n\n## Format String\n\n```common-lisp\n;; common-lisp \"~,2f\" 是浮点型的format\n(format nil \"~a: ~a ~,2f\" \"Foo\" 7 13.457) ;;=\u003e \"Foo: 7 13.46\"\n```\n```racket\n;; racket\n(format \"~a ~a ~a\" \"Foo\" 7 13.457)\n```\n```clojure\n;; clojure\n(String/format \"%s: %d %.2f\"  (to-array [\"Foo\" 7 13.457]))\n```\n```emacs-lisp\n;; emacs-lisp\n(format \"%s: %d %.2f\" \"Foo\" 7 13.457)\n```\n\n\n## Format Specifiers\n\n```common-lisp\n;; common-lisp 各种类型的Format填充方法\n~a    any type, human readable\n~s    any time, read parseable\n~%    newline\n~~    tilde\n~c    character\n~,5f  5 digits right of decimal mark\n~d    decimal\n~x    hex\n~o    octal\n~b    binary\n```\n```racket\n;; racket\n~a    any type, human readable\n~s    any time, read parseable\n~%    newline\n~~    tilde\n~c    character\n~d    decimal\n~x    hex\n~o    octal\n~b    binary\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Compare Strings\n\n```common-lisp\n;; common-lisp\n(string= \"foo\" \"bar\") ;;=\u003e NIL ,字符串比较是否相同\n(string\u003c \"foo\" \"bar\") ;;=\u003e NIL\n```\n```racket\n;; racket\n(string=? \"foo\" \"bar\")\n(string\u003c? \"foo\" \"bar\")\n```\n```clojure\n;; clojure\n(.equals \"foo\" \"bar\")\n(.compareTo \"foo\" \"bar\")\n```\n```emacs-lisp\n;; emacs-lisp 字母的先后排序大小\n(string= \"foo\" \"bar\")\n(string\u003c \"foo\" \"bar\")\n```\n\n\n## Concatenate\n\n```common-lisp\n;; common-lisp 字符串连接\n(concatenate 'string \"foo \" \"bar \" \"bar\") ;;=\u003e \"foo bar bar\" ,, (concatenate 'string 1 2 3) 是报错的\n```\n```racket\n;; racket\n(string-append \"foo \" \"bar \" \"baz\")\n```\n```clojure\n;; clojure\n(str \"foo \" \"bar \" \"baz\")\n```\n```emacs-lisp\n;; emacs-lisp 字符串连接\n(concat \"foo \" \"bar \" \"baz\")\n```\n\n\n## Replicate\n\n```common-lisp\n;; common-lisp\n(make-string 3 :initial-element #\\f) ;;=\u003e \"fff\"\n```\n```racket\n;; racket\n(make-string 3 #\\f)\n```\n```clojure\n;; clojure\n(String. (into-array  (. Character TYPE)  (repeat 3 \\f)))\n```\n```emacs-lisp\n;; emacs-lisp 字符串创建\n(make-string 3 ?f) ;; fff\n```\n\n\n## Translate Case\n\n```common-lisp\n;; common-lisp\n(string-downcase \"FOO\") ;;=\u003e \"foo\"\n(string-upcase \"foo\")\n```\n```racket\n;; racket\n(string-downcase \"FOO\")\n(string-upcase \"foo\")\n```\n```clojure\n;; clojure\n(.toLowerCase \"FOO\")\n```\n```emacs-lisp\n;; emacs-lisp\n(downcase \"FOO\")\n(upcase \"foo\")\n```\n\n\n## Capitalize\n\n```common-lisp\n;; common-lisp\n; \"Foo Bar\":\n(string-capitalize \"foo bar\") ;;=\u003e \"Foo Bar\", 驼峰\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n; \"Foo Bar\": 类似rails 命名\n(capitalize \"foo\")\n```\n\n\n## Trim\n```common-lisp\n\n;; common-lisp\n(string-trim '(#\\space #\\tab #\\newline) \" foo \") ;;=\u003e \"foo\" 去除一些字符串\n```\n```racket\n;; racket\n(require srfi/13/string)\n(string-trim-both \" foo \")\n```\n```clojure\n;; clojure\n(.trim \" foo \")\n```\n```emacs-lisp\n;; emacs-lisp\nnone; see notes for an implementation\n```\n\n\n## Padon Right On Left\n\n```common-lisp\n;; common-lisp\n(format nil \"~10a\" \"foo\") ;; =\u003e \"foo       \"\n(format nil \"~10@a\" \"foo\") ;;=\u003e \"       foo\"\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Number To String\n\n```common-lisp\n;; common-lisp\n(concatenate 'string \"value: \" (princ-to-string 8)) ;;=\u003e \"value: 8\"\n```\n```racket\n;; racket\n(string-append  \"value: \"  (number-\u003estring 8))\n```\n```clojure\n;; clojure\n(str \"Value: \" 8)\n```\n```emacs-lisp\n;; emacs-lisp 这里要注意转换为字符串才可以拼接\n(concat  \"value: \"  (number-to-string 8))\n```\n\n\n## String To Number\n\n```common-lisp\n;; common-lisp\n(+ 7 (parse-integer \"12\")) ;;=\u003e 19 (5 bits, #x13, #o23, #b10011)\n(+ 73.9 (read-from-string \".037\") #|输出=\u003e 0.037, 4|#) ;;=\u003e 73.937004\n```\n```racket\n;; racket\n(+ 7 (string-\u003enumber \"12\"))\n(+ 73.9 (string-\u003enumber \".037\"))\n```\n```clojure\n;; clojure\n(+ 7 (Integer/parseInt \"12\"))\n(+ 73.9 (Float/parseFloat \".037\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(+ 7 (string-to-number \"12\"))\n(+ 73.9 (string-to-number \".037\"))\n```\n\n\n## Split\n```common-lisp\n\n;; common-lisp\n(cl-ppcre:split \"[ \\t\\n]+\" \"foo bar baz\") ;; 必须要安装包=\u003e Package CL-PPCRE does not exist.\n```\n```racket\n;; racket\n(regexp-split #rx\"[ \\n\\t]+\"  \"foo bar baz\")\n```\n```clojure\n;; clojure\n(seq  (.split \"foo bar baz\"    \"[ \\t\\n]+\"))\n```\n```emacs-lisp\n;; emacs-lisp 这里可以按照正则表达式来切割\n(split-string \"foo bar baz\")\n```\n\n\n## String Join\n\n```common-lisp\n;; common-lisp reduce累加的字符串\n(reduce (lambda (m o) (concatenate 'string m \" \" o)) '(\"foo\" \"bar\" \"baz\")) ;;=\u003e \"foo bar baz\"\n```\n```racket\n;; racket\n(string-join  '(\"foo\" \"bar\" \"baz\")  \" \")\n```\n```clojure\n;; clojure\n(reduce #(str %1 \" \" %2)  '(\"foo\" \"bar\" \"baz\"))\n```\n```emacs-lisp\n;; emacs-lisp ruby's inject 求字符串的积分\n(reduce (lambda (m o) (concat m \"_\" o)) '(\"foo\" \"bar\" \"baz\")) ; \"foo_bar_baz\"\n```\n\n\n## Length\n```common-lisp\n\n;; common-lisp\n(length \"foo\") ;;=\u003e 3 (2 bits, #x3, #o3, #b11)\n```\n```racket\n;; racket\n(string-length \"foo\")\n```\n```clojure\n;; clojure\n(.length \"foo\")\n```\n```emacs-lisp\n;; emacs-lisp\n(length \"foo\")\n```\n\n\n## Index Of Substring\n\n```common-lisp\n;; common-lisp\n(search \"bar\" \"foo bar\") ;;=\u003e 4 (3 bits, #x4, #o4, #b100)\n```\n```racket\n;; racket\nracket:\n(require srfi/13/string)\n(string-contains \"foo bar\" \"bar\")\n```\n```clojure\n;; clojure\n(.indexOf \"foo bar\" \"bar\")\n```\n```emacs-lisp\n;; emacs-lisp 搜索得到一个数字，说明是存在的，并且知道它所在的位置\n(search \"bar\" \"foo bar\") ; 4\n```\n\n\n## Extract Substring\n\n```common-lisp\n;; common-lisp\n(subseq \"foo bar\" 4 7)\n```\n```racket\n;; racket\n(substring \"foo bar\" 4 7)\n```\n```clojure\n;; clojure\n(.substring \"foo bar\" 4 7)\n```\n```emacs-lisp\n;; emacs-lisp 根据位置来拿到字符串\n(substring \"foo bar\" 4 7)\n```\n\n\n## Character Literal\n\n```common-lisp\n;; common-lisp\n#\\a #\\space #\\newline #\\backspace #\\tab #\\linefeed #\\page #\\return #\\rubout\n```\n```racket\n;; racket\n#\\a #\\space #\\newline #\\backspace #\\tab #\\linefeed #\\page #\\return #\\nul #\\vtab #\\alarm #\\esc #\\deletenot in racket: #\\alarm #\\esc #\\delete\n```\n```clojure\n;; clojure\n\\a \\newline \\space \\backspace \\tab ? \\formfeed \\return ?\n```\n```emacs-lisp\n;; emacs-lisp 一些特殊的字符串\n?a ?\\b ?\\t ?\\n ?\\f ?\\r ?\\\" ?\\\\ ?\\ooo ?\\uhhhh ?\\xh - ?\\xhhhhhh ?\\C-x ?\\M-x\n```\n\n\n## Test Characters\n\n```common-lisp\n;; common-lisp\n(characterp #\\x)\n(alpha-char-p #\\x)\n(alphanumericp #\\x)\n(digit-char-p #\\7)\n(lower-case-p #\\x)\n(upper-case-p #\\X)\n```\n```racket\n;; racket\n(char? #\\x)\n```\n```clojure\n;; clojure\n(char? \\x)\n```\n```emacs-lisp\n;; emacs-lisp 这里的问号是代表什么东西呢, char\n(characterp ?x) ; t\n```\n\n\n## Chr And Ord\n\n```common-lisp\n;; common-lisp\n(code-char 97)\n(char-code #\\a)\n```\n```racket\n;; racket\n(integer-\u003echar 97)\n(char-\u003einteger #\\a)\n```\n```clojure\n;; clojure\n(char 97)\n(int \\a)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## To Array Of Characters\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n; list:\n(string-\u003elist \"foo\")\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Character Lookup\n\n```common-lisp\n;; common-lisp\n(char \"foo\" 0)\n```\n```racket\n;; racket\n(string-ref \"foo\" 0)\n```\n```clojure\n;; clojure\n(.charAt \"foo\" 0)\n```\n```emacs-lisp\n;; emacs-lisp 这里的应该是不同于环境查找变量\n(aref \"foo\" 2) ; 0 =\u003e 102, 2 =\u003e 111\n```\n\n\n## Literal\n```common-lisp\n\n;; common-lisp\nuse a string:\n\"\\\\b\\\\d{5}\\\\b\"\n```\n```racket\n;; racket\nposix extended:\n#rx\"^[0-9][0-9][0-9][0-9][0-9]$\"\n(regexp \"^[0-9][0-9][0-9][0-9][0-9]$\")perl style:\n#px\"\\\\b\\\\d{5}\\\\b\"\n(pregexp \"\\\\b\\\\d{5}\\\\b\")\n```\n```clojure\n;; clojure\n#\"\\b\\d{5}\\b\"\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Character Class Abbrevations\n\n```common-lisp\n;; common-lisp\n. \\d \\D \\s \\S \\w \\W\n```\n```racket\n;; racket\nregexp:\n.pregexp:\n. \\d \\D \\s \\S \\w \\W\n```\n```clojure\n;; clojure\n. \\d \\D \\s \\S \\w \\W\n```\n```emacs-lisp\n;; emacs-lisp\n. \\w \\W \\ca \\cl \\cg \\Ca \\Cl \\Cg \\sx\\ca \\cl and \\cg match ASCII, Latin, and Greek characters.Character classes of the form \\sx depend on the current syntax table.\n```\n\n\n## Anchors\n```common-lisp\n\n;; common-lisp\n^ $ \\b \\B\n```\n```racket\n;; racket\nregexp:\n^ $pregexp:\n^ $ \\b \\B\n```\n```clojure\n;; clojure\n^ $ \\A \\b \\B \\G \\z \\Z\n```\n```emacs-lisp\n;; emacs-lisp\n^ $ \\b \\B\n```\n\n\n## Match Test\n\n```common-lisp\n;; common-lisp\n(ql:quickload \"cl-ppcre\")\n(if (cl-ppcre:all-matches \"1999\" s)  (format t \"party!\"))\n```\n```racket\n;; racket\n(regexp-match #rx\"bar\" \"foo bar\")\n```\n```clojure\n;; clojure\n(re-find #\"bar\" \"foo bar\")\n```\n```emacs-lisp\n;; emacs-lisp 这里就像红宝石的 =~\n(string-match \"bar\" \"foo bar\")\n```\n\n\n## Case Insensitive Match Test\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(regexp-match #px\"(?i:lorem)\" \"Lorem\")\n```\n```clojure\n;; clojure\n(re-find #\"(?i:lorem)\" \"Lorem\")\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Substitution\n\n```common-lisp\n;; common-lisp\n(cl-ppcre:regex-replace \"[^l]l\"  \"hello\"  \"EL\")\n(cl-ppcre:regex-replace-all \"[^l]l\"  \"hello hello\"  \"EL\")\n```\n```racket\n;; racket\n(regexp-replace #rx\"el\"  \"hello\"  \"EL\")\n(regexp-replace* #rx\"el\"  \"hello hello\"  \"EL\")\n```\n```clojure\n;; clojure\n(.replaceFirst \"hello\" \"[^l]l\" \"XX\")\n(.replaceAll \"hello hello\"  \"[^l]l\" \"XX\")\n```\n```emacs-lisp\n;; emacs-lisp 这里就像红宝石的gsub\n?\n(replace-regexp-in-string \"[^l]l\"  \"EL\"  \"hello hello\")\n```\n\n\n## Group Capture\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(match (regexp-match    #px\"(\\\\d{4})-(\\\\d{2})-(\\\\d{2})\"    \"2010-06-03\")  [(list s yr mn dy) (list yr mn dy)])\n```\n```clojure\n;; clojure\n(let [[_ yr mn dy]    (re-find #\"(\\d{4})-(\\d{2})-(\\d{2})\"      \"2010-06-03\")]  yr)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Scan\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(re-seq #\"\\w+\" \"dolor sit amet\")\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Backreference In Match And Substitution\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(regexp-match #px\"(\\\\w+) \\\\1\" \"do do\")\n(regexp-replace #px\"(\\\\w+) (\\\\w+)\"  \"do re\"  \"\\\\2 \\\\1\")\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Broken Down Datetime Type\n\n```common-lisp\n;; common-lisp\nNo dedicated type; a list of 9 values is used:  second: 0-59  minute: 0-59  hour: 0-23  day of month: 1-31  month: 1-12  year: 4 digits  day of week: 0-6 for Mon-Sun  is daylight savings time: t or nil  timezone: negated UTC offset in hours\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Current Datetime\n\n```common-lisp\n;; common-lisp\n(get-decoded-time)\n```\n```racket\n;; racket\n(require racket/date)\n(current-date)\n```\n```clojure\n;; clojure\n(def dt (new java.util.Date))\n```\n```emacs-lisp\n;; emacs-lisp 可以通过时间的先后顺序来判断运算，逻辑的先后顺序\n(current-time)\n```\n\n\n## Current Unix Epoch\n\n```common-lisp\n;; common-lisp\ngray|; seconds since Jan 1, 1900:##\n(get-universal-time)\n```\n```racket\n;; racket\n(current-seconds)\n```\n```clojure\n;; clojure\n(/ (System/currentTimeMillis) 1000.0)\n```\n```emacs-lisp\n;; emacs-lisp\n(float-time)\n```\n\n\n## Unix Epoch To Broken Down Datetime\n\n```common-lisp\n;; common-lisp\n(decode-universal-time  (get-unversal-time))\n```\n```racket\n;; racket\n(seconds-\u003edate (current-seconds))\n```\n```clojure\n;; clojure\n(def dt (new java.util.Date    (System/currentTimeMillis)))\n```\n```emacs-lisp\n;; emacs-lisp\n(seconds-to-time (float-time))\n```\n\n\n## Broken Down Datetime To Unix Epoch\n\n```common-lisp\n;; common-lisp\n(encode-universal-time 0 22 10 31 5 2015)\n```\n```racket\n;; racket\n(require racket/date)\n(date-\u003eseconds (current-date))\n```\n```clojure\n;; clojure\n(/ (.getTime (new java.util.Date)) 1000.0)\n```\n```emacs-lisp\n;; emacs-lisp\n(multiple-value-bind (b s)  (current-time)  (+ (* b (expt 2 16)) s))\n```\n\n\n## Format Datetime\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(def s \"yyyy-MM-dd HH:mm:ss\")\n(def fmt (new java.text.SimpleDateFormat s))\n(.format fmt (new java.util.Date))\n```\n```emacs-lisp\n;; emacs-lisp\n(format-time-string  \"%Y-%m-%d %H:%M:%S\"  (current-time))\n```\n\n\n## Parse Datetime\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(require (prefix-in s19. srfi/19))\n(define (date-str-\u003eunix-time s fmt)    (s19.time-second      (s19.date-\u003etime-utc        (s19.string-\u003edate s fmt))))\n(date-str-\u003eunix-time  \"2015-05-31 07:06:00\"  \"~Y-~m-~d ~H:~M:~S\")\n```\n```clojure\n;; clojure\n(def s \"yyyy-MM-dd HH:mm:ss\")\n(def fmt (new java.text.SimpleDateFormat s))\n(.parse fmt \"2015-05-30 09:14:14\")\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Date Parts\n\n```common-lisp\n;; common-lisp\n(multiple-value-bind  (ss mi hr dy mo yr)  (get-decoded-time)  (list ss mi hr) ; quiesce warning  (list dy mo yr))\n```\n```racket\n;; racket\n(date-year (current-date))\n(date-month (current-date))\n(date-day (current-date))\n```\n```clojure\n;; clojure\n(def cal (new java.util.GregorianCalendar))\n(.setTime cal dt)\n(.get cal java.util.Calendar/DAY_OF_MONTH)\n(+ (.get cal java.util.Calendar/MONTH) 1)\n(.get cal java.util.Calendar/YEAR)\n```\n```emacs-lisp\n;; emacs-lisp\n(multiple-value-bind  (ss mi hr dy mo yr)   (decode-time (current-time))  (list dy mo yr))\n```\n\n\n## Time Parts\n\n```common-lisp\n;; common-lisp\n(multiple-value-bind  (ss mi hr)  (get-decoded-time)  (list ss mi hr))\n```\n```racket\n;; racket\n(date-hour (current-date))\n(date-minute (current-date))\n(date-second (current-date))\n```\n```clojure\n;; clojure\n(def cal (new java.util.GregorianCalendar))\n(.setTime cal dt)\n(.get cal java.util.Calendar/HOUR_OF_DAY)\n(.get cal java.util.Calendar/MINUTE)\n(.get cal java.util.Calendar/SECOND)\n```\n```emacs-lisp\n;; emacs-lisp\n(multiple-value-bind  (ss mi hr dy mo yr)   (decode-time (current-time))  (list ss mi hr))\n```\n\n\n## Build Broken Down Datetime\n\n```common-lisp\n;; common-lisp\n(encode-universal-time 0 22 10 31 5 2015)\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(let  [yr 2015 mo 5 dy 31 hr 10 mi 22 ss 0]  (def cal    (new java.util.GregorianCalendar      yr (- mo 1) dy hr mi ss)))\n```\n```emacs-lisp\n;; emacs-lisp\n(encode-time 0 50 8 31 5 2015)\n```\n\n\n## Literal\n```common-lisp\n\n;; common-lisp\n'(1 2 3)\n(quote (1 2 3))\n```\n```racket\n;; racket\n'(1 2 3)\n'[1 2 3]\n'{1 2 3}\n(quote (1 2 3))\n```\n```clojure\n;; clojure\n'(1 2 3)\n(quote (1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp\n'(1 2 3)\n(quote (1 2 3))\n```\n\n\n## Constructor\n\n```common-lisp\n;; common-lisp\n(list 1 2 3)\n```\n```racket\n;; racket\n(list 1 2 3)\n```\n```clojure\n;; clojure\n(list 1 2 3)\n```\n```emacs-lisp\n;; emacs-lisp\n(list 1 2 3)\n```\n\n\n## Predicate\n\n```common-lisp\n;; common-lisp\n(listp '(1 2 3))\n```\n```racket\n;; racket\n(list? '(1 2 3))\n```\n```clojure\n;; clojure\n(list? '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp 判断是不是列表\n(listp '(1 2 3))\n```\n\n\n## Empty Test\n\n```common-lisp\n;; common-lisp\nnil and '() are synonyms and evaluate as false in a boolean context. All other values are true.\n```\n```racket\n;; racket\n(empty? '())\n```\n```clojure\n;; clojure\n(empty? ())\n```\n```emacs-lisp\n;; emacs-lisp\nnil and '() are synonyms and evaluate as false in a boolean context. All other values are true.\n```\n\n\n## Evaluating The Empty List\n\n```common-lisp\n;; common-lisp\nnil\n```\n```racket\n;; racket\nerror\n```\n```clojure\n;; clojure\n()\n```\n```emacs-lisp\n;; emacs-lisp\nnil\n```\n\n\n## Cons\n```common-lisp\n\n;; common-lisp\n(cons 1 '(2 3))\n```\n```racket\n;; racket\n(cons 1 '(2 3))\n```\n```clojure\n;; clojure\n(cons 1 '(2 3))\n```\n```emacs-lisp\n;; emacs-lisp 连接列表\n(cons 1 '(2 3))\n```\n\n\n## Head\n```common-lisp\n\n;; common-lisp\n(car '(1 2 3))\n(first '(1 2 3))\n```\n```racket\n;; racket\n(car '(1 2 3))\n(first '(1 2 3))\n```\n```clojure\n;; clojure\nfirst\n```\n```emacs-lisp\n;; emacs-lisp 取列表的第一个\ncar\n```\n\n\n## Tail\n```common-lisp\n\n;; common-lisp\n(cdr '(1 2 3))\n(rest '(1 2 3))\n```\n```racket\n;; racket\n(cdr '(1 2 3))\n(rest '(1 2 3))\n```\n```clojure\n;; clojure\n(rest '(1 2 3))\n(next '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp 取除了第一个列表\n(cdr '(1 2 3))\n(rest '(1 2 3))\n```\n\n\n## Head And Tail Of Empty List\n\n```common-lisp\n;; common-lisp\nboth evaluate to nil\n```\n```racket\n;; racket\nerror\n```\n```clojure\n;; clojure\n()\n```\n```emacs-lisp\n;; emacs-lisp\nboth evaluate to nil\n```\n\n\n## Length\n```common-lisp\n\n;; common-lisp\n(length '(1 2 3))\n```\n```racket\n;; racket\n(length '(1 2 3))\n```\n```clojure\n;; clojure\n(count '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp\n(length '(1 2 3))\n```\n\n\n## Equality Test\n\n```common-lisp\n;; common-lisp\n(equal '(1 2 3) '(1 2 3))\n```\n```racket\n;; racket\n(equal? '(1 2 3) '(1 2 3))\n```\n```clojure\n;; clojure\n(= '(1 2 3) '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp 这里是eq增强版，可以判断整一个列表是不是相同\n(equal '(1 2 3) '(1 2 3))\n```\n\n\n## Nth Element\n\n```common-lisp\n;; common-lisp\n; indexed from zero:\n(nth 2 '(1 2 3 4))\n```\n```racket\n;; racket\n(list-ref '(1 2 3 4) 2)\n```\n```clojure\n;; clojure\n(nth '(1 2 3 4) 2)\n```\n```emacs-lisp\n;; emacs-lisp 直接根据列表的位置去取，和clojure一样的\n(nth 2 '(1 2 3 4))\n```\n\n\n## Out Of Bounds Behavior\n\n```common-lisp\n;; common-lisp\nnil\n```\n```racket\n;; racket\nerror\n```\n```clojure\n;; clojure\nraises IndexOutOfBoundsException\n```\n```emacs-lisp\n;; emacs-lisp\nnil\n```\n\n\n## Element Index\n\n```common-lisp\n;; common-lisp\n(position 7 '(5 6 7 8))\n```\n```racket\n;; racket\n(require srfi/1)\n(list-index (lambda (x) (= x 7)) '(5 6 7 8))\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp 根据值来得到位置所在\n(position 7 '(5 6 7 8)) ; 2\n```\n\n\n## Concatenate\n\n```common-lisp\n;; common-lisp\n(append '(1 2 3) '(4 5 6))\n```\n```racket\n;; racket\n(append '(1 2 3) '(4 5 6))\n```\n```clojure\n;; clojure\n(concat '(1 2 3) '(4 5 6))\n```\n```emacs-lisp\n;; emacs-lisp 拼接两个大的列表\n(append '(1 2 3) '(4 5 6)) ; ( 1 2 3 4 5 6)\n```\n\n\n## Take\n```common-lisp\n\n;; common-lisp\nnone\n```\n```racket\n;; racket\n(take '(1 2 3 4) 2)\n```\n```clojure\n;; clojure\n(take 2 '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Drop\n```common-lisp\n\n;; common-lisp\n(nthcdr 2 '(1 2 3 4))\n```\n```racket\n;; racket\n(drop '(1 2 3 4) 2)\n```\n```clojure\n;; clojure\n(drop 2 '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp 切割部分列表\n(nthcdr 2 '(1 2 3 4)) ; (3 4)\n```\n\n\n## Last Element\n\n```common-lisp\n;; common-lisp\n(car (last '(1 2 3)))\n```\n```racket\n;; racket\n(last '(1 2 3))\n```\n```clojure\n;; clojure\n(last '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp first对应的last\n(car (last '(1 2 3)))\n```\n\n\n## All But Last Element\n\n```common-lisp\n;; common-lisp\n(butlast '(1 2 3))\n```\n```racket\n;; racket\n(define a '(1 2 3))\n(take a (- (length a) 1))\n```\n```clojure\n;; clojure\n(butlast '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp 对应的rest\n(butlast '(1 2 3)) ; (2 3)\n```\n\n\n## Reverse\n```common-lisp\n\n;; common-lisp\n(reverse '(1 2 3))\n```\n```racket\n;; racket\n(reverse '(1 2 3))\n```\n```clojure\n;; clojure\n(reverse '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp\n(reverse '(1 2 3))\n```\n\n\n## Sort\n```common-lisp\n\n;; common-lisp\n(sort '(3 2 4 1) '\u003c)\n```\n```racket\n;; racket\n(sort '(3 2 4 1) \u003c)\n```\n```clojure\n;; clojure\n(sort \u003c '(3 2 4 1))\n```\n```emacs-lisp\n;; emacs-lisp\n(sort '(3 2 4 1) '\u003c)\n```\n\n\n## Dedupe\n```common-lisp\n\n;; common-lisp\n(remove-duplicates '(1 1 2 3))\n```\n```racket\n;; racket\n(remove-duplicates '(1 1 2 3))\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp, uniq\n(remove-duplicates '(1 1 2 3))\n```\n\n\n## Membership\n\n```common-lisp\n;; common-lisp\n(member 7 '(1 2 3))\n```\n```racket\n;; racket\n(member 7 '(1 2 3))\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp ??? ====\n(member 7 '(2 2 3)) ;nil\n```\n\n\n## Map\n```common-lisp\n\n;; common-lisp\n(mapcar  (lambda (x) (* x x))  '(1 2 3))\n```\n```racket\n;; racket\n(map (lambda (x) (* x x)) '(1 2 3))\n```\n```clojure\n;; clojure\n(map #(* % %) '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp , mapcar is c code\n;; (-map (lambda (x) (* x x))  '(1 2 3)) ;; dash\n(mapcar  (lambda (x) (* x x))  '(1 2 3)) ;; (1 4 9)\n```\n\n\n## Filter\n```common-lisp\n\n;; common-lisp\n(remove-if-not  (lambda (x) (\u003e x 2))  '(1 2 3)); remove-if returns complement\n```\n```racket\n;; racket\n(filter  (lambda (x) (\u003e x 2))  '(1 2 3)); filter-not returns complement\n```\n```clojure\n;; clojure\n(filter #(\u003e % 2) '(1 2 3)); remove returns complement\n```\n```emacs-lisp\n;; emacs-lisp, ruby select\n(remove-if-not  (lambda (x) (\u003e x 2))  '(1 2 3)); remove-if returns complement\n```\n\n\n## Reduce\n```common-lisp\n\n;; common-lisp\n(reduce '-  '(1 2 3 4)  :initial-value 0)\n```\n```racket\n;; racket\n(foldl (lambda (x y) (- y x)) 0 '(1 2 3 4))\n```\n```clojure\n;; clojure\n(reduce - 0 '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp\n(reduce '-  '(1 2 3 4)  :initial-value 0) ; -10\n```\n\n\n## Right Fold\n\n```common-lisp\n;; common-lisp\n(reduce '-  '(1 2 3 4)  :initial-value 0  :from-end t)\n```\n```racket\n;; racket\n(foldr - 0 '(1 2 3 4))\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(reduce '-  '(1 2 3 4)  :initial-value 0  :from-end t) ;; -2\n```\n\n\n## Iterate\n```common-lisp\n\n;; common-lisp\n(dolist (x '(1 2 3))  (print x)  (print (- x)))\n```\n```racket\n;; racket\n(for ((x '(1 2 3)))  (printf \"~a~n\" x)  (printf \"~a~n\" (- x)))\n```\n```clojure\n;; clojure\n(doseq [x '(1 2 3)]  (println x)  (println (- x)))\n```\n```emacs-lisp\n;; emacs-lisp\n(dolist (x '(1 2 3))  (print x)  (print (- x))) ;; doseq\n```\n\n\n## Universal Predicate\n\n```common-lisp\n;; common-lisp\n(every  (lambda (i) (= 0 (rem i 2)))  '(1 2 3 4))\n```\n```racket\n;; racket\n(for/and ((i '(1 2 3 4)))  (= 0 (remainder i 2)))\n```\n```clojure\n;; clojure\n(every? #(= 0 (rem % 2)) '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp\n(every  (lambda (i) (= 0 (% i 2)))  '(1 2 3 4))\n```\n\n\n## Existential Predicate\n\n```common-lisp\n;; common-lisp\n(some  (lambda (i) (= 0 (rem i 2)))  '(1 2 3 4))\n```\n```racket\n;; racket\n(for/or ((i '(1 2 3 4)))  (= 0 (remainder i 2)))\n```\n```clojure\n;; clojure\n(some #(= 0 (rem % 2)) '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp\n(some  (lambda (i) (= 0 (% i 2)))  '(1 2 3 4)) ; t\n```\n\n\n## List Comprehension\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(for*/list  ((file \"ABCDEFGH\") (rank (in-range 1 9)))  (format \"~a~a\" file rank))\n```\n```clojure\n;; clojure\n(for  [file \"ABCDEFGH\" rank (range 1 9)]  (format \"%c%d\" file rank))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Shuffle\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n(shuffle '(1 2 3 4))\n```\n```clojure\n;; clojure\n(shuffle '(1 2 3 4))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Set Head\n\n```common-lisp\n;; common-lisp\n(defparameter *a* '(1 2 3))\n(setf (car *a*) 3)\n```\n```racket\n;; racket\n(require schema/mpair)\n(define a (mlist 1 2 3))\n(set-mcar! a 3)\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(setq a '(1 2 6 4 5))\n(setcar a 3) ; 3, (3 2 7 4 5)\n```\n\n\n## Set Tail\n\n```common-lisp\n;; common-lisp\n(defparameter *a* '(1 2 3))\n(setf (cdr *a*) '(4 5 6))\n```\n```racket\n;; racket\n(require schema/mpair)\n(define a (mlist 1 2 3))\n(set-mcdr! a (mlist 4 5 6))\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(setq a '(1 2 3)\n(setcar a 3)\n(setcdr a '(4 5 6))\n```\n\n\n## Manipulate Back\n\n```common-lisp\n;; common-lisp\n(defparameter *a* '(1 2 3))\n(push 4 *a*)\n(pop *a*)\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(setq a '(1 2 3))\n(push 4 a)\n(pop a)\n```\n\n\n## Flatten\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n(flatten '(1 2 (3 (4))))\n```\n```clojure\n;; clojure\n(flatten '(1 2 (3 (4))))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Associative Array Lookup\n\n```common-lisp\n;; common-lisp\n(assoc 3 '((1 2) (3 4)))\n```\n```racket\n;; racket\n(assoc 3 '((1 2) (3 4)))\n```\n```clojure\n;; clojure\nnone, see note\n```\n```emacs-lisp\n;; emacs-lisp\n(assoc 3 '((1 2) (3 4)))\n```\n\n\n## Flat Associative Array Lookup\n\n```common-lisp\n;; common-lisp\n(getf '(1 2 3 4) 3)\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(getf '(1 2 3 4) 3)\n```\n\n\n## Pair Literal\n\n```common-lisp\n;; common-lisp\n'(1 . 2)\n```\n```racket\n;; racket\n'(1 . 2)\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n'(1 . 2)\n```\n\n\n## Cons Cell Test\n\n```common-lisp\n;; common-lisp\n(cons '(1 . 2))\n(not (atom '(1 . 2)))\n```\n```racket\n;; racket\n(cons? '(1 . 2))\n(pair? '(1 . 2))\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(cons '(1 . 2))\n(not (atom '(1 . 2)))\n```\n\n\n## Translate Elements Recursively\n\n```common-lisp\n;; common-lisp\n(sublis '((1 . 2) (3 . 4))  '(1 (3 3 (1))))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(sublis '((1 . 2) (3 . 4))  '(1 (3 3 (1))))\n```\n\n\n## Literal\n```common-lisp\n\n;; common-lisp\n#(1 2 3)\n```\n```racket\n;; racket\n#(1 2 3)\n```\n```clojure\n;; clojure\n[1 2 3]\n```\n```emacs-lisp\n;; emacs-lisp\n[1 2 3]\n```\n\n\n## Constructor\n\n```common-lisp\n;; common-lisp\n(vector 1 2 3)\n```\n```racket\n;; racket\n(vector 1 2 3)\n```\n```clojure\n;; clojure\n(vector 1 2 3)\n```\n```emacs-lisp\n;; emacs-lisp\n(vector 1 2 3)\n```\n\n\n## Size\n```common-lisp\n\n;; common-lisp\n(length #(1 2 3))\n```\n```racket\n;; racket\n(vector-length #(1 2 3))\n```\n```clojure\n;; clojure\n(count [1 2 3])\n```\n```emacs-lisp\n;; emacs-lisp\n(length [1 2 3])\n```\n\n\n## Lookup\n```common-lisp\n\n;; common-lisp\n(elt #(1 2 3) 0) or\n(aref #(1 2 3) 0)\n```\n```racket\n;; racket\n(vector-ref #(1 2 3) 0)\n```\n```clojure\n;; clojure\n(nth [1 2 3] 0)\n```\n```emacs-lisp\n;; emacs-lisp\n(elt [1 2 3] 0)\n```\n\n\n## Update\n```common-lisp\n\n;; common-lisp\n(setq v [1 2 3])\n(setf (aref v 2) 4)\n```\n```racket\n;; racket\n(define v (vector 1 2 3))\n(vector-set! v 2 4)\n```\n```clojure\n;; clojure\n(replace {2 4} [1 2 3])\n```\n```emacs-lisp\n;; emacs-lisp\n(setq v #(1 2 3))\n(setf (aref v 2) 4)\n```\n\n\n## Out Of Bounds Behavior\n\n```common-lisp\n;; common-lisp\nraises sb-kernel:index-too-large-error\n```\n```racket\n;; racket\nerror\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Array To List\n\n```common-lisp\n;; common-lisp\n(coerce #(1 2 3) 'list)\n```\n```racket\n;; racket\n(vector-\u003elist #(1 2 3))\n```\n```clojure\n;; clojure\n(seq [1 2 3])\n```\n```emacs-lisp\n;; emacs-lisp\n(coerce [1 2 3] 'list)\n```\n\n\n## List To Array\n\n```common-lisp\n;; common-lisp\n(coerce '(1 2 3) 'vector)\n```\n```racket\n;; racket\n(list-\u003evector '(1 2 3))\n```\n```clojure\n;; clojure\n(vec '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp\n(coerce '(1 2 3) 'vector)\n```\n\n\n## Reverse\n```common-lisp\n\n;; common-lisp\n(reverse #(1 2 3))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Sort\n```common-lisp\n\n;; common-lisp\n(sort #(2 4 1 3) #'\u003c)\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Map\n```common-lisp\n\n;; common-lisp\n(map 'vector (lambda (x) (* x x)) #(1 2 3))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Filter\n```common-lisp\n\n;; common-lisp\n(remove-if-not (lambda (x) (\u003e x 2)) #(1 2 3)); also remove-if\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Reduce\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Literal\n```common-lisp\n\n;; common-lisp\nnone\n```\n```racket\n;; racket\n; immutable:\n#hash((\"t\" . 1) (\"f\" . 0))\n```\n```clojure\n;; clojure\n; clojure.lang.PersistentArrayMap:\n{\"t\" 1 \"f\" 0}\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Constructor\n\n```common-lisp\n;; common-lisp\n(defparameter *h* (make-hash-table :test 'equal)); default equality test is 'eql\n```\n```racket\n;; racket\n(define ih  (make-immutable-hash    '((\"t\" . 1) (\"f\" . 0)))); mutable:\n(define h (make-hash '((\"t\" . 1) (\"f\" . 0))))\n```\n```clojure\n;; clojure\n; immutable:\n(def ih (hash-map \"t\" 1 \"f\" 0))\n```\n```emacs-lisp\n;; emacs-lisp\n(setq h (make-hash-table :test 'equal))\n```\n\n\n## Predicate\n\n```common-lisp\n;; common-lisp\n(hash-table-p *h*)\n```\n```racket\n;; racket\n(hash? h); also true of assoc. lists and vectors:\n(dict? h)\n```\n```clojure\n;; clojure\n(map? ih)\n```\n```emacs-lisp\n;; emacs-lisp\n(hash-table-p h)\n```\n\n\n## Size\n```common-lisp\n\n;; common-lisp\n(hash-table-count *h*)\n```\n```racket\n;; racket\n(hash-count h); also works with assoc lists and vectors:\n(dict-count ih)\n```\n```clojure\n;; clojure\n(count ih)\n```\n```emacs-lisp\n;; emacs-lisp\n(hash-table-count h)\n```\n\n\n## Lookup\n```common-lisp\n\n;; common-lisp\n(gethash \"t\" *h*)\n```\n```racket\n;; racket\n(hash-ref h \"t\"); return -1 if not found:\n(hash-ref h \"m\" -1); also works with assoc. lists and vectors:\n(dict-ref ih \"t\")\n(dict-ref ih \"m\" -1)\n```\n```clojure\n;; clojure\n(get ih \"t\")\n(find ih \"t\"); return -1 if not found:\n(get ih \"m\" -1)\n```\n```emacs-lisp\n;; emacs-lisp\n(gethash \"t\" h)\n```\n\n\n## Update\n```common-lisp\n\n;; common-lisp\n(setf (gethash \"t\" *h*) 1)\n```\n```racket\n;; racket\n(hash-set! h \"t\" 2)\n(define ih2 (hash-set ih \"t\" 2)); also dict-set! and dict-set\n```\n```clojure\n;; clojure\n(def ih2 (assoc ih \"t\" 2))\n```\n```emacs-lisp\n;; emacs-lisp\n(puthash \"t\" 1 h)\n```\n\n\n## Missing Key Behavior\n\n```common-lisp\n;; common-lisp\nreturns nil\n```\n```racket\n;; racket\nerror\n```\n```clojure\n;; clojure\nreturns nil\n```\n```emacs-lisp\n;; emacs-lisp\nreturns nil\n```\n\n\n## Is Key Present\n\n```common-lisp\n;; common-lisp\n(nth-value 1 (gethash \"t\" *h*))\n```\n```racket\n;; racket\n(hash-has-key? h \"t\"); also dict-has-key?\n```\n```clojure\n;; clojure\n(contains? ih \"t\")\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Delete\n```common-lisp\n\n;; common-lisp\n(remhash \"t\" *h*)\n```\n```racket\n;; racket\n(hash-remove! h \"t\")\n(define ih2  (hash-remove ih \"t\")); also dict-remove! and dict-remove\n```\n```clojure\n;; clojure\n(def ih2 (dissoc ih \"t\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(remhash \"hello\" h)\n```\n\n\n## Merge\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n; values in ih2 take precedence:\n(define ih3 (merge ih ih2))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Invert\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(require 'clojure.set)\n(define ih4 (clojure.set/map-invert ih))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Iterate\n```common-lisp\n\n;; common-lisp\n(maphash  (lambda (k v)    (print k)    (print v))  *h*)\n```\n```racket\n;; racket\n(hash-for-each h  (lambda (k v)    (printf \"~a~n\" k)    (printf \"~a~n\" v))); also dict-for-each\n```\n```clojure\n;; clojure\n(doseq [p ih]  (println (first p))  (println (second p)))\n```\n```emacs-lisp\n;; emacs-lisp\n(maphash  (lambda (k v)    (print k)    (print v))  h)\n```\n\n\n## Keys And Values As Lists\n\n```common-lisp\n;; common-lisp\nnone\n```\n```racket\n;; racket\n(hash-keys h)\n(hash-values h); also dict-keys and dict-values\n```\n```clojure\n;; clojure\n(def hkeys (map (fn [p] (first p)) ih))\n(def hvals (map (fn [p] (second p)) ih))\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Defstruct\n\n```common-lisp\n;; common-lisp\n(defstruct account id balance)\n```\n```racket\n;; racket\n(define-struct account (id (balance #:mutable)))\n```\n```clojure\n;; clojure\n(defstruct account :id :balance)\n```\n```emacs-lisp\n;; emacs-lisp\n(defstruct account id balance)\n```\n\n\n## Struct\n```common-lisp\n\n;; common-lisp\n(setq a  (make-account    :id 3    :balance 17.12))\n```\n```racket\n;; racket\n(define a (make-account 3 17.12))\n```\n```clojure\n;; clojure\n(def a (struct account 3 17.12))\n```\n```emacs-lisp\n;; emacs-lisp\n(setq a  (make-account :id 3 :balance 17.12))\n```\n\n\n## Struct Getter\n\n```common-lisp\n;; common-lisp\n(account-id a)\n```\n```racket\n;; racket\n(account-id a)\n```\n```clojure\n;; clojure\n(:id a)\n```\n```emacs-lisp\n;; emacs-lisp\n(account-id a)\n```\n\n\n## Struct Setter\n\n```common-lisp\n;; common-lisp\n(setf (account-balance a) 0)\n```\n```racket\n;; racket\n(set-account-balance! a 0)\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(setf (account-balance a) 0)\n```\n\n\n## Struct Predicate\n\n```common-lisp\n;; common-lisp\n(account-p a)\n```\n```racket\n;; racket\n(account? a)\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(account-p a)\n```\n\n\n## Define Function\n\n```common-lisp\n;; common-lisp\n(defun add (x y) (+ x y))\n```\n```racket\n;; racket\n(define (add x y) (+ x y))\n```\n```clojure\n;; clojure\n(defn add [x y] (+ x y))\n```\n```emacs-lisp\n;; emacs-lisp\n(defun add (x y) (+ x y))\n```\n\n\n## Can Function And Variable Share Name\n\n```common-lisp\n;; common-lisp\nyes\n```\n```racket\n;; racket\nno\n```\n```clojure\n;; clojure\nno\n```\n```emacs-lisp\n;; emacs-lisp\nyes\n```\n\n\n## Optional Argument\n\n```common-lisp\n;; common-lisp\n(defun add (a \u0026optional b)  (if (null b) a (+ a b)))\n```\n```racket\n;; racket\n(define (add a (b null))  (if (null? b) a (+ a b)))\n```\n```clojure\n;; clojure\n(defn add ([a] a) ([a b] (+ a b)))no syntax error if called with more than 2 args:\n(defn add [a \u0026 [b]]  (if (nil? b) a (+ a b)))\n```\n```emacs-lisp\n;; emacs-lisp\n(defun add (a \u0026optional b)  (if (null b) a (+ a b))) ;; like ruby *args\n(add 1) ; 1\n(add 1 2) ; 2\n```\n\n\n## Variable Number Of Arguments\n\n```common-lisp\n;; common-lisp\n(defun add (a \u0026rest b)  (if (null b)    a    (+ a (eval (cons '+ b)))))\n```\n```racket\n;; racket\n(define (add a . b)  (if (null? b)    a    (+ a (apply + b))))\n```\n```clojure\n;; clojure\n(defn add [a \u0026 b]  (if (nil? b) a (+ a (apply + b))))\n```\n```emacs-lisp\n;; emacs-lisp\n(defun add (a \u0026rest b)  (if (null b)    a    (+ a (eval (cons '+ b)))))\n(add 1) ; 1\n(add 1 2) ; 3\n```\n\n\n## Default Value\n\n```common-lisp\n;; common-lisp\n(defun add (a \u0026optional (b 0))  (+ a b))\n```\n```racket\n;; racket\nracket:\n(define (add a (b 0)) (+ a b))\n```\n```clojure\n;; clojure\n(defn add  ([a] (add a 0))  ([a b] (+ a b)))\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Named Parameter\n\n```common-lisp\n;; common-lisp\n(defun logarithm (\u0026key number base)  (/ (log number) (log base)))\n(logarithm :base 2 :number 8)\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(defn logarithm [{x :number b :base}] (/ (Math/log x) (Math/log b)))\n(logarithm {:base 2 :number 8})\n```\n```emacs-lisp\n;; emacs-lisp\n(defun logarithm  (\u0026key number \u0026key base)  (if base    (/ (log number) (log base))    (log number))) order significant, not key names:\n(logarithm :foo 8 :bar 2)\n```\n\n\n## Return Multiple Values\n\n```common-lisp\n;; common-lisp\n(defun sqrts (x)  (values (sqrt x) (- (sqrt x))))\n```\n```racket\n;; racket\n(define (sqrts x)  (values (sqrt x) (- (sqrt x))))\n```\n```clojure\n;; clojure\n(defn sqrts [x] (list (Math/sqrt x) (- (Math/sqrt x))))\n```\n```emacs-lisp\n;; emacs-lisp\nvalues creates a list:\n(defun sqrts (x)  (values (sqrt x) (- (sqrt x))))\n```\n\n\n## Assign Multiple Values To Local Variables\n\n```common-lisp\n;; common-lisp\n(multiple-value-bind (r1 r2)  (sqrts 3)  r2)\n```\n```racket\n;; racket\n(let-values  (((r1 r2) (sqrts 3)))  r2)\n```\n```clojure\n;; clojure\n(let [[r1 r2] (sqrts 3)] r2)\n```\n```emacs-lisp\n;; emacs-lisp\n(multiple-value-bind  (r1 r2)  (sqrts 3)  r2)\n```\n\n\n## Assign Multiple Values To Global Variables\n\n```common-lisp\n;; common-lisp\n(multiple-value-setq (r1 r2)  (sqrts 3))\n```\n```racket\n;; racket\n(define-values (r1 r2) (sqrts 3))\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(multiple-value-setq (r1 r2) (sqrts 3))\n```\n\n\n## Convert List To Multiple Values\n\n```common-lisp\n;; common-lisp\n(values-list '(1 2 3))\n```\n```racket\n;; racket\n(apply values '(1 2 3))\n```\n```clojure\n;; clojure\nmultiple values are lists\n```\n```emacs-lisp\n;; emacs-lisp\nmultiple values are lists\n```\n\n\n## Assign Multiple Values To List\n\n```common-lisp\n;; common-lisp\n(multiple-value-list (sqrts 3))\n```\n```racket\n;; racket\n(call-with-values  (lambda () (sqrts 3))  list)\n```\n```clojure\n;; clojure\nmultiple values are lists\n```\n```emacs-lisp\n;; emacs-lisp\nmultiple values are lists\n```\n\n\n## Tail Call Optimization\n\n```common-lisp\n;; common-lisp\nyes for sbcl\n```\n```racket\n;; racket\nyes\n```\n```clojure\n;; clojure\nyes with recur\n```\n```emacs-lisp\n;; emacs-lisp\nno\n```\n\n\n## Lambda\n```common-lisp\n\n;; common-lisp\n(lambda (x) (* x x))\n```\n```racket\n;; racket\n(lambda (x) (* x x))\n```\n```clojure\n;; clojure\n#(* % %)\n(fn [x] (* x x)); shortcut notation with two args:\n#(* %1 %2)\n```\n```emacs-lisp\n;; emacs-lisp\n(lambda (x) (* x x))\n```\n\n\n## Apply\n```common-lisp\n\n;; common-lisp\n((lambda (x) (* x x)) 2)\n(apply #'(lambda (x) (* x x)) '(2))\n```\n```racket\n;; racket\n((lambda (x) (* x x)) 2)\n(apply (lambda (x) (* x x)) '(2))\n```\n```clojure\n;; clojure\n(#(* % %) 2)\n((fn [x] (* x x)) 2)\n(apply #(* % %) '(2))\n```\n```emacs-lisp\n;; emacs-lisp\n((lambda (x) (* x x)) 2)\n(apply  #'(lambda (x) (* x x))  '(2))\n```\n\n\n## Progn\n```common-lisp\n\n;; common-lisp\nprogn prog1 prog2\n```\n```racket\n;; racket\nbegin none noner6rs:\nbegin begin0 none\n```\n```clojure\n;; clojure\ndo none none\n```\n```emacs-lisp\n;; emacs-lisp\nprogn prog1 prog2\n```\n\n\n## Loop\n```common-lisp\n\n;; common-lisp\n(setq i 1)\n(loop (print \"hello\")  (if (\u003e i 10)    (return)    (setq i (+ i 1))))\n```\n```racket\n;; racket\nnone, use recursion\n```\n```clojure\n;; clojure\n(loop [i 1]  (if (\u003c= i 10)      (do (println \"hello\")          (recur (+ i 1)))))\n```\n```emacs-lisp\n;; emacs-lisp\n(setq i 1)\n(loop (print \"hello\")      (if (\u003e i 10)          (return)          (setq i (+ i 1))))\n```\n\n\n## Do\n```common-lisp\n\n;; common-lisp\n(do ((i 1) (sum 0))  ((\u003e i 100) sum)  (setq sum (+ sum i))  (setq i (+ i 1)))do* initializes serially\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\n(do ((i 1) (sum 0))    ((\u003e i 100) sum)    (setq sum (+ sum i))    (setq i (+ i 1)))do* initializes sequentially\n```\n\n\n## Dotimes\n```common-lisp\n\n;; common-lisp\n(dotimes (i 10 nil)  (format t \"hello~%\"))\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(dotimes [_ 10]  (println \"hello\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(dotimes (i 10 nil)  (print \"hello\\n\"))\n```\n\n\n## If\n```common-lisp\n\n;; common-lisp\n(if (\u003c x 0) (- x) x)\n```\n```racket\n;; racket\n(if (\u003c x 0) (- x) x)\n```\n```clojure\n;; clojure\n(if (\u003c x 0) (- x) x)\n```\n```emacs-lisp\n;; emacs-lisp\n(if (\u003c x 0) (- x) x)\n```\n\n\n## When\n```common-lisp\n\n;; common-lisp\n(when (\u003c x y)  (print \"x is less \")  (print \"than y\"))\n```\n```racket\n;; racket\nracket:\n(when (\u003c x y)  (display \"x is less \")  (display \"than y\"))\n```\n```clojure\n;; clojure\n(when (\u003c x y)  (println \"x is less \")  (println \"than y\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(when (\u003c x y)  (print \"x is less \")  (print \"than y\"))\n```\n\n\n## Cond\n```common-lisp\n\n;; common-lisp\n(cond ((\u003e x 0) 1)  ((= x 0) 0)  (t -1))\n```\n```racket\n;; racket\n(cond ((\u003e x 0) 1)  ((= x 0) 0)  (else -1))\n```\n```clojure\n;; clojure\n(cond (\u003e x 0) 1  (= x 0) 0  true -1)\n```\n```emacs-lisp\n;; emacs-lisp\n(cond ((\u003e x 0) 1)  ((= x 0) 0)  (t -1))\n```\n\n\n## Lazy Evaluation\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(define x (delay (/ 1 0)))\n(promise? x)\n(+ 1 (force x))\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Continuations\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(define cc null)\n(+ 1 (call/cc (lambda (x) (set! cc x) 0)))\n(cc 5)\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Error\n```common-lisp\n\n;; common-lisp\n(error \"failed\")\n```\n```racket\n;; racket\n(error \"failed\")\n```\n```clojure\n;; clojure\n(throw (Exception. \"failed\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(error \"failed\")\n```\n\n\n## Handle Error\n\n```common-lisp\n;; common-lisp\n(handler-case  (error \"failed\")  (simple-error (e)    (format t \"error: ~a\" e)))\n```\n```racket\n;; racket\n(with-handlers  ((exn:fail?     (lambda (e)       (printf \"error: ~a\"         (exn-message e)))))  (error \"failed\"))\n```\n```clojure\n;; clojure\n(try (throw (Exception. \"failure\"))  (catch Exception e    (printf \"error: %s\"      (.getMessage e))))\n```\n```emacs-lisp\n;; emacs-lisp\n(condition-case e  (error \"failed\")  (error (message \"error: %s\"    (error-message-string e))))\n```\n\n\n## Define Exception\n\n```common-lisp\n;; common-lisp\n(define-condition odd-err (error)  ((num :accessor odd-err-num        :initarg :num))  (:report    (lambda (e s)      (format s \"odd number: ~a\"        (odd-err-num e)))))\n```\n```racket\n;; racket\n(define exn:odd-err? \"odd number\")\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nonly symbols and keywords can be thrown and caught\n```\n\n\n## Throw Exception\n\n```common-lisp\n;; common-lisp\n(error 'odd-err :num 7)\n```\n```racket\n;; racket\n(raise exn:odd-err?)\n```\n```clojure\n;; clojure\n(throw (Exception. \"failed\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(throw 'odd-err t)\n```\n\n\n## Catch Exception\n\n```common-lisp\n;; common-lisp\n(handler-case (/ 1 0)  (division-by-zero ()    (progn      (format t \"division by zero\")      nil)))\n```\n```racket\n;; racket\n(with-handlers ((exn:fail? (lambda (e) (begin (printf \"division by zero~n\") null)))) (/ 1 0))\n```\n```clojure\n;; clojure\n(try (/ 1 0) (catch ArithmeticException _ (do (println \"division by zero\") nil)))\n```\n```emacs-lisp\n;; emacs-lisp\n(catch 'failed (throw 'failed nil) t)\n```\n\n\n## Restart Case\n\n```common-lisp\n;; common-lisp\n(defun halve (l)  (mapcar (lambda (x)    (restart-case      (if (= (rem x 2) 0) (/ x 2)        (error 'odd-error :num x))      (round-down () (/ (- x 1) 2))      (round-up () (/ (+ x 1) 2)))) l))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Invoke Restart\n\n```common-lisp\n;; common-lisp\n(handler-bind  ((odd-err      (lambda (c)        (invoke-restart          'round-down))))      (halve '(1 2 4 9)))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Finally Clause\n\n```common-lisp\n;; common-lisp\n(unwind-protect  (error \"failure\")  (print \"clean up\"))\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(try (throw (Exception. \"failure\"))     (finally (println \"clean up\")))\n```\n```emacs-lisp\n;; emacs-lisp\n(unwind-protect  (error \"failure\")  (print \"clean up\"))\n```\n\n\n## Standard File Handles\n\n```common-lisp\n;; common-lisp\n*standard-input*\n*standard-output*\n*error-output*\n```\n```racket\n;; racket\n(current-input-port)\n(current-output-port)\n(current-error-port)\n```\n```clojure\n;; clojure\n*in*\n*out*\n*err*\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## End Of File Behavior\n\n```common-lisp\n;; common-lisp\nread-line returns two values, the 2nd set to T at end-of-file.\nEOF-OF-FILE is signaled when reading past end of file.\n```\n```racket\n;; racket\nReturns the value eof.Use eof-object? to test for it.\n```\n```clojure\n;; clojure\n.readLine on a java.io.Reader object returns nil.\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Read Line From Stdin\n\n```common-lisp\n;; common-lisp\n(setq line (read-line))\n```\n```racket\n;; racket\n(let ((s (read-line)))  #|use s|#)\n```\n```clojure\n;; clojure\n(let [s (read-line)]  (comment use s))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Chomp\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\nread-line discards newline\n```\n```clojure\n;; clojure\nread-line discards newline\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Write Line To Stdout\n\n```common-lisp\n;; common-lisp\n(defun println (s)  (format t \"~a~%\" s))\n(println \"hello\")\n```\n```racket\n;; racket\n(write-string s)\n(newline)\n```\n```clojure\n;; clojure\n(println \"hello\")\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Write Formatted String To Stdout\n\n```common-lisp\n;; common-lisp\n(format t \"~s ~d: ~2$~%\"  \"foo\"  7  13.7)\n```\n```racket\n;; racket\n(printf \"~a ~a: ~a~n\"  \"foo\"  7  (/ (round (* 13.7 100)) 100))\n```\n```clojure\n;; clojure\n(printf \"%s %d %.2f\\n\" \"foo\" 7 13.7)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Open File For Reading\n\n```common-lisp\n;; common-lisp\n(setq in (open \"/etc/hosts\"))\n```\n```racket\n;; racket\n(let  ((f (open-input-file \"/etc/hosts\")))  #| use f |#)\n```\n```clojure\n;; clojure\n; f is java.io.Reader object:\n(let [f (clojure.java.io/reader \"/etc/hosts\")]  (.readLine f))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Open File For Writing\n\n```common-lisp\n;; common-lisp\n(setq out (open \"/tmp/test\" :direction :output :if-exists :supersede))\n```\n```racket\n;; racket\n(let  ((f (open-output-file        \"/tmp/foo\"        #:exists 'truncate)))  #| use f |#)\n```\n```clojure\n;; clojure\n; f is java.io.Writer object:\n(let [f (clojure.java.io/writer \"/tmp/foo\")]  (.write f \"lorem ipsum\\n\")  (.close f))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Open File For Appending\n\n```common-lisp\n;; common-lisp\n(setq out (open \"/tmp/test\" :direction :output :if-exists :append))\n```\n```racket\n;; racket\n(let  ((f (open-output-file        \"/tmp/foo\"        #:exists 'append)))  #| use f |#)\n```\n```clojure\n;; clojure\n(let [f (clojure.java.io/writer \"/tmp/foo\"      :append true)]  (.write f \"lorem ipsum\\n\")  (.close f))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Close File\n\n```common-lisp\n;; common-lisp\n(close in)\n```\n```racket\n;; racket\n(close-input-port f)\n(close-output-port f)\n```\n```clojure\n;; clojure\n(.close f)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Close File Implicitly\n\n```common-lisp\n;; common-lisp\n(with-open-file (out #P\"/tmp/test\" :direction :output) (write-line \"lorem ipsum\" out))\n```\n```racket\n;; racket\n(call-with-input-file  \"/etc/hosts\"  (lambda (f) (#| use f |#)); also call-with-output-file\n```\n```clojure\n;; clojure\n(with-open [f    (clojure.java.io/reader \"/etc/hosts\")]  (comment use f))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Read Line\n\n```common-lisp\n;; common-lisp\n(setq line (read-line f))\n```\n```racket\n;; racket\n(define line (read-line in))\n```\n```clojure\n;; clojure\n(.readLine f)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Iterate Over File By Line\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(for ([line (in-lines        (open-input-file          \"/etc/hosts\"))])  (write-string line)  (newline))\n```\n```clojure\n;; clojure\n(loop [line (.readLine f)]  (if (not= line nil)    (do (println line)      (recur (.readLine f)))))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Read File Into Array Of Strings\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n; to list of strings:\n(sequence-\u003elist (in-lines    (open-input-file \"/etc/hosts\")))\n```\n```clojure\n;; clojure\n(vec (line-seq f))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Read File Into String\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(define s (file-\u003estring \"/etc/hosts\"))\n```\n```clojure\n;; clojure\n(let [s (slurp \"/etc/hosts\")]  (print s))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Write String\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(write-string s f)\n```\n```clojure\n;; clojure\n(.write f s)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Write Line\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(write-string s f)\n(newline f)\n```\n```clojure\n;; clojure\n(.write f (println-str s))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Flush File Handle\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(flush-output f)\n```\n```clojure\n;; clojure\n(f .flush)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## File Handle Positionget Set\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n; Evaluates to non-negative integer:\n(file-position f); Sets next read or write\n; to beginning of file:\n(file-position f 0)\n```\n```clojure\n;; clojure\n; arg is characters from current position;\n; moving backward not possible:\n(.skip f 1000); arg is max characters to buffer:\n(.mark f 1000000); move to position saved when .mark was called:\n(.rest f)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## In Memory Stream\n\n```common-lisp\n;; common-lisp\n(setq f (make-string-input-stream    \"lorem ipsum\"))\n(read-line f)\n(setq f2 (make-string-output-stream)\n(write-string \"lorem ipsum)\n(get-output-stream-string out)\n```\n```racket\n;; racket\n(define f (open-input-string \"lorem ipsum\"))\n(read-line f)\n(define f2 (open-output-string))\n(write-string \"lorem ipsum\" f2)\n(get-output-string f2)\n```\n```clojure\n;; clojure\n; use *in* to read from string:\n(with-in-str \"lorem ispum\"  (read-line)); use *out* to write to string:\n(with-out-str  (println \"lorem ipsum\"))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## List Buffers\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; list of buffer objects:\n(buffer-list);; name of first buffer in list:\n(buffer-name (car (buffer-list)));; name of current buffer:\n(buffer-name (current-buffer))\n```\n\n\n## Current Bufferget And Set\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; name of current buffer:\n(buffer-name (current-buffer));; open in current pane:\n(switch-to-buffer \"foo.txt\");; open in other pane:\n(switch-to-buffer-other-window  \"bar.txt\")\n```\n\n\n## Clear Buffer\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; current buffer:\n(erase-buffer);; buffer named \"foo.txt:\n(with-current-buffer \"foo.txt\"  (erase-buffer))\n```\n\n\n## Pointget And Set\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; 1-based index of char under cursor:\n(point);; go to beginning of current buffer:\n(goto-char 1);; go to end of current buffer:\n(goto-char (buffer-size))\n```\n\n\n## Search And Set Point\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; Set point to character after string.\n;; 1st arg is position in buffer beyond\n;;   which search stops.\n;; If 2nd arg is true, return nil\n;;   on failure, otherwise raise error.\n;; 3rd argument is the occurrence\n;;   of the string, if negative\n;;   search backwards from point.\n(search-forward \"lorem\" nil t 1)\n```\n\n\n## Insert At String Point\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; takes 1 or more args:\n(insert \"lorem\" \" ipsum\")\n```\n\n\n## Current Buffer As String\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(buffer-string)\n```\n\n\n## Insert File Contents At Point\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(insert-file \"/etc/passwd\")\n```\n\n\n## Markget And Set\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n;; to beginning of current buffer:\n(set-mark 1);; to point of current buffer:\n(set-mark (point))\n```\n\n\n## File Test Regular File Test\n\n```common-lisp\n;; common-lisp\n(osicat:file-exists-p \"/tmp/foo\")\n(osicat:regular-file-exists-p \"/tmp/foo\")\n```\n```racket\n;; racket\n??\n(file-exists? \"/etc/hosts\")\n```\n```clojure\n;; clojure\n(.exists (io/file \"/etc/hosts\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(file-exists-p \"/etc/hosts\")\n(file-regular-p \"/etc/hosts\")\n```\n\n\n## File Size\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(file-size \"/etc/hosts\")\n```\n```clojure\n;; clojure\n(.length (io/file \"/etc/hosts\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(eighth  (file-attributes \"/etc/hosts\"))\n```\n\n\n## Is File Readable Writable Executable\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(pair? (filter    (lambda (x) (eq? x 'read))    (file-or-directory-permissions      \"/etc/hosts\")))\n(pair? (filter    (lambda (x) (eq? x 'write))    (file-or-directory-permissions      \"/etc/hosts\")))\n(pair? (filter    (lambda (x) (eq? x 'execute))    (file-or-directory-permissions      \"/etc/hosts\")))\n```\n```clojure\n;; clojure\n(.canRead (io/file \"/etc/hosts\"))\n(.canWrite (io/file \"/etc/hosts\"))\n(.canExecute (io/file \"/etc/hosts\"))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Set File Permissions\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(file-or-directory-permissions  \"/tmp/foo\"  #o755)\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(set-file-modes \"/tmp/foo\" #o755)\n```\n\n\n## Last Modification Time\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(file-or-directory-modify-seconds \"/tmp/foo\")\n```\n```clojure\n;; clojure\n; Unix epoch in milliseconds:\n(.lastModified (java.io.File. \"/tmp/foo\"))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Copy File Remove File Rename File\n\n```common-lisp\n;; common-lisp\n(cl-fad:copy-file #P\"/tmp/foo\"  #P\"/tmp/bar\")\n(delete-file #P\"/tmp/foo\")\n(rename-file #P\"/tmp/bar\"  #P\"/tmp/foo\")\n```\n```racket\n;; racket\n(copy-file \"/tmp/foo\" \"/tmp/bar\")\n(delete-file \"/tmp/foo\")\n(rename-file-or-directory  \"/tmp/bar\"  \"/tmp/foo\")\n```\n```clojure\n;; clojure\n(clojure.java.io/copy  (java.io.File. \"/tmp/foo\")  (java.io.File. \"/tmp/bar\"))\n(clojure.java.io/delete-file \"/tmp/foo\")\n(.renameTo (java.io.File. \"/tmp/bar\")  (java.io.File. \"/tmp/foo\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(copy-file \"/tmp/foo\" \"/tmp/bar\")\n(delete-file \"/tmp/foo\")\n(rename-file \"/tmp/bar\" \"/tmp/foo\")\n```\n\n\n## Create Symlink Symlink Test Get Target\n\n```common-lisp\n;; common-lisp\n(osicat:make-link \"/tmp/hosts\" :target \"/etc/hosts\")\n```\n```racket\n;; racket\n(make-file-or-directory-link  \"/etc/hosts\"  \"/tmp/hosts\")\n(link-exists? \"/tmp/hosts\")??\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(make-symbolic-link \"/etc/hosts\" /tmp/hosts\")returns target if symlink or nil:\n(file-symlink-p \"/tmp/hosts\")\n```\n\n\n## Temporary File\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(define tmp (make-temporary-file))\n(path-\u003estring tmp)\n```\n```clojure\n;; clojure\n; java.io.File:\n(java.io.File/createTempFile \"foo\" \".txt\")\n```\n```emacs-lisp\n;; emacs-lisp\n(make-temp-file \"foo\")\n```\n\n\n## Build Pathname\n\n```common-lisp\n;; common-lisp\n(make-pathname  :directory '(:absolute \"etc\")  :name \"hosts\")\n```\n```racket\n;; racket\n; returns path; convert to string\n; with path-\u003estring:\n(build-path \"/etc\" \"hosts\")\n```\n```clojure\n;; clojure\n(require '[clojure.java.io :as io]); returns java.io.File;\n; convert to string with .getPath:\n(io/file \"/etc\" \"hosts\")\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Dirname And Basename\n\n```common-lisp\n;; common-lisp\n(pathname-directory #P\"/etc/hosts\")\n(pathname-name #P\"/etc/hosts\")\n```\n```racket\n;; racket\n(let-values (((dir file _)        (split-path \"/etc/hosts\")))  #| use dir or file |#)\n```\n```clojure\n;; clojure\n(require '[clojure.java.io :as io])\n(.getParent (io/file \"/etc/hosts\"))\n(.getName (io/file \"/etc/hosts\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(file-name-directory \"/etc/hosts\")\n(file-name-nondirectory  \"/etc/hosts\")\n```\n\n\n## Absolute Pathname\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(simplify-path  (path-\u003ecomplete-path \"..\"))\n```\n```clojure\n;; clojure\n(.getCanonicalPath (java.io.File. \"..\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(expand-file-name \"..\")\n```\n\n\n## Iterate Over Directory By File\n\n```common-lisp\n;; common-lisp\n(dolist (file (osicat:list-directory \"/tmp\")) (format t \"~a~%\" file))\n```\n```racket\n;; racket\n(for ([path (directory-list \"/etc\")])  (write-string    (path-\u003estring path)))\n```\n```clojure\n;; clojure\n; file-seq returns java.io.File objects for files\n; in arg directory and any subdirs recursively.\n(filter #(= (.getParent %) \"/etc\")  (file-seq (clojure.java.io/file \"/etc\")))\n```\n```emacs-lisp\n;; emacs-lisp\n(dolist  (file (directory-files \"/etc\"))  (print file)))\n```\n\n\n## Make Directory\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(make-directory* \"/tmp/foo/bar\")\n```\n```clojure\n;; clojure\n(require '[clojure.java.io :as io])\n(.mkdir (io/file \"/tmp/foo\"))\n```\n```emacs-lisp\n;; emacs-lisp\ncreates parents if 2nd arg non-nil:\n(make-directory \"/tmp/foo/bar\" t)\n```\n\n\n## Recursive Copy\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n(copy-directory/files \"/tmp/foo.d\"  \"/tmp/bar.d\")\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Remove Empty Directory\n\n```common-lisp\n;; common-lisp\n(delete-directory \"/tmp/foo.d\")\n```\n```racket\n;; racket\n(delete-directory \"/tmp/foo.d\")\n```\n```clojure\n;; clojure\n(clojure.java.io/delete-file \"/tmp/foo.d\")\n```\n```emacs-lisp\n;; emacs-lisp\n(delete-directory \"/tmp/foo.d\")\n```\n\n\n## Remove Directory And Contents\n\n```common-lisp\n;; common-lisp\n(osicat:delete-directory-and-files \"/tmp/foo.d\")\n```\n```racket\n;; racket\n(delete-directory/files \"/tmp/foo.d\")\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(delete-directory \"/tmp/foo.d\" t)\n```\n\n\n## Directory Test\n\n```common-lisp\n;; common-lisp\n(osicat:directory-exists-p #P\"/etc\")\n```\n```racket\n;; racket\n(directory-exists? \"/etc\")\n```\n```clojure\n;; clojure\n(.isDirectory (io/file \"/etc\"))\n```\n```emacs-lisp\n;; emacs-lisp\n(file-directory-p \"/etc\")\n```\n\n\n## Command Line Arguments\n\n```common-lisp\n;; common-lisp\n*posix-argv*\n```\n```racket\n;; racket\ncurrent-command-line-arguments\n```\n```clojure\n;; clojure\n*command-line-args*\n```\n```emacs-lisp\n;; emacs-lisp\nin shebang mode only:\ncommand-line-args or argv\n```\n\n\n## Program Name\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Environment Variables\n\n```common-lisp\n;; common-lisp\n(posix-getenv \"HOME\")\n```\n```racket\n;; racket\n(getenv \"HOME\")\n```\n```clojure\n;; clojure\n(System/getenv \"HOME\")\n```\n```emacs-lisp\n;; emacs-lisp\n(getenv \"HOME\")\n```\n\n\n## User Id And Name\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Exit\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## External Command\n\n```common-lisp\n;; common-lisp\n(run-program \"ls\" '( \"/etc\"))\n```\n```racket\n;; racket\n(require scheme/system)\n(system \"ls /etc\")\n```\n```clojure\n;; clojure\n(.exec (Runtime/getRuntime) \"ls\")\n```\n```emacs-lisp\n;; emacs-lisp\n(shell-command \"ls /etc\")\n```\n\n\n## Command Substitution\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n(shell-command-to-string \"ls /etc\")\n```\n\n\n## Complete Example\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n$ cat b/a.clj\n(ns b.a)\n(def x 3)\n$ java -cp clojure.jar:. clojure.main\n=\u003e (require 'b.a)\n=\u003e b.a/x\n3\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Compile Library\n\n```common-lisp\n;; common-lisp\n(compile-file \"a.lisp\")\n```\n```racket\n;; racket\n$ raco make a.rkt\n```\n```clojure\n;; clojure\n(compile 'a)\n```\n```emacs-lisp\n;; emacs-lisp\n$ emacs -batch -Q -L . \\  -f batch-byte-compile a.el\n```\n\n\n## Load Library\n\n```common-lisp\n;; common-lisp\n(load \"a.lisp\")\n```\n```racket\n;; racket\n(require a)\n```\n```clojure\n;; clojure\n(require 'a)\n```\n```emacs-lisp\n;; emacs-lisp\n(require \"a\")\n```\n\n\n## Load Library In Subdirectory\n\n```common-lisp\n;; common-lisp\n(load \"b/a.lisp\")\n```\n```racket\n;; racket\n(require \"b/a.rkt\")\n```\n```clojure\n;; clojure\n(require 'b.a)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Hot Patch\n\n```common-lisp\n;; common-lisp\n(load \"a.lisp\")\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(require 'b.a :reload)\n```\n```emacs-lisp\n;; emacs-lisp\n(load \"a\")\n```\n\n\n## Load Error\n\n```common-lisp\n;; common-lisp\nraises sb-int:simple-file-error\n```\n```racket\n;; racket\nraises exn:fail:syntax:missing-module. Because require must be top-level, the exception cannot be handled.\n```\n```clojure\n;; clojure\nraises FileNotFoundException\n```\n```emacs-lisp\n;; emacs-lisp\nraises file-err\n```\n\n\n## Library Path\n\n```common-lisp\n;; common-lisp\ncontains working directory at startup\n```\n```racket\n;; racket\n(require setup/dirs)\n(get-collects-search-dirs)\n```\n```clojure\n;; clojure\nsame as path used by java VM\n```\n```emacs-lisp\n;; emacs-lisp\n; adds directory to library path:\n(add-to-list 'load-path (\"/home/ed/.emacs.d/lib\"))\n```\n\n\n## Library Path Environment Variable\n\n```common-lisp\n;; common-lisp\nnone\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\nCLASSPATH\n```\n```emacs-lisp\n;; emacs-lisp\nEMACSLOADPATH\n```\n\n\n## Library Path Command Line Option\n\n```common-lisp\n;; common-lisp\nnone\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n$ java -cp /foo/bar:/baz/quux\n```\n```emacs-lisp\n;; emacs-lisp\n$ emacs -L /foo/bar\n```\n\n\n## Namespace Declaration\n\n```common-lisp\n;; common-lisp\n(defpackage :foo)\n```\n```racket\n;; racket\n(module mconst racket  (provide pi)  (define pi 3.14))\n```\n```clojure\n;; clojure\n(ns mconst)\n```\n```emacs-lisp\n;; emacs-lisp\nNo namespaces; a common convention is to use a prefix on all identifiers in a library, separated from the rest of the identifier by a hyphen.\n```\n\n\n## Subnamespace Declaration\n\n```common-lisp\n;; common-lisp\nnone\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n; must be in b/a.clj:\n(ns b.a)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Namespace Separator\n\n```common-lisp\n;; common-lisp\n:\n```\n```racket\n;; racket\n:\n```\n```clojure\n;; clojure\n. and /\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Import Definitions\n\n```common-lisp\n;; common-lisp\n; set current *package* to foo and import symbol twiddle from bar:\n(defpackage :foo  (:import-from :bar :twiddle))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Import All Definitions In Namespace\n\n```common-lisp\n;; common-lisp\n; set current *package* to foo and import symbols from bar:\n(defpackage :foo  (:use :bar))\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Namespace Shadow Avoidance\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Identifier Shadow Avoidance\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Package Manager Help\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n$ raco help\n$ raco pkg --help\n$ raco pkg install --help\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## List Installed Packages\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n$ raco pkg show --all\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nM-x list packages\n```\n\n\n## Search Packages\n\n```common-lisp\n;; common-lisp\n(ql:system-apropos \"time\")\n```\n```racket\n;; racket\nhttp://pkgs.racket-lang.org\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nM-x list-packages\n```\n\n\n## Install Package\n\n```common-lisp\n;; common-lisp\n; install quicklisp\n(load \"~/quicklisp/setup.lisp\")\n(ql:quickload \"osicat\")\n```\n```racket\n;; racket\n$ raco pkg install --deps search-auto srfi\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nUse M-x list-packages to bring up the package menu; i to select a package to install, and x to install it.\n```\n\n\n## Remove Package\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n$ raco pkg remove srfi\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\nIn the package menu, use d to select a package to uninstall and x to uninstall it.\n```\n\n\n## Define Class\n\n```common-lisp\n;; common-lisp\n(defclass rectangle ()  (    (height      :accessor rectangle-height      :initarg :height)    (width      :accessor rectangle-width      :initarg :width)))\n```\n```racket\n;; racket\n(define rectangle%  (class object%    (init width)    (init height)    (super-new)    (define curr-height height)    (define curr-width width)    (define/public (get-height)      curr-height)    (define/public (get-width)      curr-width)    (define/public (set-height ht)      (set! curr-height ht))    (define/public (set-width wd)      (set! curr-width wd))))\n```\n```clojure\n;; clojure\nuse java:\npublic class Rectangle {  public float height;  public float width;  public Rectangle(float h, float w) {    this.height = h;    this.width = w;  }  public void setHeight(float h) {    this.height = h;  }  public void setWidth(float w) {    this.width = w;\n}\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Make Instance\n\n```common-lisp\n;; common-lisp\n(make-instance 'rectangle  :height 3  :width 7)\n```\n```racket\n;; racket\n(define rect  (new rectangle    (height 7)    (width 3)))\n```\n```clojure\n;; clojure\n(import 'Rectangle)\n(def r (Rectangle. 7 3))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Read Attribute\n\n```common-lisp\n;; common-lisp\n(rectangle-height rect)\n```\n```racket\n;; racket\n(send rect get-height)\n```\n```clojure\n;; clojure\n(.height r)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Write Attribute\n\n```common-lisp\n;; common-lisp\n(setf (rectangle-height rect) 4)\n```\n```racket\n;; racket\n(send rect set-height 4)\n```\n```clojure\n;; clojure\n(.setHeight r 8)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Define Method\n\n```common-lisp\n;; common-lisp\n(defmethod area ((figure rectangle))  (* (rectangle-height figure)    (rectangle-width figure)))\n```\n```racket\n;; racket\n(define/public (area)  (* curr-height curr-width))\n```\n```clojure\n;; clojure\n(defmulti area class)\n(defmethod area Rectangle [r] (* (.height r) (.width r)))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Invoke Method\n\n```common-lisp\n;; common-lisp\n(area rect)\n```\n```racket\n;; racket\n(send rect area)\n```\n```clojure\n;; clojure\n(area r)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Universal Superclass\n\n```common-lisp\n;; common-lisp\nstandard-object t\n```\n```racket\n;; racket\nobject%\n```\n```clojure\n;; clojure\nObject\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Multiple Inheritance\n\n```common-lisp\n;; common-lisp\nyes\n```\n```racket\n;; racket\nno\n```\n```clojure\n;; clojure\nonly one direct superclass; can implement multiple interfaces\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Backquote And Comma\n\n```common-lisp\n;; common-lisp\n(setq op '+)\n(eval `(,op 1 1))\n```\n```racket\n;; racket\n(define op '+)\n(eval `(,op 1 1))\n(eval (quasiquote ((unquote op) 1 1)))\n```\n```clojure\n;; clojure\n(def op +)\n(eval `(,op 1 1))\n```\n```emacs-lisp\n;; emacs-lisp\n(setq op '+)\n(eval `(,op 1 1))\n```\n\n\n## Defmacro\n\n```common-lisp\n;; common-lisp\n(defmacro rpn (arg1 arg2 op)  (list op arg1 arg2))\n```\n```racket\n;; racket\n(define-syntax-rule (rpn arg1 arg2 op) (op arg1 arg2))\n```\n```clojure\n;; clojure\n(defmacro rpn [arg1 arg2 op]  (list op arg1 arg2))\n```\n```emacs-lisp\n;; emacs-lisp\n(defmacro rpn (arg1 arg2 op)  (list op arg1 arg2))\n```\n\n\n## Defmacro W Backquote\n\n```common-lisp\n;; common-lisp\n(defmacro rpn (arg1 arg2 op)  `(,op ,arg1 ,arg2))\n```\n```racket\n;; racket\n(define-syntax-rule (rpn3 arg1 arg2 op)  (eval ‘(,op ,arg1 ,arg2)))\n```\n```clojure\n;; clojure\n(defmacro rpn [arg1 arg2 op] `(~op ~arg1 ~arg2))\n```\n```emacs-lisp\n;; emacs-lisp\n(defmacro rpn (arg1 arg2 op)  `(,op ,arg1 ,arg2))\n```\n\n\n## Macro Predicate\n\n```common-lisp\n;; common-lisp\n(macro-function rpn)\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\nnone\n```\n```emacs-lisp\n;; emacs-lisp\nnone\n```\n\n\n## Macroexpand\n\n```common-lisp\n;; common-lisp\n(macroexpand ’(rpn 1 2 +))\n```\n```racket\n;; racket\n(syntax-object-\u003edatum (expand-to-top-form '(rpn 1 2 +)))\n```\n```clojure\n;; clojure\n(macroexpand '(rpn 1 2 +))\n```\n```emacs-lisp\n;; emacs-lisp\n(macroexpand '(rpn 1 2 +))\n```\n\n\n## Splice Quote\n\n```common-lisp\n;; common-lisp\n(defmacro add ( \u0026rest args )  `(+ ,@args))\n```\n```racket\n;; racket\n(define-syntax-rule ( add first …) (+ first …))\n```\n```clojure\n;; clojure\n(defmacro add [ \u0026 args ] `(+ ~@args))\n```\n```emacs-lisp\n;; emacs-lisp\n(defmacro add ( \u0026rest args )  `(+ ,@args))\n```\n\n\n## Recursive Macro\n\n```common-lisp\n;; common-lisp\n(defmacro add (a \u0026rest b)  `(if (null ',b)    (+ ,a)    (+ ,a (add ,@b))))\n```\n```racket\n;; racket\n(define-syntax add (syntax-rules ()  [(add x) x]  [(add x y) (+ x y)]  [(add x y …) (+ x (add y …))]))\n```\n```clojure\n;; clojure\n(defmacro add ([a] `(+ ~a)) ([a \u0026 b] `(+ ~a (add ~@b))))\n```\n```emacs-lisp\n;; emacs-lisp\n(defmacro add (a \u0026rest b)  `(if (null ',b)    (+ ,a)    (+ ,a (add ,@b))))\n```\n\n\n## Hygienic\n\n```common-lisp\n;; common-lisp\nno\n```\n```racket\n;; racket\nyes\n```\n```clojure\n;; clojure\nwith # suffix\n```\n```emacs-lisp\n;; emacs-lisp\nno\n```\n\n\n## Local Values\n\n```common-lisp\n;; common-lisp\n(defmacro square-sum (x y)  (let ((sum (gensym)))    `(let ((,sum (+ ,x ,y)))      (* ,sum ,sum))))\n```\n```racket\n;; racket\n(define-syntax-rule (square-sum x y)  (let ((sum (+ x y)))    (* sum sum)))\n```\n```clojure\n;; clojure\n(defmacro two-list [x] `(let [arg# ~x] (list arg# arg#)))\n```\n```emacs-lisp\n;; emacs-lisp\n(defmacro square-sum (x y)  (let ((sum (gensym)))    `(let ((,sum (+ ,x ,y)))      (* ,sum ,sum))))\n```\n\n\n## Inspect Type\n\n```common-lisp\n;; common-lisp\n(type-of '(1 2 3))\n(typep '(1 2 3) 'list)\n(listp '(1 2 3))\n```\n```racket\n;; racket\n(list? '(1 2 3))\n```\n```clojure\n;; clojure\n(= (type 1) java.lang.Long)\n(= (class 1) java.lang.Long)\n(integer? 1)\n```\n```emacs-lisp\n;; emacs-lisp\n(type-of [1 2 3] 'vector)\n(typep [1 2 3] 'vector)\n(vectorp [1 2 3])\n```\n\n\n## Instance Of\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\ninstance?\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Basic Types\n\n```common-lisp\n;; common-lisp\nlogical and numeric:\nbignum bit complex double-float fixnum float integer long-float nil null number ratio rational real short-float signed-btye single-float t unsigned-bytesymbols and strings:\nbase-character character extended-character keyword simple-string standard-char string symboldata structures:\narray atom bit-vector cons hash-table list sequence simple-array simple-bit-vector simple-vector vectorother:\ncompiled-function function package pathname random-state stream\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Sequence Data Types\n\n```common-lisp\n;; common-lisp\nlist vector\n```\n```racket\n;; racket\nlist vector hash-table string input-port range\n```\n```clojure\n;; clojure\nall collections and strings\n```\n```emacs-lisp\n;; emacs-lisp\nlist vector\n```\n\n\n## Get Docstring\n\n```common-lisp\n;; common-lisp\n(describe #'mapcar)\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(doc map)\n```\n```emacs-lisp\n;; emacs-lisp\n(describe-function 'mapcar)\n```\n\n\n## Define Function With Docstring\n\n```common-lisp\n;; common-lisp\n(defun add (x y)  \"add x and y\"  (+ x y))\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(defn add \"add x and y\" [x y]  (+ x y))\n```\n```emacs-lisp\n;; emacs-lisp\n(defun add (x y)  \"add x and y\"  (+ x y))\n```\n\n\n## Apropos And Documentation Search\n\n```common-lisp\n;; common-lisp\nnone\n```\n```racket\n;; racket\nnone\n```\n```clojure\n;; clojure\n(apropos #\"^add$\")\n(find-doc #\"add \\S+ and \\S+\")\n```\n```emacs-lisp\n;; emacs-lisp\n(apropos \"^add$\")none\n```\n\n\n## New\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(def rnd (new java.util.Random))\n(def rnd (java.util.Random.))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Method\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(. rnd nextFloat)\n(.nextFloat rnd)\n(. rnd nextInt 10)\n(.nextInt rnd 10)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Class Method\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(Math/sqrt 2)\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Chain\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## Import\n```common-lisp\n\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(import '(java.util Random))\n(def rnd (Random.))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n\n\n## To Java Array\n\n```common-lisp\n;; common-lisp\n\n```\n```racket\n;; racket\n\n```\n```clojure\n;; clojure\n(to-array '(1 2 3))\n(into-array Integer '(1 2 3))\n```\n```emacs-lisp\n;; emacs-lisp\n\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fxlisp%2Ffp-book","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fxlisp%2Ffp-book","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fxlisp%2Ffp-book/lists"}