【图文】JV-M-04-08_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
JV-M-04-08
上传于|0|0|文档简介
&&java ppt
大小：112.50KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢Lisp: Common Lisp, Racket, Clojure, Emacs Lisp - Hyperpolyglot
Lisp: Common Lisp, Racket, Clojure, Emacs Lisp
ca side-by-side reference sheet
Racket 6.1
Clojure 1.6
Emacs 24.5
$ sbcl --version
$ racket --version
displayed by repl on startup
$ emacs --version
common lisp
emacs lisp
$ raco make module.rkt
M-x byte-compile-file
(sb-ext:save-lisp-and-die
"executable"
:executable t
:toplevel 'function)
$ mzc —exe executable file
$ sbcl --script foo.lisp
$ racket -r foo.racket
specify full path to clojure jar:
java -cp clojure.jar clojure.main foo.clj
#!/usr/bin/env sbcl --script
#!/usr/bin/env racket --script
specify full path to clojure jar:
#!/usr/bin/env java -jar clojure.jar
#!/usr/bin/env emacs --script
$ java -jar /PATH/TO/clojure.jar
$ racket -e '(+ 1 1)'
whitespace
whitespace
whitespace and commas
whitespace
(+ 1 1) ; adding
(+ 1 1) ; adding
(+ 1 1) ; adding
(+ 1 1) ; adding
(+ 1 #| adding |# 1)
(+ 1 #| adding |# 1)
common lisp
emacs lisp
case insensitive, cannot start with digit
excluded characters:
SP ( ) " , ' ` : ; # | \
reserved for user macros:
? ! [ ] { }
case sensitive, cannot start with digit
excluded characters:
SP ( ) [ ] { } " , ' ` ; # | \
case sensitive, cannot start with digit
permitted characters:
A-Z a-z 0-9 * + ! - _ ?
these have special meaning or are reserved:
case sensitive, cannot start with digit
excluded characters:
SP ( ) " , ' ` ; # | \ _ [ ]
and escaped identifier
(setq |white space symbol| 3)
(setq white\ space\ symbol 3)
(define |white space symbol| 3)
(define white\ space\ symbol 3)
(setq white\ space\ symbol 3)
; parallel assignment:
(let ((x 3) (y 4))
; sequential assignment:
(let* ((x 3) (y (* x x)))
; parallel assignment:
(let ((x 3) (y 4))
; sequential assignment:
(let* ((x 3) (y (* x x)))
(let [x 3 y 4]
(let [[x y] [3 4]]
(let [x 3 y (* x x)]
; parallel assignment:
(lexical-let ((x 3) (y 4))
(lexical-let* ((x 3) (y (* x x)))
(defparameter *x* 3)
; doesn't change x if already set:
(defvar *x* 3)
(define x 3)
; y is not global:
(define (double z)
(define y 2)
(set 'x 3)
(setq x 3)
(makunbound 'x)
(namespace-undefine-variable! 'x)
(ns-unmap *ns* 'x)
(makunbound 'x)
; same value as null in Java:
(symbolp 'x)
(symbol? 'x)
(symbol? 'x)
(symbolp 'x)
identifier equality test
(eq 'x 'x)
(eq? 'x 'x)
(eq 'x 'x)
set, get, remove
(set 'x 13)
(setf (get 'x :desc) "unlucky")
(get 'x :desc)
(remprop 'x :desc)
; value must be instance of clojure.lang.IObj:
(def x (with-meta [13] {:desc "unlucky"}))
(get (meta x) :desc)
(set 'x 13)
(setf (get 'x :desc) "unlucky")
(get 'x :desc)
(remprop 'x :desc)
common lisp
emacs lisp
true false
true false
(or (not t) (and t nil))
(or (not #t) (and #t #f))
(or (not true) (and true false))
(or (not t) (and t nil))
= /= & & &= &=
= none & & &= &=
= not= & & &= &=
= /= & & &= &=
(min 1 2 3)
(max 1 2 3)
(min 1 2 3)
(max 1 2 3)
(min 1 2 3)
(max 1 2 3)
(min 1 2 3)
(max 1 2 3)
numberp integerp
rationalp floatp
realp complexp
number? integer?
rational? inexact?
real? complex?
number? integer?
rational? float?
numberp integerp
none floatp
+ - * / mod
+ - * / modulo
+ - * / mod
and remainder
(truncate 7 3)
(quotient 7 3)
(remainder 7 3)
(quot 7 3)
division-by-zero error
division by zero error
arith-error
(/ 7 (* 3 1.0))
(/ 7 (float 3))
(/ 7 (* 3 1.0))
integer quotient:
(/ 7 (* 3 1.0))
division-by-zero error
-1.0e+INF, -0.0e+NaN, or 1.0e+INF
(expt 2 32)
(expt 2 32)
returns float:
(Math/pow 2 32)
(expt 2 32)
(Math/sqrt 2)
#c(0.0 1.0)
(Math/sqrt -1): NaN
exp log sin cos tan asin acos atan atan
exp log sin cos tan asin acos atan atan
Math/exp Math/log Math/sin Math/cos Math/tan Math/asin Math/acos Math/atan Math/atan2
exp log sin cos tan asin acos atan atan
return two values, first is integer:
truncate round ceiling floor
return floats:
truncate round ceiling floor
return integers:
int Math/round
return floats:
Math/ceil Math/floor
truncate round ceiling floor
fround fceiling ffloor
truncate returns integer
and signum
abs signum
racket: sgn
Math/abs Math/signum
abs signum
arbitrary-precision integers
arbitrary-precision integers
clojure.lang.Numbers.throwIntOverflow exception
floating-point-overflow error
not literals:
-Infity NaN Infinity
; literal:
; literal:
; also rational:
; literal:
(numerator 3/7)
(denominator 3/7)
(numerator 3/7)
(denominator 3/7)
(numerator 3/7)
(denominator 3/7)
(realpart #c(1 2))
(imagpart #c(1 2))
(phase #c(1 2))
(abs #c(1 2))
(conjugate #c(1 2))
(real-part 1+2i)
(imag-part 1+2i)
(angle 1+2i)
(magnitude 1+2i)
(conjugate 1+2i)
uniform integer, uniform float, normal float
(random 100)
(random 1.0)
(random 100)
(def rnd (java.util.Random.))
(.nextInt rnd 100)
(.nextFloat rnd)
(.nextGaussian rnd)
(random 100)
(setq *random-state*
(sb-ext:seed-random-state 17))
(random-seed 17)
ash left shift when 2nd argument positive logand logior logxor lognot
arithmetic-shift left shift when 2nd argument positive bitwise-and bitwise-ior bitwise-xor bitwise-not
bit-shift-left bit-shift-right bit-and bit-or bit-xor bit-not
lsh left shift when 2nd argument positive logand logior logxor lognot
(format nil "~7r" 42)
common lisp
emacs lisp
(stringp "foo")
(string? "foo")
(string? "foo")
(stringp "foo")
\t \n \r \" \\ \ooo \uhhhh
\b \t \n \f \r \" \\ \ooo \uhhhh
\b \t \n \f \r \" \\ \ooo \uhhhh \xh - \xhhhhhh \C-x \M-x
(string #\f #\o #\o)
(string ?f ?o ?o)
(format nil "~a: ~a ~,2f" "Foo" 7 13.457)
(format "~a ~a ~a" "Foo" 7 13.457)
(String/format "%s: %d %.2f"
(to-array ["Foo" 7 13.457]))
(format "%s: %d %.2f" "Foo" 7 13.457)
any type, human readable
any time, read parseable
5 digits right of decimal mark
any type, human readable
any time, read parseable
(string= "foo" "bar")
(string& "foo" "bar")
(string=? "foo" "bar")
(string&? "foo" "bar")
(.equals "foo" "bar")
(.compareTo "foo" "bar")
(string= "foo" "bar")
(string& "foo" "bar")
(concatenate 'string "foo " "bar " "bar")
(string-append "foo " "bar " "baz")
(str "foo " "bar " "baz")
(concat "foo " "bar " "baz")
make-string 3 :initial-element #\f)
(make-string 3 #\f)
(String. (into-array
(. Character TYPE)
(repeat 3 \f)))
(make-string 3 ?f)
(string-downcase "FOO")
(string-upcase "foo")
(string-downcase "FOO")
(string-upcase "foo")
(.toLowerCase "FOO")
(downcase "FOO")
(upcase "foo")
; "Foo Bar":
(string-capitalize "foo bar")
; "Foo Bar":
(capitalize "foo")
(string-trim
'(#\space #\tab #\newline)
(require srfi/13/string)
(string-trim-both " foo ")
(.trim " foo ")
see notes for an implementation
on right, on left
(format nil "~10a" "foo")
(format nil "~10@a" "foo")
(concatenate 'string
(princ-to-string 8))
(string-append
(number-&string 8))
(str "Value: " 8)
(number-to-string 8))
(+ 7 (parse-integer "12"))
(+ 73.9 (read-from-string ".037"))
(+ 7 (string-&number "12"))
(+ 73.9 (string-&number ".037"))
(+ 7 (Integer/parseInt "12"))
(+ 73.9 (Float/parseFloat ".037"))
(+ 7 (string-to-number "12"))
(+ 73.9 (string-to-number ".037"))
(cl-ppcre:split
"[ \t\n]+"
"foo bar baz")
(regexp-split #rx"[ \n\t]+"
"foo bar baz")
(.split "foo bar baz"
"[ \t\n]+"))
(split-string "foo bar baz")
(lambda (m o)
(concatenate 'string m " " o))
'("foo" "bar" "baz"))
(string-join
'("foo" "bar" "baz")
(reduce #(str %1 " " %2)
'("foo" "bar" "baz"))
(lambda (m o) (concat m " " o))
'("foo" "bar" "baz"))
(length "foo")
(string-length "foo")
(.length "foo")
(length "foo")
(search "bar" "foo bar")
(require srfi/13/string)
(string-contains "foo bar" "bar")
(.indexOf "foo bar" "bar")
(search "bar" "foo bar")
(subseq "foo bar" 4 7)
(substring "foo bar" 4 7)
(.substring "foo bar" 4 7)
(substring "foo bar" 4 7)
#\a #\space #\newline #\backspace #\tab #\linefeed #\page #\return #\rubout
#\a #\space #\newline #\backspace #\tab #\linefeed #\page #\return #\nul #\vtab #\alarm #\esc #\delete
not in racket: #\alarm #\esc #\delete
\a \newline \space \backspace \tab ? \formfeed \return ?
?a ?\b ?\t ?\n ?\f ?\r ?\" ?\\ ?\ooo ?\uhhhh ?\xh - ?\xhhhhhh ?\C-x ?\M-x
(characterp #\x)
(alpha-char-p #\x)
(alphanumericp #\x)
(digit-char-p #\7)
(lower-case-p #\x)
(upper-case-p #\X)
(char? #\x)
(char? \x)
(characterp ?x)
(code-char 97)
(char-code #\a)
(integer-&char 97)
(char-&integer #\a)
(string-&list "foo")
(char "foo" 0)
(string-ref "foo" 0)
(.charAt "foo" 0)
(aref "foo" 0)
common lisp
emacs lisp
use a string:
"\\b\\d{5}\\b"
posix extended:
#rx"^[0-9][0-9][0-9][0-9][0-9]$"
(regexp "^[0-9][0-9][0-9][0-9][0-9]$")
perl style:
#px"\\b\\d{5}\\b"
(pregexp "\\b\\d{5}\\b")
#"\b\d{5}\b"
. \d \D \s \S \w \W
. \d \D \s \S \w \W
. \d \D \s \S \w \W
. \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.
^ $ \A \b \B \G \z \Z
(ql:quickload "cl-ppcre")
(if (cl-ppcre:all-matches "1999" s)
(format t "party!"))
(regexp-match #rx"bar" "foo bar")
(re-find #"bar" "foo bar")
(string-match "bar" "foo bar")
(regexp-match #px"(?i:lorem)" "Lorem")
(re-find #"(?i:lorem)" "Lorem")
(cl-ppcre:regex-replace "[^l]l"
(cl-ppcre:regex-replace-all "[^l]l"
"hello hello"
(regexp-replace #rx"el"
(regexp-replace* #rx"el"
"hello hello"
(.replaceFirst "hello" "[^l]l" "XX")
(.replaceAll "hello hello"
"[^l]l" "XX")
(replace-regexp-in-string "[^l]l"
"hello hello")
(match (regexp-match
#px"(\\d{4})-(\\d{2})-(\\d{2})"
[(list s yr mn dy) (list yr mn dy)])
(let [[_ yr mn dy]
(re-find #"(\d{4})-(\d{2})-(\d{2})"
(re-seq #"\w+" "dolor sit amet")
(regexp-match #px"(\\w+) \\1" "do do")
(regexp-replace #px"(\\w+) (\\w+)"
"\\2 \\1")
common lisp
emacs lisp
N 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
(get-decoded-time)
(require racket/date)
(current-date)
(def dt (new java.util.Date))
(current-time)
gray|; seconds since Jan 1, 1900:##
(get-universal-time)
(current-seconds)
(/ (System/currentTimeMillis) 1000.0)
(float-time)
(decode-universal-time
(get-unversal-time))
(seconds-&date (current-seconds))
(def dt (new java.util.Date
(System/currentTimeMillis)))
(seconds-to-time (float-time))
(encode-universal-time 0 22 10 31 5 2015)
(require racket/date)
(date-&seconds (current-date))
(/ (.getTime (new java.util.Date)) 1000.0)
(multiple-value-bind (b s)
(current-time)
(+ (* b (expt 2 16)) s))
(def s "yyyy-MM-dd HH:mm:ss")
(def fmt (new java.text.SimpleDateFormat s))
(.format fmt (new java.util.Date))
(format-time-string
"%Y-%m-%d %H:%M:%S"
(current-time))
(require (prefix-in s19. srfi/19))
(define (date-str-&unix-time s fmt)
(s19.time-second
(s19.date-&time-utc
(s19.string-&date s fmt))))
(date-str-&unix-time
" 07:06:00"
"~Y-~m-~d ~H:~M:~S")
(def s "yyyy-MM-dd HH:mm:ss")
(def fmt (new java.text.SimpleDateFormat s))
(.parse fmt " 09:14:14")
(multiple-value-bind
(ss mi hr dy mo yr)
(get-decoded-time)
(list ss mi hr) ; quiesce warning
(list dy mo yr))
(date-year (current-date))
(date-month (current-date))
(date-day (current-date))
(def cal (new java.util.GregorianCalendar))
(.setTime cal dt)
(.get cal java.util.Calendar/DAY_OF_MONTH)
(+ (.get cal java.util.Calendar/MONTH) 1)
(.get cal java.util.Calendar/YEAR)
(multiple-value-bind
(ss mi hr dy mo yr)
(decode-time (current-time))
(list dy mo yr))
(multiple-value-bind
(ss mi hr)
(get-decoded-time)
(list ss mi hr))
(date-hour (current-date))
(date-minute (current-date))
(date-second (current-date))
(def cal (new java.util.GregorianCalendar))
(.setTime cal dt)
(.get cal java.util.Calendar/HOUR_OF_DAY)
(.get cal java.util.Calendar/MINUTE)
(.get cal java.util.Calendar/SECOND)
(multiple-value-bind
(ss mi hr dy mo yr)
(decode-time (current-time))
(list ss mi hr))
(encode-universal-time 0 22 10 31 5 2015)
[yr 2015 mo 5 dy 31 hr 10 mi 22 ss 0]
(new java.util.GregorianCalendar
yr (- mo 1) dy hr mi ss)))
(encode-time 0 50 8 31 5 2015)
common lisp
emacs lisp
(quote (1 2 3))
(quote (1 2 3))
(quote (1 2 3))
(quote (1 2 3))
constructor
(list 1 2 3)
(list 1 2 3)
(list 1 2 3)
(list 1 2 3)
(listp '(1 2 3))
(list? '(1 2 3))
(list? '(1 2 3))
(listp '(1 2 3))
empty test
nil and '() are synonyms and evaluate as false in a boolean context. All other values are true.
(empty? '())
(empty? ())
nil and '() are synonyms and evaluate as false in a boolean context. All other values are true.
evaluating the empty list
(cons 1 '(2 3))
(cons 1 '(2 3))
(cons 1 '(2 3))
(cons 1 '(2 3))
(car '(1 2 3))
(first '(1 2 3))
(car '(1 2 3))
(first '(1 2 3))
(cdr '(1 2 3))
(rest '(1 2 3))
(cdr '(1 2 3))
(rest '(1 2 3))
(rest '(1 2 3))
(next '(1 2 3))
(cdr '(1 2 3))
(rest '(1 2 3))
head and tail of empty list
both evaluate to nil
both evaluate to nil
(length '(1 2 3))
(length '(1 2 3))
(count '(1 2 3))
(length '(1 2 3))
equality test
(equal '(1 2 3) '(1 2 3))
(equal? '(1 2 3) '(1 2 3))
(= '(1 2 3) '(1 2 3))
(equal '(1 2 3) '(1 2 3))
nth element
; indexed from zero:
(nth 2 '(1 2 3 4))
(list-ref '(1 2 3 4) 2)
(nth '(1 2 3 4) 2)
(nth 2 '(1 2 3 4))
out-of-bounds behavior
raises IndexOutOfBoundsException
element index
(position 7 '(5 6 7 8))
(require srfi/1)
(list-index (lambda (x) (= x 7)) '(5 6 7 8))
(position 7 '(5 6 7 8))
concatenate
(append '(1 2 3) '(4 5 6))
(append '(1 2 3) '(4 5 6))
(concat '(1 2 3) '(4 5 6))
(append '(1 2 3) '(4 5 6))
(take '(1 2 3 4) 2)
(take 2 '(1 2 3 4))
(subseq '(1 2 3 4) 0 2)
(nthcdr 2 '(1 2 3 4))
(drop '(1 2 3 4) 2)
(drop 2 '(1 2 3 4))
(nthcdr 2 '(1 2 3 4))
last element
(car (last '(1 2 3)))
(last '(1 2 3))
(last '(1 2 3))
(car (last '(1 2 3)))
all but last element
(butlast '(1 2 3))
(define a '(1 2 3))
(take a (- (length a) 1))
(butlast '(1 2 3))
(butlast '(1 2 3))
(reverse '(1 2 3))
(reverse '(1 2 3))
(reverse '(1 2 3))
(reverse '(1 2 3))
(sort '(3 2 4 1) '&)
(sort '(3 2 4 1) &)
(sort & '(3 2 4 1))
(sort '(3 2 4 1) '&)
(remove-duplicates '(1 1 2 3))
(remove-duplicates '(1 1 2 3))
(remove-duplicates '(1 1 2 3))
membership
(member 7 '(1 2 3))
(member 7 '(1 2 3))
(member 7 '(1 2 3)
(lambda (x) (* x x))
(map (lambda (x) (* x x)) '(1 2 3))
(map #(* % %) '(1 2 3))
(lambda (x) (* x x))
(remove-if-not
(lambda (x) (& x 2))
; remove-if returns complement
(lambda (x) (& x 2))
; filter-not returns complement
(filter #(& % 2) '(1 2 3))
; remove returns complement
(remove-if-not
(lambda (x) (& x 2))
; remove-if returns complement
(reduce '-
'(1 2 3 4)
:initial-value 0)
(foldl (lambda (x y) (- y x)) 0 '(1 2 3 4))
(reduce - 0 '(1 2 3 4))
(reduce '-
'(1 2 3 4)
:initial-value 0)
(reduce '-
'(1 2 3 4)
:initial-value 0
:from-end t)
(foldr - 0 '(1 2 3 4))
(reduce '-
'(1 2 3 4)
:initial-value 0
:from-end t)
(dolist (x '(1 2 3))
(print (- x)))
(for ((x '(1 2 3)))
(printf "~a~n" x)
(printf "~a~n" (- x)))
(doseq [x '(1 2 3)]
(println x)
(println (- x)))
(dolist (x '(1 2 3))
(print (- x)))
(lambda (i) (= 0 (rem i 2)))
'(1 2 3 4))
(for/and ((i '(1 2 3 4)))
(= 0 (remainder i 2)))
(every? #(= 0 (rem % 2)) '(1 2 3 4))
(lambda (i) (= 0 (% i 2)))
'(1 2 3 4))
(lambda (i) (= 0 (rem i 2)))
'(1 2 3 4))
(for/or ((i '(1 2 3 4)))
(= 0 (remainder i 2)))
(some #(= 0 (rem % 2)) '(1 2 3 4))
(lambda (i) (= 0 (% i 2)))
'(1 2 3 4))
list comprehension
(for*/list
((file "ABCDEFGH") (rank (in-range 1 9)))
(format "~a~a" file rank))
[file "ABCDEFGH" rank (range 1 9)]
(format "%c%d" file rank))
(shuffle '(1 2 3 4))
(shuffle '(1 2 3 4))
(defparameter *a* '(1 2 3))
(setf (car *a*) 3)
(require schema/mpair)
(define a (mlist 1 2 3))
(set-mcar! a 3)
(setq a '(1 2 3)
(setcar a 3)
(defparameter *a* '(1 2 3))
(setf (cdr *a*) '(4 5 6))
(require schema/mpair)
(define a (mlist 1 2 3))
(set-mcdr! a (mlist 4 5 6))
(setq a '(1 2 3)
(setcar a 3)
(setcdr a '(4 5 6))
manipulate back
(defparameter *a* '(1 2 3))
(push 4 *a*)
(setq a '(1 2 3))
(push 4 a)
(flatten '(1 2 (3 (4))))
(flatten '(1 2 (3 (4))))
associative array lookup
(assoc 3 '((1 2) (3 4)))
(assoc 3 '((1 2) (3 4)))
none, see note
(assoc 3 '((1 2) (3 4)))
flat associative array lookup
(getf '(1 2 3 4) 3)
(getf '(1 2 3 4) 3)
cons cell test
(cons '(1 . 2))
(not (atom '(1 . 2)))
(cons? '(1 . 2))
(pair? '(1 . 2))
(cons '(1 . 2))
(not (atom '(1 . 2)))
translate elements recursively
(sublis '((1 . 2) (3 . 4))
'(1 (3 3 (1))))
(sublis '((1 . 2) (3 . 4))
'(1 (3 3 (1))))
common lisp
emacs lisp
constructor
(vector 1 2 3)
(vector 1 2 3)
(vector 1 2 3)
(vector 1 2 3)
(length #(1 2 3))
(vector-length #(1 2 3))
(count [1 2 3])
(length [1 2 3])
(elt #(1 2 3) 0) or
(aref #(1 2 3) 0)
(vector-ref #(1 2 3) 0)
(nth [1 2 3] 0)
(elt [1 2 3] 0)
(setq v [1 2 3])
(setf (aref v 2) 4)
(define v (vector 1 2 3))
(vector-set! v 2 4)
(replace {2 4} [1 2 3])
(setq v #(1 2 3))
(setf (aref v 2) 4)
out-of-bounds behavior
raises sb-kernel:index-too-large-error
array to list
(coerce #(1 2 3) 'list)
(vector-&list #(1 2 3))
(seq [1 2 3])
(coerce [1 2 3] 'list)
list to array
(coerce '(1 2 3) 'vector)
(list-&vector '(1 2 3))
(vec '(1 2 3))
(coerce '(1 2 3) 'vector)
(reverse #(1 2 3))
(sort #(2 4 1 3) #'&)
(map 'vector (lambda (x) (* x x)) #(1 2 3))
(remove-if-not (lambda (x) (& x 2)) #(1 2 3))
; also remove-if
common lisp
emacs lisp
; immutable:
#hash(("t" . 1) ("f" . 0))
; clojure.lang.PersistentArrayMap:
{"t" 1 "f" 0}
(defparameter *h* (make-hash-table :test 'equal))
; default equality test is 'eql
(define ih
(make-immutable-hash
'(("t" . 1) ("f" . 0))))
; mutable:
(define h (make-hash '(("t" . 1) ("f" . 0))))
; immutable:
(def ih (hash-map "t" 1 "f" 0))
(setq h (make-hash-table :test 'equal))
(hash-table-p *h*)
; also true of assoc. lists and vectors:
(hash-table-p h)
(hash-table-count *h*)
(hash-count h)
; also works with assoc lists and vectors:
(dict-count ih)
(count ih)
(hash-table-count h)
(gethash "t" *h*)
(hash-ref h "t")
; return -1 if not found:
(hash-ref h "m" -1)
; also works with assoc. lists and vectors:
(dict-ref ih "t")
(dict-ref ih "m" -1)
(get ih "t")
(find ih "t")
; return -1 if not found:
(get ih "m" -1)
(gethash "t" h)
(setf (gethash "t" *h*) 1)
(hash-set! h "t" 2)
(define ih2 (hash-set ih "t" 2))
; also dict-set! and dict-set
(def ih2 (assoc ih "t" 2))
(puthash "t" 1 h)
returns nil
returns nil
returns nil
(nth-value 1 (gethash "t" *h*))
(hash-has-key? h "t")
; also dict-has-key?
(contains? ih "t")
(remhash "t" *h*)
(hash-remove! h "t")
(define ih2
(hash-remove ih "t"))
; also dict-remove! and dict-remove
(def ih2 (dissoc ih "t"))
(remhash "hello" h)
; values in ih2 take precedence:
(define ih3 (merge ih ih2))
(require 'clojure.set)
(define ih4 (clojure.set/map-invert ih))
(lambda (k v)
(print v))
(hash-for-each h
(lambda (k v)
(printf "~a~n" k)
(printf "~a~n" v)))
; also dict-for-each
(doseq [p ih]
(println (first p))
(println (second p)))
(lambda (k v)
(print v))
(hash-keys h)
(hash-values h)
; also dict-keys and dict-values
(def hkeys (map (fn [p] (first p)) ih))
(def hvals (map (fn [p] (second p)) ih))
common lisp
emacs lisp
(defstruct account id balance)
(define-struct account (id (balance #:mutable)))
(defstruct account :id :balance)
(defstruct account id balance)
(make-account
:balance 17.12))
(define a (make-account 3 17.12))
(def a (struct account 3 17.12))
(make-account :id 3 :balance 17.12))
(account-id a)
(account-id a)
(account-id a)
(setf (account-balance a) 0)
(set-account-balance! a 0)
(setf (account-balance a) 0)
(account-p a)
(account? a)
(account-p a)
common lisp
emacs lisp
(defun add (x y) (+ x y))
(define (add x y) (+ x y))
(defn add [x y] (+ x y))
(defun add (x y) (+ x y))
can function and variable share name
(defun add (a &optional b)
(if (null b) a (+ a b)))
(define (add a (b null))
(if (null? b) a (+ a b)))
(defn add ([a] a) ([a b] (+ a b)))
no syntax error if called with more than 2 args:
(defn add [a & [b]]
(if (nil? b) a (+ a b)))
(defun add (a &optional b)
(if (null b) a (+ a b)))
(defun add (a &rest b)
(if (null b)
(+ a (eval (cons '+ b)))))
(define (add a . b)
(if (null? b)
(+ a (apply + b))))
(defn add [a & b]
(if (nil? b) a (+ a (apply + b))))
(defun add (a &rest b)
(if (null b)
(+ a (eval (cons '+ b)))))
(defun add (a &optional (b 0))
(define (add a (b 0)) (+ a b))
([a] (add a 0))
([a b] (+ a b)))
(defun logarithm (&key number base)
(/ (log number) (log base)))
(logarithm :base 2 :number 8)
(defn logarithm [{x :number b :base}] (/ (Math/log x) (Math/log b)))
(logarithm {:base 2 :number 8})
(defun logarithm
(&key number &key base)
(/ (log number) (log base))
(log number)))
order significant, not key names:
(logarithm :foo 8 :bar 2)
(defun sqrts (x)
(values (sqrt x) (- (sqrt x))))
(define (sqrts x)
(values (sqrt x) (- (sqrt x))))
(defn sqrts [x] (list (Math/sqrt x) (- (Math/sqrt x))))
values creates a list:
(defun sqrts (x)
(values (sqrt x) (- (sqrt x))))
(multiple-value-bind (r1 r2)
(let-values
(((r1 r2) (sqrts 3)))
(let [[r1 r2] (sqrts 3)] r2)
(multiple-value-bind
(multiple-value-setq (r1 r2)
(sqrts 3))
(define-values (r1 r2) (sqrts 3))
(multiple-value-setq (r1 r2) (sqrts 3))
(values-list '(1 2 3))
(apply values '(1 2 3))
multiple values are lists
multiple values are lists
(multiple-value-list (sqrts 3))
(call-with-values
(lambda () (sqrts 3))
multiple values are lists
multiple values are lists
yes for sbcl
yes with recur
(lambda (x) (* x x))
(lambda (x) (* x x))
(fn [x] (* x x))
; shortcut notation with two args:
#(* %1 %2)
(lambda (x) (* x x))
((lambda (x) (* x x)) 2)
(apply #'(lambda (x) (* x x)) '(2))
((lambda (x) (* x x)) 2)
(apply (lambda (x) (* x x)) '(2))
(#(* % %) 2)
((fn [x] (* x x)) 2)
(apply #(* % %) '(2))
((lambda (x) (* x x)) 2)
#'(lambda (x) (* x x))
common lisp
emacs lisp
progn prog1 prog2
begin none none
begin begin0 none
do none none
progn prog1 prog2
(setq i 1)
(loop (print "hello")
(if (& i 10)
(setq i (+ i 1))))
none, use recursion
(loop [i 1]
(if (&= i 10)
(do (println "hello")
(recur (+ i 1)))))
(setq i 1)
(loop (print "hello")
(if (& i 10)
(setq i (+ i 1))))
(do ((i 1) (sum 0))
((& i 100) sum)
(setq sum (+ sum i))
(setq i (+ i 1)))
do* initializes serially
(do ((i 1) (sum 0))
((& i 100) sum)
(setq sum (+ sum i))
(setq i (+ i 1)))
do* initializes sequentially
(dotimes (i 10 nil)
(format t "hello~%"))
(dotimes [_ 10]
(println "hello"))
(dotimes (i 10 nil)
(print "hello\n"))
(if (& x 0) (- x) x)
(if (& x 0) (- x) x)
(if (& x 0) (- x) x)
(if (& x 0) (- x) x)
(when (& x y)
(print "x is less ")
(print "than y"))
(when (& x y)
(display "x is less ")
(display "than y"))
(when (& x y)
(println "x is less ")
(println "than y"))
(when (& x y)
(print "x is less ")
(print "than y"))
(cond ((& x 0) 1)
((= x 0) 0)
(cond ((& x 0) 1)
((= x 0) 0)
(else -1))
(cond (& x 0) 1
(cond ((& x 0) 1)
((= x 0) 0)
(define x (delay (/ 1 0)))
(promise? x)
(+ 1 (force x))
(define cc null)
(+ 1 (call/cc (lambda (x) (set! cc x) 0)))
common lisp
emacs lisp
(error "failed")
(error "failed")
(throw (Exception. "failed"))
(error "failed")
(handler-case
(error "failed")
(simple-error (e)
(format t "error: ~a" e)))
(with-handlers
((exn:fail?
(lambda (e)
(printf "error: ~a"
(exn-message e)))))
(error "failed"))
(try (throw (Exception. "failure"))
(catch Exception e
(printf "error: %s"
(.getMessage e))))
(condition-case e
(error "failed")
(error (message "error: %s"
(error-message-string e))))
(define-condition odd-err (error)
((num :accessor odd-err-num
:initarg :num))
(lambda (e s)
(format s "odd number: ~a"
(odd-err-num e)))))
(define exn:odd-err? "odd number")
only symbols and keywords can be thrown and caught
(error 'odd-err :num 7)
(raise exn:odd-err?)
(throw (Exception. "failed"))
(throw 'odd-err t)
(handler-case (/ 1 0)
(division-by-zero ()
(format t "division by zero")
(with-handlers ((exn:fail? (lambda (e) (begin (printf "division by zero~n") null)))) (/ 1 0))
(try (/ 1 0) (catch ArithmeticException _ (do (println "division by zero") nil)))
(catch 'failed (throw 'failed nil) t)
(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))
(handler-bind
(lambda (c)
(invoke-restart
'round-down))))
(halve '(1 2 4 9)))
(unwind-protect
(error "failure")
(print "clean up"))
(try (throw (Exception. "failure"))
(finally (println "clean up")))
(unwind-protect
(error "failure")
(print "clean up"))
common lisp
emacs lisp
*standard-input*
*standard-output*
*error-output*
(current-input-port)
(current-output-port)
(current-error-port)
read-line returns two values, the 2nd set to T at end-of-file.
EOF-OF-FILE is signaled when reading past end of file.
Returns the value eof.
Use eof-object? to test for it.
.readLine on a java.io.Reader object returns nil.
(setq line (read-line))
(let ((s (read-line)))
#|use s|#)
(let [s (read-line)]
(comment use s))
read-line discards newline
read-line discards newline
(defun println (s)
(format t "~a~%" s))
(println "hello")
(write-string s)
(println "hello")
(format t "~s ~d: ~2$~%"
(printf "~a ~a: ~a~n"
(/ (round (* 13.7 100)) 100))
(printf "%s %d %.2f\n" "foo" 7 13.7)
(setq in (open "/etc/hosts"))
((f (open-input-file "/etc/hosts")))
#| use f |#)
; f is java.io.Reader object:
(let [f (clojure.java.io/reader "/etc/hosts")]
(.readLine f))
(setq out (open "/tmp/test" :direction :output :if-exists :supersede))
((f (open-output-file
"/tmp/foo"
#:exists 'truncate)))
#| use f |#)
; f is java.io.Writer object:
(let [f (clojure.java.io/writer "/tmp/foo")]
(.write f "lorem ipsum\n")
(.close f))
(setq out (open "/tmp/test" :direction :output :if-exists :append))
((f (open-output-file
"/tmp/foo"
#:exists 'append)))
#| use f |#)
(let [f (clojure.java.io/writer "/tmp/foo"
:append true)]
(.write f "lorem ipsum\n")
(.close f))
(close in)
(close-input-port f)
(close-output-port f)
(.close f)
(with-open-file (out #P"/tmp/test" :direction :output) (write-line "lorem ipsum" out))
(call-with-input-file
"/etc/hosts"
(lambda (f) (#| use f |#))
; also call-with-output-file
(with-open [f
(clojure.java.io/reader "/etc/hosts")]
(comment use f))
(setq line (read-line f))
(define line (read-line in))
(.readLine f)
(for ([line (in-lines
(open-input-file
"/etc/hosts"))])
(write-string line)
(newline))
(loop [line (.readLine f)]
(if (not= line nil)
(do (println line)
(recur (.readLine f)))))
; to list of strings:
(sequence-&list (in-lines
(open-input-file "/etc/hosts")))
(vec (line-seq f))
(define s (file-&string "/etc/hosts"))
(let [s (slurp "/etc/hosts")]
(print s))
(write-string s f)
(.write f s)
(write-string s f)
(newline f)
(.write f (println-str s))
(flush-output f)
(f .flush)
; Evaluates to non-negative integer:
(file-position f)
; Sets next read or write
; to beginning of file:
(file-position f 0)
; arg is characters f
; moving backward not possible:
(.skip f 1000)
; arg is max characters to buffer:
(.mark f 1000000)
; move to position saved when .mark was called:
(setq f (make-string-input-stream
"lorem ipsum"))
(read-line f)
(setq f2 (make-string-output-stream)
(write-string "lorem ipsum)
(get-output-stream-string out)
(define f (open-input-string "lorem ipsum"))
(read-line f)
(define f2 (open-output-string))
(write-string "lorem ipsum" f2)
(get-output-string f2)
; use *in* to read from string:
(with-in-str "lorem ispum"
(read-line))
; use *out* to write to string:
(with-out-str
(println "lorem ipsum"))
emacs lisp
;; list of buffer objects:
(buffer-list)
;; name of first buffer in list:
(buffer-name (car (buffer-list)))
;; name of current buffer:
(buffer-name (current-buffer))
get and set
;; name of current buffer:
(buffer-name (current-buffer))
;; open in current pane:
(switch-to-buffer "foo.txt")
;; open in other pane:
(switch-to-buffer-other-window
"bar.txt")
;; current buffer:
(erase-buffer)
;; buffer named "foo.txt:
(with-current-buffer "foo.txt"
(erase-buffer))
get and set
;; 1-based index of char under cursor:
;; go to beginning of current buffer:
(goto-char 1)
;; go to end of current buffer:
(goto-char (buffer-size))
search and set point
;; Set point to character after string.
;; 1st arg is position in buffer beyond
which search stops.
;; If 2nd arg is true, return nil
on failure, otherwise raise error.
;; 3rd argument is the occurrence
of the string, if negative
search backwards from point.
(search-forward "lorem" nil t 1)
insert at string point
;; takes 1 or more args:
(insert "lorem" " ipsum")
current buffer as string
(buffer-string)
insert file contents at point
(insert-file "/etc/passwd")
get and set
;; to beginning of current buffer:
(set-mark 1)
;; to point of current buffer:
(set-mark (point))
common lisp
emacs lisp
(osicat:file-exists-p "/tmp/foo")
(osicat:regular-file-exists-p "/tmp/foo")
(file-exists? "/etc/hosts")
(.exists (io/file "/etc/hosts"))
(file-exists-p "/etc/hosts")
(file-regular-p "/etc/hosts")
(file-size "/etc/hosts")
(.length (io/file "/etc/hosts"))
(file-attributes "/etc/hosts"))
(pair? (filter
(lambda (x) (eq? x 'read))
(file-or-directory-permissions
"/etc/hosts")))
(pair? (filter
(lambda (x) (eq? x 'write))
(file-or-directory-permissions
"/etc/hosts")))
(pair? (filter
(lambda (x) (eq? x 'execute))
(file-or-directory-permissions
"/etc/hosts")))
(.canRead (io/file "/etc/hosts"))
(.canWrite (io/file "/etc/hosts"))
(.canExecute (io/file "/etc/hosts"))
(file-or-directory-permissions
"/tmp/foo"
(set-file-modes "/tmp/foo" #o755)
(file-or-directory-modify-seconds "/tmp/foo")
; Unix epoch in milliseconds:
(.lastModified (java.io.File. "/tmp/foo"))
(cl-fad:copy-file #P"/tmp/foo"
#P"/tmp/bar")
(delete-file #P"/tmp/foo")
(rename-file #P"/tmp/bar"
#P"/tmp/foo")
(copy-file "/tmp/foo" "/tmp/bar")
(delete-file "/tmp/foo")
(rename-file-or-directory
"/tmp/bar"
"/tmp/foo")
(clojure.java.io/copy
(java.io.File. "/tmp/foo")
(java.io.File. "/tmp/bar"))
(clojure.java.io/delete-file "/tmp/foo")
(.renameTo (java.io.File. "/tmp/bar")
(java.io.File. "/tmp/foo"))
(copy-file "/tmp/foo" "/tmp/bar")
(delete-file "/tmp/foo")
(rename-file "/tmp/bar" "/tmp/foo")
(osicat:make-link "/tmp/hosts" :target "/etc/hosts")
(make-file-or-directory-link
"/etc/hosts"
"/tmp/hosts")
(link-exists? "/tmp/hosts")
(make-symbolic-link "/etc/hosts" /tmp/hosts")
returns target if symlink or nil:
(file-symlink-p "/tmp/hosts")
(define tmp (make-temporary-file))
(path-&string tmp)
; java.io.File:
(java.io.File/createTempFile "foo" ".txt")
(make-temp-file "foo")
common lisp
emacs lisp
(make-pathname
:directory '(:absolute "etc")
:name "hosts")
; convert to string
; with path-&string:
(build-path "/etc" "hosts")
(require '[clojure.java.io :as io])
; returns java.io.F
; convert to string with .getPath:
(io/file "/etc" "hosts")
(pathname-directory #P"/etc/hosts")
(pathname-name #P"/etc/hosts")
(let-values (((dir file _)
(split-path "/etc/hosts")))
#| use dir or file |#)
(require '[clojure.java.io :as io])
(.getParent (io/file "/etc/hosts"))
(.getName (io/file "/etc/hosts"))
(file-name-directory "/etc/hosts")
(file-name-nondirectory
"/etc/hosts")
(simplify-path
(path-&complete-path ".."))
(.getCanonicalPath (java.io.File. ".."))
(expand-file-name "..")
(dolist (file (osicat:list-directory "/tmp")) (format t "~a~%" file))
(for ([path (directory-list "/etc")])
(write-string
(path-&string path)))
; file-seq returns java.io.File objects for files
; in arg directory and any subdirs recursively.
(filter #(= (.getParent %) "/etc")
(file-seq (clojure.java.io/file "/etc")))
(file (directory-files "/etc"))
(print file)))
(make-directory* "/tmp/foo/bar")
(require '[clojure.java.io :as io])
(.mkdir (io/file "/tmp/foo"))
creates parents if 2nd arg non-nil:
(make-directory "/tmp/foo/bar" t)
(copy-directory/files "/tmp/foo.d"
"/tmp/bar.d")
(delete-directory "/tmp/foo.d")
(delete-directory "/tmp/foo.d")
(clojure.java.io/delete-file "/tmp/foo.d")
(delete-directory "/tmp/foo.d")
(osicat:delete-directory-and-files "/tmp/foo.d")
(delete-directory/files "/tmp/foo.d")
(delete-directory "/tmp/foo.d" t)
(osicat:directory-exists-p #P"/etc")
(directory-exists? "/etc")
(.isDirectory (io/file "/etc"))
(file-directory-p "/etc")
common lisp
emacs lisp
*posix-argv*
current-command-line-arguments
*command-line-args*
in shebang mode only:
command-line-args or argv
(posix-getenv "HOME")
(getenv "HOME")
(System/getenv "HOME")
(getenv "HOME")
(run-program "ls" '( "/etc"))
(require scheme/system)
(system "ls /etc")
(.exec (Runtime/getRuntime) "ls")
(shell-command "ls /etc")
(shell-command-to-string "ls /etc")
common lisp
emacs lisp
complete example
$ cat b/a.clj
$ java -cp clojure.jar:. clojure.main
=& (require 'b.a)
compile library
(compile-file "a.lisp")
$ raco make a.rkt
(compile 'a)
$ emacs -batch -Q -L . \
-f batch-byte-compile a.el
load library
(load "a.lisp")
(require a)
(require 'a)
(require "a")
load library in subdirectory
(load "b/a.lisp")
(require "b/a.rkt")
(require 'b.a)
(load "a.lisp")
(require 'b.a :reload)
(load "a")
load error
raises sb-int:simple-file-error
raises exn:fail:syntax:missing-module. Because require must be top-level, the exception cannot be handled.
raises FileNotFoundException
raises file-err
library path
contains working directory at startup
(require setup/dirs)
(get-collects-search-dirs)
same as path used by java VM
; adds directory to library path:
(add-to-list 'load-path ("/home/ed/.emacs.d/lib"))
library path environment variable
EMACSLOADPATH
library path command line option
$ java -cp /foo/bar:/baz/quux
$ emacs -L /foo/bar
namespace declaration
(defpackage :foo)
(module mconst racket
(provide pi)
(define pi 3.14))
(ns mconst)
N a common convention is to use a prefix on all identifiers in a library, separated from the rest of the identifier by a hyphen.
subnamespace declaration
; must be in b/a.clj:
namespace separator
import definitions
; set current *package* to foo and import symbol twiddle from bar:
(defpackage :foo
(:import-from :bar :twiddle))
import all definitions in namespace
; set current *package* to foo and import symbols from bar:
(defpackage :foo
(:use :bar))
namespace shadow avoidance
identifier shadow avoidance
package manager help
$ raco help
$ raco pkg --help
$ raco pkg install --help
list installed packages
$ raco pkg show --all
M-x list packages
search packages
(ql:system-apropos "time")
M-x list-packages
install package
; install quicklisp
(load "~/quicklisp/setup.lisp")
(ql:quickload "osicat")
$ raco pkg install --deps search-auto srfi
Use M-x list-packages to bring i to select a package to install, and x to install it.
remove package
$ raco pkg remove srfi
In the package menu, use d to select a package to uninstall and x to uninstall it.
common lisp
emacs lisp
(defclass rectangle ()
:accessor rectangle-height
:initarg :height)
:accessor rectangle-width
:initarg :width)))
(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))))
public class Rectangle {
public Rectangle(float h, float w) {
this.height =
this.width =
public void setHeight(float h) {
this.height =
public void setWidth(float w) {
this.width =
(make-instance 'rectangle
(define rect
(new rectangle
(height 7)
(width 3)))
(import 'Rectangle)
(def r (Rectangle. 7 3))
(rectangle-height rect)
(send rect get-height)
(.height r)
(setf (rectangle-height rect) 4)
(send rect set-height 4)
(.setHeight r 8)
(defmethod area ((figure rectangle))
(* (rectangle-height figure)
(rectangle-width figure)))
(define/public (area)
(* curr-height curr-width))
(defmulti area class)
(defmethod area Rectangle [r] (* (.height r) (.width r)))
(area rect)
(send rect area)
standard-object t
only o can implement multiple interfaces
common lisp
emacs lisp
(setq op '+)
(eval `(,op 1 1))
(define op '+)
(eval `(,op 1 1))
(eval (quasiquote ((unquote op) 1 1)))
(def op +)
(eval `(,op 1 1))
(setq op '+)
(eval `(,op 1 1))
(defmacro rpn (arg1 arg2 op)
(list op arg1 arg2))
(define-syntax-rule (rpn arg1 arg2 op) (op arg1 arg2))
(defmacro rpn [arg1 arg2 op]
(list op arg1 arg2))
(defmacro rpn (arg1 arg2 op)
(list op arg1 arg2))
(defmacro rpn (arg1 arg2 op)
`(,op ,arg1 ,arg2))
(define-syntax-rule (rpn3 arg1 arg2 op)
(eval ‘(,op ,arg1 ,arg2)))
(defmacro rpn [arg1 arg2 op] `(~op ~arg1 ~arg2))
(defmacro rpn (arg1 arg2 op)
`(,op ,arg1 ,arg2))
(macro-function rpn)
(macroexpand ’(rpn 1 2 +))
(syntax-object-&datum (expand-to-top-form '(rpn 1 2 +)))
(macroexpand '(rpn 1 2 +))
(macroexpand '(rpn 1 2 +))
(defmacro add ( &rest args )
`(+ ,@args))
(define-syntax-rule ( add first …) (+ first …))
(defmacro add [ & args ] `(+ ~@args))
(defmacro add ( &rest args )
`(+ ,@args))
(defmacro add (a &rest b)
`(if (null ',b)
(+ ,a (add ,@b))))
(define-syntax add (syntax-rules ()
[(add x) x]
[(add x y) (+ x y)]
[(add x y …) (+ x (add y …))]))
(defmacro add ([a] `(+ ~a)) ([a & b] `(+ ~a (add ~@b))))
(defmacro add (a &rest b)
`(if (null ',b)
(+ ,a (add ,@b))))
with # suffix
(defmacro square-sum (x y)
(let ((sum (gensym)))
`(let ((,sum (+ ,x ,y)))
(* ,sum ,sum))))
(define-syntax-rule (square-sum x y)
(let ((sum (+ x y)))
(* sum sum)))
(defmacro two-list [x] `(let [arg# ~x] (list arg# arg#)))
(defmacro square-sum (x y)
(let ((sum (gensym)))
`(let ((,sum (+ ,x ,y)))
(* ,sum ,sum))))
common lisp
emacs lisp
inspect type
(type-of '(1 2 3))
(typep '(1 2 3) 'list)
(listp '(1 2 3))
(list? '(1 2 3))
(= (type 1) java.lang.Long)
(= (class 1) java.lang.Long)
(integer? 1)
(type-of [1 2 3] 'vector)
(typep [1 2 3] 'vector)
(vectorp [1 2 3])
instance-of
basic types
logical and numeric:
bignum bit complex double-float fixnum float integer long-float nil null number ratio rational real short-float signed-btye single-float t unsigned-byte
symbols and strings:
base-character character extended-character keyword simple-string standard-char string symbol
data structures:
array atom bit-vector cons hash-table list sequence simple-array simple-bit-vector simple-vector vector
compiled-function function package pathname random-state stream
list vector
list vector hash-table string input-port range
all collections and strings
list vector
(describe #'mapcar)
(describe-function 'mapcar)
(defun add (x y)
"add x and y"
(defn add "add x and y" [x y]
(defun add (x y)
"add x and y"
(apropos #"^add$")
(find-doc #"add \S+ and \S+")
(apropos "^add$")
common lisp
emacs lisp
(def rnd (new java.util.Random))
(def rnd (java.util.Random.))
(. rnd nextFloat)
(.nextFloat rnd)
(. rnd nextInt 10)
(.nextInt rnd 10)
(Math/sqrt 2)
(import '(java.util Random))
(def rnd (Random.))
(to-array '(1 2 3))
(into-array Integer '(1 2 3))
__________________________________________
__________________________________________
__________________________________________
__________________________________________
Versions used to verify examples in the reference sheet.
How to determine the version.
Compiling a.ss creates the byte-code compiled file a_ss.zo, which will be used by mzscheme in preference to the source code if it encounters
(require a)
In order for code to be compiled as a standalone executable, it must be packaged as a module. This can be accomplished by putting the #lang scheme shorthand the top of the file. All functions that are defined in the module will be executed in order. Here is a simple example:
#lang scheme
(define hello
(printf "Hello world!~n"))
How to interpret the code in a file.
How to have a script run by the interpreter automatically. Replace the given path with the path to the interpreter on your system.
emacs lisp
To run some lisp code from within emacs, use M-x load or M-x load-file. The first command will use the list of strings in load-path to search for the file. It is not necessary to specify the .el or .elc suffix if the file has one.
The following snippet is an emacs lisp shebang script implementation of cat:
#!/usr/bin/env emacs --script
(condition-case nil
(let (line)
(while (setq line (read-from-minibuffer ""))
(princ line)
(princ "\n")))
(error nil))
An implementation of echo:
#!/usr/bin/env emacs --script
(condition-case nil
(dotimes (i (length argv) nil)
(princ (nth i argv))
(princ " "))
(princ "\n"))
(error nil))
How to invoke the repl from the command line.
Racket also provides a GUI repl environment called DrRacket.
The clojure repl saves the result of each evaluation in the variables *1, *2, … and the last exception in *e.
How to pass in a program to be executed on the command line.
What is used to separate the operator and data of a S-expression.
In lisps other than clojure, any character can be used in a symbol. Some characters are special to the reader and must be escaped to include them in a symbol. The reader will interpret a sequence of characters starting with a digit as a number instead of a symbol, so escaping must be used to create such a symbol.
common lisp:
Common Lisp is case insensitive, and the reader converts all letters to upper case. A symbol consisting of just periods "." must be escaped. Symbols that start and end with an asterisk "*" may conflict with system defined special variables.
# is only disallowed by the reader at the beginning of symbols. A symbol consisting of a single period must be escaped.
#| |# delimited comments in Common Lisp and Scheme can span multiple lines, and thus can be used to comment out code.
Code with balanced parens can be commented out in the following manner:
Are identi which characters can be used in identifers.
In Lisp, identifiers are called symbols.
How to quote or escape characters in identifiers which are otherwise prohibited.
How to declare a local variable.
How to declare a global variable.
How to remove a variable.
The null value.
common lisp
nil and the empty list '() are identical.
null and the empty list '() are identical.
nil and the empty list '() are distinct.
emacs lisp
nil and the empty list '() are identical.
How to test whether a value is null.
How to get the value of an identifier.
In Lisp, identifiers are first class values and can be stored in variables. When used as an argument, the Lisp interpreter will treat an identifier as the value of the variable associated with the identifier unless special syntax is used.
How to test whether a value is an identifier.
A non-referential identifier is an identifier whose value is itself.
Non-referential identifiers are called keywords in Lisp. They also appear in Prolog, where they are called atoms, and Ruby, where they are called symbols.
A non-referential identifier can be convenient to use as a key in a dictionary, since it doesn't have to single quote escaped.
Strings are an alternative to non-ref some languages have string interning which makes the use of strings just as efficient as non-referential identifiers.
In Common Lisp, there is a dictionary of attributes associated with each identifier called a property list.
Clojure metadata is stored with a value which is an instance of clojure.lang.IObj. Many types are subclasses of clojure.lang.IObj, but integers, floats, and strings are not. Clojure metadata is immutable: all keys must be set at once and there is no way to remove keys.
cell types
The different cell types. A lisp-1 only stores a single entity under a symbol in a given environment. A lisp-2 stores multiple entities, and which entity a symbol will resolve to depends on how the symbol is used. In particular, a value and a function can be stored under the same symbol without collision.
nil, is () null?, is () symbol?
(eq nil ())
is true in common lisp and emacs lisp.
(eq? () null)
is true in Scheme.
Keywords are pre-defined symbols that evaluate to their printed representation. The reader recognizes them by the initial colon, or in the case of Scheme, by the initial "#:". In Scheme it is an error to use a keyword as an expression.
atom is is a predicate which returns false for cons cells, and true for anything else. All lists except for the empty list are cons cells.
Scheme lacks atom, but cons? is its logical negation.
Clojure lacks cons cells. Thus atom if implemented in the language would always return true. However, (not (list? x)) is closer to the spirit and certainly more useful. Because nil is not the empty list in clojure there is also ambiguity about what the value of (atom ()) would be.
All lisps have a single quote macro abbreviation for quote. Here are identical ways to quote a symbol and a list:
(quote (+ 3 7))
eval is a one-sided inverse of quote. If X is arbitrary lisp code, then the following are identical
(eval (quote X))
eq, equal, =
In his 1960 paper, McCarthy described eq as undefined if either or both arguments are not atomic. Common Lisp and Scheme (eq?) return true if the arguments both evaluate to the same list in memory, otherwise false. equal and equal? (Scheme) return true if the arguments evaluate to lists with the same elements as determined by calling equal or equal? recursively.
In Common Lisp and Scheme, = can only be called on numeric arguments. The predicates for whether a symbol is numeric are numberp and number?, respectively.
Clojure dispenses with eq and equal and defines = to be equivalent to the Common Lisp equal.
Because car and cdr are abbreviations for parts of the word of the IBM 704, there is a trend to replace them with first and rest. However, car and cdr are short, and convenient notation exists for abbreviating nested calls to car and cdr.
In terms of car, cdr, and combinations thereof, here is what the dialects define:
common lisp
emacs lisp
cadr,second
cadr,second
second,fnext
cadr,second
caddr,third
caddr,third
caddr,third
cadddr,fourth
cadddr,fourth
cadddr,fourth
common lisp
cdr and rest return nil when called on an empty list.
cdr and rest raise an error when called on an empty list.
rest returns an empty set () when called on an empty or singleton list, whereas next returns nil. In clojure, the empty set evaluates as true in a boolean context and nil evaluates as false.
Clojure does not implement a list as a linked list of cons cells. The second argument to cons must be a list.
(#(+ %1 %2) 1 2)
Common Lisp and Racket have arbitrary-precision integers and use them by default.
Racket provides the fixnum library for access to hardware integers:
(require racket/fixnum)
Operations on Racket fixnums cause an error when they overflow.
rationals and floats
Common Lisp and Racket have arbitrary-precision rationals. Racket uses them in a number of cases when Common Lisp uses hardware floats:
Racket provides the flonum library for access to hardware floats:
(require racket/flonum)
(fl* 3.1 -7.2)
complex numbers
Both the real and imaginary part of a Common Lisp complex number will have the same type, but the type can be integer, rational, or float.
Literals for true and false.
Values which evaluate to false in a boolean context.
null and the empty list {{'{} do not evaluate as false in a boolean context.
The logical operators.
Relational operators for performing comparisons.
Functions for returning the least and greatest of the arguments.
A selection of numeric predicates.
realp and real? are true of all numbers which have a zero imaginary component. floatp and inexact? are true if the number is being stored in a floating point representation.
The following all evaluate as #t:
(rational? 1.1)
(rational? (sqrt 2))
(rational? pi)
closure of integers under division
The number system that containing the potential results of integer division. In mathematics, the closure of integers under division is the rationals, and this is true for common lisp, scheme, and clojure as well.
Emacs lisp performs integer division (i.e. computes the quotient), so the closure of the integers under division is the integers.
In Lisp, + and * take zero or more arguments and - and / take one or more arguments. With zero arguments + and * return the additive and multiplicative identities 0 and 1. With one argument + and * return the argument and - and / return the additive and multiplicative inverses: i.e. the negation and the reciprocal. When evaluating 3 or more arguments - and / are computed from left to right: i.e. (- 3 4 5) is computed as (- (- 3 4) 5).
Math.pow returns a double.
Unary division (i.e. computing the reciprocal) generates a wrong number of arguments error.
For rounding, floor, and ceiling, the return value is integer if the argument is rational and floating point if the argument is floating point, unless otherwise noted.
inexact-&exact can be used to convert a float returned by round, ceiling, or floor to an integer.
Math/round always returns an integer and throws and error if called on a rational. Math/floor and Math/ceil can be called on a rational, but always return a float.
round, ceiling, and floor return integers. fround, fceiling, and ffloor return floats.
quotient and remainder
The value of (sqrt -2). Common lisp and Scheme support complex numbers. Clojure and Emacs Lisp do not.
decomposition of integer, rational, complex
For absolute value, the type of the return value is the same of the type of the argument.
The scheme/math library must be loaded to use sgn.
Math/signum only operates on a float and returns a float
How to generate a random integer, and a random float in a uniform and a normal distribution.
The bitwise operators implemented by Gambit and Racket are specified in the withdrawn standard .
Also has ash, which gives a different value when both arguments are negative.
character literals
The syntax for character literals. The first literal uses the letter "a" as an example of how to write a literal for all ASCII printing characters.
common lisp:
Characters are of type standard-char. The predicate is characterp.
The predicate is char?.
Characters are of type java.lang.Character.
Characters are of type integer and can be manipulated by arithmetic operators. characterp and integerp are synonyms.
string literal
The syntax for a string literal.
string escapes
A list of escape sequences that can be used in string literals.
emacs lisp:
The \x escape sequence is followed by one to six hex digits. Because a variable number of hex digits can be used, it may be necessary to indicate the end of the sequence with a backslash and a space, e.g. the following string literal is "λ123":
"\x3bb\ 123"
character access
How to get the character at a given position in a string.
find substring
Find the location of a substring in a string.
extract substring
constructors
comparison
common lisp:
Here is the complete list of string comparison functions:
There are also case insensitive versions of the above functions:
string-equal
string-lessp
string-greaterp
string-not-greaterp
string-not-lessp
string-not-equal
Case sensitive string comparison:
Case insensitive string comparison:
string-ci&=?
string-ci&?
string-ci=?
string-ci&=?
string-ci&?
emacs lisp:
Emacs has only these string comparison functions, all of which are case sensitive:
string-equal
string-lessp
string= and string-equal are synonyms, as are string& and string-lessp.
An implementation of trim:
(defun trim (s)
(let ((s1 (replace-regexp-in-string "[ \t]*$" "" s)))
(replace-regexp-in-string "^[ \t]*" "" s1)))
convert from string, to string
How to convert strings to numbers, and numbers to strings.
common lisp:
read-from-string invokes the reader, so the return value is not guaranteed to be a floating point number.
Here is a parse-float function which will convert all real numeric types to floats and raise a simple error if another condition is encountered.
(defun parse-float (s)
(let ((readval (handler-case
(read-from-string s)
(sb-int:simple-reader-error nil)
(end-of-file nil))))
(cond ((realp readval ) (+ readval 0.0))
(t (error (concatenate 'string "not a float: " s))))))
regular expressions
common lisp
emacs lisp
string-match returns the first index of the first matching substring, or nil.
The following code moves the point to next position following the point that matches the argument, and returns the index of the that position.
(re-search-forward "hello")
regex substitution
regex special characters
list literal
pair literal
(eval '())
A practical advantage of having (eval '()) be equal to '() is that the empty list doesn't have to be quoted.
list functions
nth and list-ref count from zero. nth returns nil if the index is too large. list-ref throws an error.
index of list element
How to get the index of a list element. The first element of a list has an index of zero.
last butlast
In clojure, last and butlast are analogs of first and rest which operate at the end of a list. If X is a list, then the following code pairs are identities:
(first (reverse X))
(butlast X)
(reverse (rest (reverse X)))
The analogy breaks down in Common Lisp because last returns a list with a single element.
set-car set-cdr
common lisp:
The following code pairs perform the same operation on the list:
(setf (car l) 3)
(rplaca l 3)
(setf (cdr l) '(4 5 6))
(rplacd l '(4 5 6))
However, they are not identical because rplaca and rplacd return the modified list instead of their 2nd argument.
Racket provides a separate interpreter plt-r5rs for an R5RS compliant version of Scheme. Also, the language can be set to R5RS within DrRacket.
emacs lisp:
Also has setf.
In Clojure, assoc returns a new association with the specified values replaced:
(def numbers {1 :one 2 :two 3 :three 4 :four})
(def jumble (assoc numbers 1 :uno 3 :drei 4 :quatre))
How to implement getf in Scheme:
(define (getf lst key (default null))
(cond ((null? lst) default)
((null? (cdr lst)) default)
((eq? (car lst) key) (cadr lst))
(else (getf (cddr lst) key default))))
common lisp
The lambda can accept multiple arguments:
(mapcar '+ '(1 2 3) '(4 5 6))
(map + '(1 2 3) '(4 5 6))
(map + '(1 2 3) '(4 5 6))
emacs lisp
mapcar does not accept multiple argument lambdas
common lisp
Also the negative version:
(remove-if (lambda (x) (& x 2)) '(1 2 3))
Also the negative version:
(remove #(& % 2) '(1 2 3))
emacs lisp
Also has negative version:
(remove-if (λ (x) (& x 2)) '(1 2 3))
reduce (left fold)
right fold
How to define foldr:
(defn foldr [f init list] (reduce #(f %2 %1) (reverse list)))
How to apply the mapping defined by an associative list to a recursive list.
Here is how to define take for common lisp or emacs lisp:
(defun take (n l)
(cond ((& n 0) (error "index negative"))
((= n 0) ())
((null l) (error "index too large"))
(t (cons (car l) (take (- n 1) (cdr l))))))
push and pop
Here is an implementation of push and pop in Racket using boxes:
(define (push x a-list)
(set-box! a-list (cons x (unbox a-list))))
(define (pop a-list)
(let ((result (first (unbox a-list))))
(set-box! a-list (rest (unbox a-list)))
Note the in clojure, pop only retur the original list is left unmodified.
vector literal
#(1 2 3) creates an immutable vect. (vector 1 2 3) creates a mutable vector.
vector access
set vector element
vector-set! throws an error if called on an immutable vector.
vector to list
list to vector
abstract sequence
Lists and vectors support the only difference is the speed at which the operations can be performed. It is a convenience for the developer if functions that perform the operation i.e. if lists and vectors are members of an abstract sequence type. Clojure has gone furthest in this direction, making all the customary list functions work on vectors as well. In common lisp and emacs lisp, some of the list functions also work on vectors, and some don't. In Scheme none of the list functions work on vectors.
sequence data types
The containers that respond to sequence functions.
sequence predicate
list functions usable on sequences
make-array
In Lisp terminology, both arrays and vectors refer to collections whi vectors are arrays with rank 1. Only common lisp supports arrays with rank greater than 1.
array access
set array element
array dimensions
array-rank returns the number of indices required to specify an element in the array. array-dimensions returns t the number of cells is the product of the elements of the list.
list comprehension
Lisp has a tradition of using lists of pairs for dictionaries. The data structures in this section are implemented using hash tables.
In addition to hash tables there are a set of functions which work with any dictionary type, which in Racket include hash tables, lists of cons cell pairs, and vectors. When a vector is treated as a dictionary, the value is an element and the key is the integer index of the element.
There are three dictionary types which can be used with the functions described in this section:
constructor
(hash-map "t" 1 "f" 0)
clojure.lang.PersistentHashMap
(array-map "t" 1 "f" 0)
clojure.lang.PersistentArrayMap
(zipmap '("t" "f") '(1 0))
clojure.lang.PersistentArrayMap
(sorted-map "t" 1 "f" 0)
clojure.lang.PersistentTreeMap
(sorted-map-by #(& %1 %2) "t" 1 "f" 0)
clojure.lang.PersistentTreeMap
The syntax for a dictionary literal.
The constructor for a dictionary.
The constructors use equal? to test for equality of the two keys.
There are also constructors which use eq? or eqv? to test keys: hasheq, hasheqv, make-immutable-hasheq, make-immutable-hasheqv.
How to test whether a value is a dictionary.
How to get the number of keys stored in the dictionary.
How to look up the value associated with a key.
How to insert a key-value pair or replace the value stored with an existing key.
What happens when a lookup is performed on a key not in the dictionary.
How to handle the error and return a null when the key is not found:
(with-handlers ((exn:fail? (lambda (e) null))) (get h "goodbye"))
How to check whether a key exists in a dictionary.
How to remove a key and its associated value from a dictionary.
How to merge two dictionaries.
How to turn a dictionary into its inverse. If a key 'foo' is mapped to value 'bar' by a dictionary, then its inverse will map the key 'bar' to the value 'foo'.
If multiple keys are mapped to the same value in the original dictionary, some of the keys will be discarded in the inverse.
How to iterate over the key-value pairs in a dictionary.
How to get the keys or the values in a dictionary as lists.
struct getter
struct setter
struct predicate
Traditionally let performs its assignments in parallel and let* serially.
In Clojure, let and let* are synonyms and both perform serial assignment.
Note that let uses dynamic scope. Use lexical-let for lexical scope:
ELISP& (let ((x 3)) (defun get-x () x))
ELISP& (get-x)
*** Eval error ***
Symbol's value as variable is void: x
ELISP& (let ((x 4)) (get-x))
ELISP& (lexical-let ((x 3)) (defun get-x-2 () x))
ELISP& (get-x-2)
ELISP& (lexical-let ((x 4)) (get-x-2))
define function
optional argument
variable number of arguments
default value
named parameter
common lisp:
In common lisp, named parameters are optional. Named values can be assigned default values:
(defun logarithm (&key number (base 10)) (/ (log number) (log base)))
If a named parameter is not provided at invocation and has not been assigned a default value, then it is set to nil.
emacs lisp:
In emacs lisp named parameters are mandatory. A runtime error results in they are not provided when the function is invoked.
tail call optimization
common lisp:
The ANSI Common Lisp specification does not require an implementation to perform tail call optimization.
How to get the documentation string for a function.
common lisp:
describe returns the documentation string with additional information such as the function signature. To get just the documentation string use this:
(documentation #'mapcar 'function)
How to define a function that has a documentation string.
How to search definitions and documentation.
Apropos takes a pattern and returns all defined symbol names which match the pattern.
apropos returns matching symbol names as a list.
find-doc searches all documentation strings and writes any which match to standard out.
Both apropos and find-doc can take a string or a regular expression as an argument.
emacs lisp:
apropos displays the documentation for matching definitions in the *Apropos* buffer. The argument is a string but will be treated as a regular expression.
progn and its equivalents in other dialects returns the value of the last expression. Common Lisp and Emacs Lisp also have prog1 and prog2 for returning the value of the 1st or 2nd expression.
handle error
Calling error raises an exception of type exn:fail
In the example:
(condition-case nil (error "failed") (error (message "caught error") nil))
the 2nd argument to condition-case is the code which might raise an error, and the 3rd argument is the error handler. The error handler starts with condition to be caught. The last nil is the return value of the entire condition-case expression.
An error cannot be handled by catch. An uncaught throw will generate an error, which can be handled by a condition-case error handler.
define exception
How to define a custom exception with a payload.
common lisp:
The :report clause is not necessary. If defined it will be displayed if the exception is handled by the lisp debugger.
throw exception
The 1st argument of an emacs throw expression identifies the type of exception, and the 2nd argument will be the return value of the catch expression that catches the exception.
catch exception
The following catch expression will return nil:
(catch 'failed (throw 'failed nil) t)
restart case
invoke restart
finally clause
Kent Pitman
Dorai Sitiram
Here is an optional technique for making sure that a file handle is closed:
(with-open [#^PrintWriter w (writer f)] (.print w content))
lazy evaluation
continuations
printf prints to stdout. format returns a string.
emacs lisp
The format statement returns the generated string. When used for i/o, it prints in the emacs minibuffer.
How to build a file pathname from components.
How to extract the directory p how to extract the non-directory portion.
How to get the get the absolute pathname for a pathname. If the pathname is relative the current working directory will be appended.
How to iterate over the files in a directory.
How to create a directory, including any parents directories specified in the path.
How to copy a directory and its contents.
How to remove an empty directory.
How to remove a directory and its contents.
How to test whether a directory exists.
external command
command line arguments
The global variables command-line-args and argv are set when emacs is run in shebang mode: i.e. with the —script option. command-line-args contains the pathname used to invoke emacs, as well as any options processed by emacs at startup, in addition to any additional arguments. argv only contains the additional arguments.
environment variables
loading a file
How to load a file and evaluate the top level expressions.
common lisp
Does not display the result of any evaluations.
Displays the result of the last evaluation.
loading a library
define class
make instance
read attribute
write attribute
define method
invoke method
define subclass
universal superclass
multiple inheritance
backquote and comma
defmacro-backquote
macro predicate
macroexpand
macroexpand recursively expands a sexp until the head is no longer a macro. It does not expand arguments that are macros.
common lisp
Common lisp also has macroexpand-1, which will non-recursively expand a macro once. The head of the expansion may thus be a macro.
Clojure also has macroexpand-1. See above for an example of use.
emacs lisp
Emacs has macroexpand-all, which will recursively expand a sexp until head and arguments are free of macros.
splice quote
recursive macro
Does the language have macros whose expansions are guaranteed not to introduce name collisions.
local values
How to get the data type of the entity referred to by a symbol.
version used on jvm
extra libraries used
The srfi-1 library brings in a common list functions which Kawa does not make available by default. See .
class method
to java array
For a package manager we use Quicklisp. Here is how to install it and use it to load the cl-ppcre library:
$ curl -O http://beta.quicklisp.org/quicklisp.lisp
* (load "quicklisp.lisp")
* (quicklisp-quickstart:install)
* (ql:quickload "cl-ppcre")
* (cl-ppcre:all-matches "foo" "foo bar")
Quicklisp creates a quicklisp directory in the user's home directory. Once quicklisp is downloaded and installed, it can be used like this:
* (load "~/quicklisp/setup.lisp")
* (ql:quickload "cl-ppcre")
* (cl-ppcre:all-matches "foo" "foo bar")
One can ensure that Quicklisp is automatically loaded at startup by putting the load command into the .sbclrc file:
$ cat ~/.sbclrc
(load "~/quicklisp/setup.lisp")
Racket ships with a large number of libraries in the collects directory of the installation which can be loaded with the require command, which takes a raw symbol which is the relative pathname from the collects directory to the file, not including the .rkt suffix. The Racket 5.1 distribution includes 50 SRFI libraries.
Racket also has a built in package management system. Browse the . To install a package, click through to the detail page for the package and get the require string to load it. If the require string is executed by Racket, the library will be downloaded somewhere in the user's home directory. When I ran this on my Mac
& (require (planet "spgsql.rkt" ("schematics" "spgsql.plt" 2 3)))
the files for the PostgreSQL database bindings were installed in ~/Library/Racket.
Calling Java
Here are the basics of calling Java code:
(def rnd (new java.util.Random)) create Java object
(. rnd nextFloat) invoke method on object
(. rnd nextInt 10) invoke method with argument
(. Math PI) static member
(import '(java.util Random)) import
Clojure automatically imports everything in java.lang.
There are shortcuts for the above syntax:
(new Random)
(. Math PI)
(.nextInt rnd)
(. rnd nextInt)
Because they are primitive types and not objects, Clojure provides functions specific to Java arrays:
(mak}