@@ -7,107 +7,116 @@ <h1 class="title">Snippets</h1>
77</ header >
88< p > One of the great resources we can have as developers is snippets and example code to understand how the idiom of a language is spoken and written.</ p >
99< h3 id ="defining-a-function "> Defining a function:</ h3 >
10- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class ="kw "> defun</ span > < span class ="fu "> function-name </ span > (param1 param2 &key (keyword1 default-value))
11- < span class ="co "> ;; keywords are optional; optional positional parameters are also available. </ span >
12- < span class ="co "> ;; implicit progn</ span >
13- )</ code > </ pre >
10+ < pre class ="sourceCode lisp "> < code class ="sourceCode lisp "> (defun function-name (param1 param2 &key (keyword1 default-value))
11+ ;; keywords are optional; optional positional parameters are also available.
12+ ;; implicit progn
13+ )
14+ </ code > </ pre >
15+ 1416< h3 id ="defining-a-method-on-a-type "> Defining a method on a type:</ h3 >
15- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class =" kw " > defmethod</ span > < span class =" fu " > method-name </ span > ((param1 < span class =" kw " > class -name</ span > ))
16- < span class =" co " > ;; implicit progn</ span >
17+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defmethodmethod-name ((param1 class-name))
18+ ;; implicit progn
1719 )</ code > </ pre >
20+ 1821< h3 id ="defining-a-class "> Defining a class</ h3 >
1922< p > Note that < code > DEFCLASS</ code > accessor functions for slots can be < code > SETF</ code > ’d and serve as both getters and setters for the slot.</ p >
2023< p > < code > :INITARG</ code > is the keyword used in < code > MAKE-INSTANCE</ code > to denote the value of the initial argument (see below).</ p >
2124< p > < code > :INITFORM</ code > is the form used to initialize the slot. Without this, it defaults to < code > nil</ code > . I favor using < code > nil</ code > , < code > 0</ code > , < code > ""</ code > , or < code > (error "You must set slot <slotname> to a value")</ code > as the usual initform set.</ p >
2225< p > Note that < code > (:documentation ...)</ code > is the standard documentation mechanism, which can be viewed in the running image with < code > DESCRIBE</ code > (at least in SBCL).</ p >
23- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp ">
24- < span class =" co " > ;; no superclass, no slots.</ span >
25- (< span class =" kw " > defclass</ span > < span class =" fu " > superclass-1 </ span > < span class =" kw " > nil</ span > < span class =" kw " > nil</ span > )
26+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode lisp ">
27+ ;; no superclass, no slots.
28+ (defclasssuperclass-1 nilnil)
2629
27- (< span class =" kw " > defclass</ span > < span class =" fu " > my-class </ span > (superclass< span class =" dv " > -1 </ span > )
30+ (defclassmy-class (superclass-1 )
2831 ((variable
2932 :accessor accessor-function
3033 :initarg :variable
3134 :initform form-for-initializition.)
3235 another-variable)
33- (:documentation < span class ="st "> "a class snippet!"</ span > ))</ code > </ pre >
36+ (:documentation "a class snippet!"))</ code > </ pre >
37+ 3438< h3 id ="creating-an-instance "> Creating an instance</ h3 >
35- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class ="kw "> make-instance</ span > 'my-class :variable value)</ code > </ pre >
39+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode lisp "> (make-instance 'my-class :variable value)</ code > </ pre >
40+ 3641< h3 id ="adding-a-constructor "> Adding a constructor</ h3 >
3742< p > This function runs after the instance is initialized.</ p >
38- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class ="kw "> defmethod</ span > < span class ="fu "> initialize-instance </ span > :after ((obj my-class) &key)
39- (< span class ="kw "> setf</ span > (accessor-function obj) < span class ="dv "> 10</ span > ))</ code > </ pre >
43+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defmethod initialize-instance :after ((obj my-class) &key)
44+ (setf (accessor-function obj) 10))</ code > </ pre >
45+ 4046< h3 id ="defining-a-constant "> Defining a constant:</ h3 >
4147< p > Note that the convention is that constants are surrounded with +</ p >
42- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class ="kw "> defconstant</ span > < span class ="fu "> +name+ </ span > value < span class ="st "> "docstring"</ span > )</ code > </ pre >
48+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defconstant +name+ value "docstring")</ code > </ pre >
49+ 4350< h3 id ="defining-a-global-variable "> Defining a global variable:</ h3 >
4451< p > Note that the convention is that globals are surrounded with *</ p >
45- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class ="kw "> defparameter</ span > < span class ="fu "> *name* </ span > value < span class ="st "> "docstring"</ span > )</ code > </ pre >
52+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defparameter *name* value "docstring")</ code > </ pre >
53+ 4654< h3 id ="creating-local-variables. "> Creating local variables.</ h3 >
47- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class =" kw " > let</ span > ((variable1 value-form)
55+ < pre class ="sourceCode lisp "> < code class ="sourceCode lisp "> (let ((variable1 value-form)
4856 (variable2 value-again))
49- < span class =" co " > ;; implicit progn where variable[12] are valid</ span >
57+ ;; implicit progn where variable[12] are valid</ span >
5058 )</ code > </ pre >
59+ 5160< h3 id ="loop "> LOOP</ h3 >
5261< p > LOOP is a contentious form in Common Lisp: some people love its imperative style, others hate it. Regardless, its really handy! Here are my favorite LOOPs</ p >
5362< pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp ">
54- (< span class =" kw " > loop</ span > for i from < span class =" dv " > 0 </ span > upto < span class =" dv " > 10 </ span >
63+ (loop for i from 0 upto 10
5564 collect i)
5665
57- (< span class =" kw " > loop</ span > for i from < span class =" dv " > 0 </ span > below < span class =" dv " > 10 </ span >
66+ (loop for i from 0 below 10
5867 collect i)
5968
60- (< span class =" kw " > loop</ span > for i from < span class =" dv " > 0 </ span > upto < span class =" dv " > 10 </ span >
61- < span class =" kw " > do </ span >
69+ (loop for i from 0 upto 10
70+ do
6271 (side-effect i))
6372
64- (< span class =" kw " > loop</ span > for ele in < span class =" kw " > list</ span >
73+ (loop for ele in list
6574 collect
6675 (operate-on ele))
6776
68- (< span class =" kw " > loop</ span > for ele across < span class =" kw " > array</ span >
77+ (loop for ele across array
6978 collect
7079 (operate-on ele))</ code > </ pre >
7180< h3 id ="lambda-functions "> Lambda functions</ h3 >
7281< p > The lambda functions is an anonymous function, i.e., unnamed.</ p >
7382< p > Here we map over < code > numeric-list</ code > and increment each element in it by 1 with < code > 1+</ code > , returning the incremented list.</ p >
7483< pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp ">
75- (< span class =" kw " > mapcar</ span >
76- #'(< span class =" kw " > lambda</ span > (x)
77- (< span class =" kw " > 1+ </ span > x))
84+ (mapcar
85+ #'(lambda (x)
86+ (1+ x))
7887 numeric-list)</ code > </ pre >
7988< h3 id ="macro "> Macro</ h3 >
8089< p > Note that Lisp macros should be used with care: they read source code and emit source code.</ p >
81- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class =" kw " > defmacro</ span > < span class =" fu " > with-resource </ span > ((resource) &body body)
90+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defmacrowith-resource ((resource) &body body)
8291 (allocate-resource ,resource)
83- (< span class =" kw " > unwind-protect</ span >
84- (< span class =" kw " > progn</ span >
92+ (unwind-protect
93+ (progn
8594 ,@body)
8695 (deallocate-resource ,resource)))</ code > </ pre >
8796< p > See < a href ="http://www.lispworks.com/documentation/HyperSpec/Body/s_unwind.htm "> UNWIND-PROTECT</ a > for details on this very useful form.</ p >
8897< h3 id ="writing-a-text-file "> Writing a text file</ h3 >
8998< p > More complete reading and writing of text files can be done by using the ALEXANDRIA library; these routines are great for starting to customize your own routine.</ p >
90- < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (< span class =" kw " > defun</ span > < span class =" fu " > write-file </ span > (filename data)
91- (< span class =" kw " > with-open-file</ span > ( < span class =" kw " > stream</ span >
99+ < pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp "> (defunwrite-file (filename data)
100+ (with-open-file ( stream
92101 filename
93- < span class =" kw " > :direction</ span > < span class =" kw " > :output</ span >
94- :if-exists < span class =" kw " > :supersede</ span >
95- :if-does-not-exist < span class =" kw " > :create</ span > )
96- (< span class =" kw " > write-sequence</ span >
102+ :direction:output
103+ :if-exists :supersede
104+ :if-does-not-exist :create)
105+ (write-sequence
97106 data
98- < span class =" kw " > stream</ span > )))</ code > </ pre >
107+ stream)))</ code > </ pre >
99108< h3 id ="reading-a-text-file "> Reading a text file</ h3 >
100109< pre class ="sourceCode commonlisp "> < code class ="sourceCode commonlisp ">
101- (< span class =" kw " > defun</ span > < span class =" fu " > read-file </ span > (filename)
102- < span class =" st " > "Reads `filename` as a sequence of unsigned 8-bit bytes, no</ span >
103- < span class =" st " > encoding"</ span >
104- (< span class =" kw " > with-open-file</ span > (fin filename
105- < span class =" kw " > :direction</ span > < span class =" kw " > :input</ span >
106- :if-does-not-exist < span class =" kw " > :error</ span > )
107- (< span class =" kw " > let</ span > ((seq (< span class =" kw " > make-array</ span > ( < span class =" kw " > file-length</ span > fin)
108- :fill-pointer < span class =" kw " > t </ span > )))
109- (< span class =" kw " > setf</ span > ( < span class =" kw " > fill-pointer</ span > seq)
110- (< span class =" kw " > read-sequence</ span > seq fin))
110+ (defunread-file (filename)
111+ "Reads `filename` as a sequence of unsigned 8-bit bytes, no
112+ encoding"
113+ (with-open-file (fin filename
114+ :direction:input
115+ :if-does-not-exist :error)
116+ (let ((seq (make-array ( file-length fin)
117+ :fill-pointer t )))
118+ (setf ( fill-pointer seq)
119+ (read-sequence seq fin))
111120 seq)))</ code > </ pre >
112121< p > Please feel free to contribute your examples or library information to this page! Send in those pull requests and file those bugs!</ p >
113122< hr />
0 commit comments