PageRenderTime 49ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/scheme/man/Yet Another Scheme Tutorial/www.shido.info/lisp/scheme3_e.html

http://zhangpengpeng.googlecode.com/
HTML | 286 lines | 239 code | 47 blank | 0 comment | 0 complexity | fc390ca5664de3f278d8d94d6fde8d4c MD5 | raw file
    

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    2. 

  2. 

  3. <html lang="en">
    4. 

  4. <head>
    5. 

  5. <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    6. 

  6. <meta name="Author" content="Takafumi Shido">
    7. 

  7. <meta name="keywords" content="Scheme, lists">
    8. 

  8. <meta name="description" content="List operations on Scheme">
    9. 

  9. <meta http-equiv="CONTENT-SCRIPT-TYPE"  content="text/css;">
    10. 

  10. <meta name="robots" content="all">
    11. 

  11. <link rel="stylesheet" href="../shido_e.css" text="text/css">
    12. 

  12. <link rel="icon" href="http://www.shido.info/images/shido.png" type="image/png">
    13. 

  13. <title> 3. Making Lists </title>
    14. 

  14. </head>
    15. 

  15. <body>
    16. 

  16. <a name="top"></a>
    17. 

  17. <p class="header">
    18. 

  18. <table class='guide'><tr>
    19. 

  19. <td><a rel=home href='http://www.shido.info/index_e.php'>
    20. 

  20.   <img src='../images/shido_small.png' class='arrow' border=0>HOME</a></td>
    21. 

  21. <td><a rel=prev href="scheme2_e.html"><img src='../images/left_arrow.gif' class='arrow' border=0>
    22. 

  22.   2. Using Scheme as a Calculator</a></td>
    23. 

  23. <td><a rel=up href="idx_scm_e.html"><img src='../images/up_arrow.gif' class='arrow' border=0>Yet Another Scheme Tutorial</a></td>
    24. 

  24. <td><a rel=next href="scheme4_e.html"><img src='../images/right_arrow.gif' class='arrow' border=0>4. Defining Functions</a></td>
    25. 

  25. <td><a href='http://www.shido.info/gb/write_guestbook_e.php?ref=lisp/scheme3_e.html&amp;t=%28Scheme%29+Making+Lists' target='new'>
    26. 

  26. <img src='../images/pencil.gif' class='arrow' border=0>Post Messages</a></td>
    27. 

  27. </tr></table></p>
    28. 

  28. 

  29. <h1> 3. Making Lists </h1>
    30. 

  30. <hr>
    31. 

  31. <h2>1. Introduction </h2>
    32. 

  32. As Scheme belongs to Lisp linguistic family, it is good at list operations.
    33. 

  33. You should understand lists and list operations thoroughly to master Scheme.
    34. 

  34. Lists play important roles in recursive functions and higher order functions,
    35. 

  35. which I will explain in later chapters.
    36. 

  36. <p>
    37. 

  37. 

  38. In this chapter, I will explain basic list operators, such as
    39. 

  39. <span class='ttb'>cons</span>, <span class='ttb'>car</span>,
    40. 

  40.   <span class='ttb'>cdr</span>, <span class='ttb'>list</span>
    41. 

  41. and <span class='ttb'>quote</span>.
    42. 

  42. 

  43. <h2>2. Cons Cells and Lists</h2>
    44. 

  44. <a name='cons'>
    45. 

  45. <h3>2.1. Cons Cells</h3>
    46. 

  46. First, let me explain about <b>cons cells</b> which are elements of lists.
    47. 

  47. Cons cells are a memory spaces which storage two addresses.
    48. 

  48. Cons cells can be made by function <span class='ttb'>cons</span>.<p>
    49. 

  49. 

  50. Give <tt>(cons 1 2)</tt> to the front end.
    51. 

  51. <pre class='samp'>
    52. 

  52. (cons 1 2)
    53. 

  53. <span class='response'>;Value 11: (1 . 2)</span>
    54. 

  54. </pre>
    55. 

  55. It responds <tt>(1 . 2)</tt>.
    56. 

  56. Function <span class='ttb'>cons</span> allocates a memory space for two addresses as shown in Figure 1.
    57. 

  57. and stores the address to 1 in one part and to 2 in the other part.
    58. 

  58. The part storing the address to 1 is called  <span class='ttb'>car</span> part and
    59. 

  59. that storing the address to 2 is called  <span class='ttb'>cdr</span> part.
    60. 

  60. <tt>Car</tt> and <tt>cdr</tt> are abbreviations of <u>Contents of the Address part of the Register</u>
    61. 

  61. and <u>Contents of the Decrement part of the Register</u>. These are originated from the names of
    62. 

  62. memory spaces of the hardware on which Lisp was first implemented.
    63. 

  63. These names also indicate that the reality of the cons cell is a memory space.
    64. 

  64. The name cons is an abbreviation of  a English term 'construction' for your information.
    65. 

  65. 

  66. <p>
    67. 

  67. <center><img src='cons2.png'><br>Fig 1: A cons cell.</center>
    68. 

  68. <p>
    69. 

  69. Cons cells can be beaded.
    70. 

  70. <pre class='samp'>
    71. 

  71. (cons 3 (cons 1 2))
    72. 

  72. <span class='response'>;Value 15: (3 1 . 2)</span>
    73. 

  73. </pre>
    74. 

  74. (3 1 . 2) is a convenient notation for  (3 . (1 . 2)).
    75. 

  75. The memory space of this situation is shown in Figure 2.<p>
    76. 

  76.   <center><img src='conss2.png'><br>Figure 2: Beaded cons cells.</center>
    77. 

  77. <p>
    78. 

  78. 

  79. Cons cells can store different kinds of data and can be nested.
    80. 

  80. 

  81. <pre class='samp'>
    82. 

  82. (cons #\a (cons 3 "hello"))
    83. 

  83. <span class='response'>;Value 17: (#\a 3 . "hello")</span>
    84. 

  84. 

  85. (cons (cons 0 1) (cons 1 2))
    86. 

  86. <span class='response'>;Value 23: ((0 . 1) 2 . 3)</span>
    87. 

  87. </pre>
    88. 

  88. This is due to that Scheme manipulates all the data by their addresses.
    89. 

  89. (<span class='ttb'>#\</span><var>c</var> represents a character <var>c</var>.
    90. 

  90. For example, <tt>#\a</tt> represents a character <tt>a</tt>.)
    91. 

  91. 

  92. <h3>2.2. Lists</h3>
    93. 

  93. Lists are (beaded) cons cells with the cdr part of the last cons cell being 
    94. 

  94. <strong>'()</strong>.
    95. 

  95. <strong>'()</strong> is called the empty list, which is  included to lists.
    96. 

  96. Even if the data consists of only one cons cell, it is a list if the cdr part is <tt>'()</tt>.
    97. 

  97. Figure 3 shows the memory structure of a list <tt><u>(1 2 3)</u></tt>.
    98. 

  98. <p>
    99. 

  99.   <center><img src='list2.png'><br>Figure 3: Memory structure for a list <u><tt>(1 2 3)</tt></u>.</center>
    100. 

  100. <p>
    101. 

  101. Actuary, list can be defined recursively like as follows:
    102. 

  102. 

  103. <ol>
    104. 

  104. <li> <tt>'()</tt> is a list.
    105. 

  105. <li> If <var>ls</var> is a list and <var>obj</var> is a kind of data,
    106. 

  106.   <span class='ttb'>(cons <var>obj</var> <var>ls</var>)</span> is a list.
    107. 

  107.   </ol>
    108. 

  108. As lists are data structure defined recursively,
    109. 

  109. it is reasonable to be used in recursive functions.
    110. 

  110.   
    111. 

  111. <h3>2.3. atoms</h3>
    112. 

  112. Data structures which do not use cons cells are called <b>atom</b>.
    113. 

  113. Numbers, characters, strings, vectors, and <tt>'()</tt> are atom.
    114. 

  114. <tt>'()</tt> is an atom and a list as well.
    115. 

  115. <h3> Exercise 1</h3>
    116. 

  116. Make data structures using <tt>cons</tt> that the front end responds like as follows.
    117. 

  117. <ol>
    118. 

  118. <li> <tt>("hi" . "everybody")</tt>
    119. 

  119. <li> <tt>(0)</tt>
    120. 

  120. <li> <tt>(1 10 . 100)</tt>
    121. 

  121. <li> <tt>(1 10 100)</tt>
    122. 

  122. <li> <tt>(#\I "saw" 3 "girls")</tt>
    123. 

  123. <li> <tt> ("Sum of" (1 2 3 4) "is" 10)</tt>
    124. 

  124. </ol>
    125. 

  125. 

  126. <h2> 3. quote</h2>
    127. 

  127. All tokens are ready to be evaluated
    128. 

  128. due to the Scheme's rule of the evaluation that tokens in parentheses are evaluated from inner to outer
    129. 

  129. and that the value comes out from the outermost parentheses is the value of the S-expression.
    130. 

  130. 

  131. A special form named <span class='ttb'>quote</span> is used to protect tokens from evaluation.
    132. 

  132. It is for giving symbols or lists to a program, which became something else by evaluation.<p>
    133. 

  133. 

  134. For instance, while <tt>(+ 2 3)</tt> is evaluated to be 5, <tt>(quote (+ 2 3))</tt> gives a list
    135. 

  135. <tt><u>(+ 2 3)</u></tt> itself to the program.  As <tt>quote</tt> is frequently used,
    136. 

  136. it is abbreviated as <u><tt>'</tt></u>.<br>
    137. 

  137. For example:
    138. 

  138. <ul>
    139. 

  139. <li><tt>'(+ 2 3)</tt> represents a list <tt><u>(+ 2 3)</u></tt> itself.
    140. 

  140. <li> <tt>'+</tt> represents a symbol <u><tt>+</tt></u> itself.
    141. 

  141.   </ul>
    142. 

  142. Actually,  <tt>'()</tt> is a quoted empty list, which means that
    143. 

  143. you should write <tt>'()</tt> to represent an empty list while the interpreter
    144. 

  144. responds  <tt>()</tt> for an empty list.
    145. 

  145. 

  146. 

  147. 

  148. <h3>3.1. Special forms</h3>
    149. 

  149. Scheme has two kinds of operators:
    150. 

  150. One is functions. Functions evaluate all the arguments to return  value.
    151. 

  151. The other is special forms. Special forms are not evaluate all the arguments.
    152. 

  152. Besides <tt>quote</tt>,
    153. 

  153. <span class='ttb'>lambda</span>, <span class='ttb'>define</span>,
    154. 

  154. <span class='ttb'>if</span>, <span class='ttb'>set!</span>, etc. are special forms.
    155. 

  155. 

  156. 

  157. <h2>4. Functions car and cdr</h2>
    158. 

  158. 

  159. Functions that returns the car part and the cdr part of a cons cell is called
    160. 

  160. <span class='ttb'>car</span> and
    161. 

  161. <span class='ttb'>cdr</span>, respectively.
    162. 

  162. If the value of <tt>cdr</tt> is a beaded cons cells, the interpreter
    163. 

  163. prints whole values of the car parts.
    164. 

  164. If the cdr part of the last cons cell is not  <tt>'()</tt>, the value is also shown
    165. 

  165. after <b>.</b>.
    166. 

  166. 

  167. <pre class='samp'>
    168. 

  168. (car '(1 2 3 4))
    169. 

  169. <span class='response'>;Value: 1</span>
    170. 

  170. 

  171. (cdr '(1 2 3 4))
    172. 

  172. <span class='response'>;Value 18: (2 3 4)</span>
    173. 

  173. </pre>
    174. 

  174. 

  175. <h3>  Exercise 2</h3>
    176. 

  176. Evaluated following S-expressions.
    177. 

  177. <ol>
    178. 

  178. <li> <tt>(car '(0))</tt>
    179. 

  179. <li> <tt>(cdr '(0))</tt>
    180. 

  180. <li> <tt> (car '((1 2 3) (4 5 6)))</tt>
    181. 

  181. <li> <tt> (cdr '(1 2 3 . 4))</tt>
    182. 

  182. <li> <tt>(cdr (cons 3 (cons 2 (cons 1 '()))))</tt>
    183. 

  183. </ol>
    184. 

  184. <h2>5. Function list </h2>
    185. 

  185. Function <span class='ttb'>list</span> is available to make a list consisting of several elements.
    186. 

  186. Function <tt>list</tt> takes arbitrary numbers of arguments and returns a list of them.
    187. 

  187. <pre class='samp'>
    188. 

  188. (list)
    189. 

  189. <span class='response'>;Value: ()</span>
    190. 

  190. 

  191. (list 1)
    192. 

  192. <span class='response'>;Value 24: (1)</span>
    193. 

  193. 

  194. (list '(1 2) '(3 4))
    195. 

  195. <span class='response'>;Value 25: ((1 2) (3 4))</span>
    196. 

  196. 

  197. (list 0)
    198. 

  198. <span class='response'>;Value 26: (0)</span>
    199. 

  199. 

  200. (list 1 2)
    201. 

  201. <span class='response'>;Value 27: (1 2)</span>
    202. 

  202. </pre>
    203. 

  203. 

  204. 

  205. <h2>6. Summary</h2>
    206. 

  206. This chapter explained about lists and basic operations for lists.
    207. 

  207. Chapters 1 &ndash; 3 may be boring, I am afraid.
    208. 

  208. The next chapter is interesting, I hope.
    209. 

  209. It deals with making functions.
    210. 

  210. I will explain
    211. 

  211. <ul>
    212. 

  212. <li>how to edit source codes using a editor,
    213. 

  213.   <li>how to load the source code to the interpreter, and
    214. 

  214.     <li> how to define functions.
    215. 

  215.       </ul>
    216. 

  216. 

  217. <h3>The Answers for Exercises</h3>
    218. 

  218. 

  219. <h4>Answer 1</h4>
    220. 

  220. 

  221. <pre class='samp'>
    222. 

  222. ;1
    223. 

  223. (cons "hi" "everybody")
    224. 

  224. <span class='response'>;Value 32: ("hi" . "everybody")</span>
    225. 

  225. 

  226. ;2
    227. 

  227. (cons 0 '())
    228. 

  228. <span class='response'>;Value 33: (0)</span>
    229. 

  229. 

  230. ;3
    231. 

  231. (cons 1 (cons 10 100))
    232. 

  232. <span class='response'>;Value 34: (1 10 . 100)</span>
    233. 

  233. 

  234. ;4
    235. 

  235. (cons 1 (cons 10 (cons 100 '())))
    236. 

  236. <span class='response'>;Value 35: (1 10 100)</span>
    237. 

  237. 

  238. ;5
    239. 

  239. (cons #\I (cons "saw" (cons 3 (cons "girls" '()))))
    240. 

  240. <span class='response'>;Value 36: (#\I "saw" 3 "girls")</span>
    241. 

  241. 

  242. ;6
    243. 

  243. (cons "Sum of" (cons (cons 1 (cons 2 (cons 3 (cons 4 '())))) (cons "is" (cons 10 '()))))
    244. 

  244. <span class='response'>;Value 37: ("Sum of" (1 2 3 4) "is" 10)</span>
    245. 

  245. </pre>
    246. 

  246. 

  247. <h4>Answer 2</h4>
    248. 

  248. <pre class='samp'>
    249. 

  249. ;1
    250. 

  250. (car '(0))
    251. 

  251. <span class='response'>;Value: 0</span>
    252. 

  252. 

  253. ;2
    254. 

  254. (cdr '(0))
    255. 

  255. <span class='response'>;Value: ()</span>
    256. 

  256. 

  257. ;3
    258. 

  258. (car '((1 2 3) (4 5 6)))
    259. 

  259. <span class='response'>;Value 28: (1 2 3)</span>
    260. 

  260. 

  261. ;4
    262. 

  262. (cdr '(1 2 3 . 4))
    263. 

  263. <span class='response'>;Value 29: (2 3 . 4)</span>
    264. 

  264. 

  265. ;5
    266. 

  266. (cdr (cons 3 (cons 2 (cons 1 '()))))
    267. 

  267. <span class='response'>;Value 31: (2 1)</span>
    268. 

  268. </pre>
    269. 

  269. 

  270. 

  271. <hr>
    272. 

  272. <p class="footer">
    273. 

  273. <table class='guide'><tr>
    274. 

  274. <td><a rel=home href='http://www.shido.info/index_e.php'>
    275. 

  275.   <img src='../images/shido_small.png' class='arrow' border=0>HOME</a></td>
    276. 

  276. <td><a rel=prev href="scheme2_e.html"><img src='../images/left_arrow.gif' class='arrow' border=0>
    277. 

  277.   2. Using Scheme as a Calculator</a></td>
    278. 

  278. <td><a rel=up href="idx_scm_e.html"><img src='../images/up_arrow.gif' class='arrow' border=0>Yet Another Scheme Tutorial</a></td>
    279. 

  279. <td><a rel=next href="scheme4_e.html"><img src='../images/right_arrow.gif' class='arrow' border=0>4. Defining Functions</a></td>
    280. 

  280. <td><a href='http://www.shido.info/gb/write_guestbook_e.php?ref=lisp/scheme3_e.html&amp;t=%28Scheme%29+Making+Lists' target='new'>
    281. 

  281. <img src='../images/pencil.gif' class='arrow' border=0>Post Messages</a></td>
    282. 

  282. </tr></table></p>
    283. 

  283. </body>
    284. 

  284. </html>
    285. 

  285. 

  286. 

  287.