objects.texi 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142
  1. @c -*- mode: texinfo; coding: utf-8 -*-
  2. @c This is part of the GNU Emacs Lisp Reference Manual.
  3. @c Copyright (C) 1990-1995, 1998-1999, 2001-2016 Free Software
  4. @c Foundation, Inc.
  5. @c See the file elisp.texi for copying conditions.
  6. @node Lisp Data Types
  7. @chapter Lisp Data Types
  8. @cindex object
  9. @cindex Lisp object
  10. @cindex type
  11. @cindex data type
  12. A Lisp @dfn{object} is a piece of data used and manipulated by Lisp
  13. programs. For our purposes, a @dfn{type} or @dfn{data type} is a set of
  14. possible objects.
  15. Every object belongs to at least one type. Objects of the same type
  16. have similar structures and may usually be used in the same contexts.
  17. Types can overlap, and objects can belong to two or more types.
  18. Consequently, we can ask whether an object belongs to a particular type,
  19. but not for @emph{the} type of an object.
  20. @cindex primitive type
  21. A few fundamental object types are built into Emacs. These, from
  22. which all other types are constructed, are called @dfn{primitive types}.
  23. Each object belongs to one and only one primitive type. These types
  24. include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
  25. @dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
  26. @dfn{byte-code function}, plus several special types, such as
  27. @dfn{buffer}, that are related to editing. (@xref{Editing Types}.)
  28. Each primitive type has a corresponding Lisp function that checks
  29. whether an object is a member of that type.
  30. Lisp is unlike many other languages in that its objects are
  31. @dfn{self-typing}: the primitive type of each object is implicit in
  32. the object itself. For example, if an object is a vector, nothing can
  33. treat it as a number; Lisp knows it is a vector, not a number.
  34. In most languages, the programmer must declare the data type of each
  35. variable, and the type is known by the compiler but not represented in
  36. the data. Such type declarations do not exist in Emacs Lisp. A Lisp
  37. variable can have any type of value, and it remembers whatever value
  38. you store in it, type and all. (Actually, a small number of Emacs
  39. Lisp variables can only take on values of a certain type.
  40. @xref{Variables with Restricted Values}.)
  41. This chapter describes the purpose, printed representation, and read
  42. syntax of each of the standard types in GNU Emacs Lisp. Details on how
  43. to use these types can be found in later chapters.
  44. @menu
  45. * Printed Representation:: How Lisp objects are represented as text.
  46. * Comments:: Comments and their formatting conventions.
  47. * Programming Types:: Types found in all Lisp systems.
  48. * Editing Types:: Types specific to Emacs.
  49. * Circular Objects:: Read syntax for circular structure.
  50. * Type Predicates:: Tests related to types.
  51. * Equality Predicates:: Tests of equality between any two objects.
  52. @end menu
  53. @node Printed Representation
  54. @section Printed Representation and Read Syntax
  55. @cindex printed representation
  56. @cindex read syntax
  57. The @dfn{printed representation} of an object is the format of the
  58. output generated by the Lisp printer (the function @code{prin1}) for
  59. that object. Every data type has a unique printed representation.
  60. The @dfn{read syntax} of an object is the format of the input accepted
  61. by the Lisp reader (the function @code{read}) for that object. This
  62. is not necessarily unique; many kinds of object have more than one
  63. syntax. @xref{Read and Print}.
  64. @cindex hash notation
  65. In most cases, an object's printed representation is also a read
  66. syntax for the object. However, some types have no read syntax, since
  67. it does not make sense to enter objects of these types as constants in
  68. a Lisp program. These objects are printed in @dfn{hash notation},
  69. which consists of the characters @samp{#<}, a descriptive string
  70. (typically the type name followed by the name of the object), and a
  71. closing @samp{>}. For example:
  72. @example
  73. (current-buffer)
  74. @result{} #<buffer objects.texi>
  75. @end example
  76. @noindent
  77. Hash notation cannot be read at all, so the Lisp reader signals the
  78. error @code{invalid-read-syntax} whenever it encounters @samp{#<}.
  79. @kindex invalid-read-syntax
  80. In other languages, an expression is text; it has no other form. In
  81. Lisp, an expression is primarily a Lisp object and only secondarily the
  82. text that is the object's read syntax. Often there is no need to
  83. emphasize this distinction, but you must keep it in the back of your
  84. mind, or you will occasionally be very confused.
  85. When you evaluate an expression interactively, the Lisp interpreter
  86. first reads the textual representation of it, producing a Lisp object,
  87. and then evaluates that object (@pxref{Evaluation}). However,
  88. evaluation and reading are separate activities. Reading returns the
  89. Lisp object represented by the text that is read; the object may or may
  90. not be evaluated later. @xref{Input Functions}, for a description of
  91. @code{read}, the basic function for reading objects.
  92. @node Comments
  93. @section Comments
  94. @cindex comments
  95. @cindex @samp{;} in comment
  96. A @dfn{comment} is text that is written in a program only for the sake
  97. of humans that read the program, and that has no effect on the meaning
  98. of the program. In Lisp, a semicolon (@samp{;}) starts a comment if it
  99. is not within a string or character constant. The comment continues to
  100. the end of line. The Lisp reader discards comments; they do not become
  101. part of the Lisp objects which represent the program within the Lisp
  102. system.
  103. The @samp{#@@@var{count}} construct, which skips the next @var{count}
  104. characters, is useful for program-generated comments containing binary
  105. data. The Emacs Lisp byte compiler uses this in its output files
  106. (@pxref{Byte Compilation}). It isn't meant for source files, however.
  107. @xref{Comment Tips}, for conventions for formatting comments.
  108. @node Programming Types
  109. @section Programming Types
  110. @cindex programming types
  111. There are two general categories of types in Emacs Lisp: those having
  112. to do with Lisp programming, and those having to do with editing. The
  113. former exist in many Lisp implementations, in one form or another. The
  114. latter are unique to Emacs Lisp.
  115. @menu
  116. * Integer Type:: Numbers without fractional parts.
  117. * Floating-Point Type:: Numbers with fractional parts and with a large range.
  118. * Character Type:: The representation of letters, numbers and
  119. control characters.
  120. * Symbol Type:: A multi-use object that refers to a function,
  121. variable, or property list, and has a unique identity.
  122. * Sequence Type:: Both lists and arrays are classified as sequences.
  123. * Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
  124. * Array Type:: Arrays include strings and vectors.
  125. * String Type:: An (efficient) array of characters.
  126. * Vector Type:: One-dimensional arrays.
  127. * Char-Table Type:: One-dimensional sparse arrays indexed by characters.
  128. * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
  129. * Hash Table Type:: Super-fast lookup tables.
  130. * Function Type:: A piece of executable code you can call from elsewhere.
  131. * Macro Type:: A method of expanding an expression into another
  132. expression, more fundamental but less pretty.
  133. * Primitive Function Type:: A function written in C, callable from Lisp.
  134. * Byte-Code Type:: A function written in Lisp, then compiled.
  135. * Autoload Type:: A type used for automatically loading seldom-used
  136. functions.
  137. * Finalizer Type:: Runs code when no longer reachable.
  138. @end menu
  139. @node Integer Type
  140. @subsection Integer Type
  141. The range of values for an integer depends on the machine. The
  142. minimum range is @minus{}536,870,912 to 536,870,911 (30 bits; i.e.,
  143. @ifnottex
  144. @minus{}2**29
  145. @end ifnottex
  146. @tex
  147. @math{-2^{29}}
  148. @end tex
  149. to
  150. @ifnottex
  151. 2**29 @minus{} 1)
  152. @end ifnottex
  153. @tex
  154. @math{2^{29}-1})
  155. @end tex
  156. but many machines provide a wider range.
  157. Emacs Lisp arithmetic functions do not check for integer overflow. Thus
  158. @code{(1+ 536870911)} is @minus{}536,870,912 if Emacs integers are 30 bits.
  159. The read syntax for integers is a sequence of (base ten) digits with an
  160. optional sign at the beginning and an optional period at the end. The
  161. printed representation produced by the Lisp interpreter never has a
  162. leading @samp{+} or a final @samp{.}.
  163. @example
  164. @group
  165. -1 ; @r{The integer @minus{}1.}
  166. 1 ; @r{The integer 1.}
  167. 1. ; @r{Also the integer 1.}
  168. +1 ; @r{Also the integer 1.}
  169. @end group
  170. @end example
  171. @noindent
  172. As a special exception, if a sequence of digits specifies an integer
  173. too large or too small to be a valid integer object, the Lisp reader
  174. reads it as a floating-point number (@pxref{Floating-Point Type}).
  175. For instance, if Emacs integers are 30 bits, @code{536870912} is read
  176. as the floating-point number @code{536870912.0}.
  177. @xref{Numbers}, for more information.
  178. @node Floating-Point Type
  179. @subsection Floating-Point Type
  180. Floating-point numbers are the computer equivalent of scientific
  181. notation; you can think of a floating-point number as a fraction
  182. together with a power of ten. The precise number of significant
  183. figures and the range of possible exponents is machine-specific; Emacs
  184. uses the C data type @code{double} to store the value, and internally
  185. this records a power of 2 rather than a power of 10.
  186. The printed representation for floating-point numbers requires either
  187. a decimal point (with at least one digit following), an exponent, or
  188. both. For example, @samp{1500.0}, @samp{+15e2}, @samp{15.0e+2},
  189. @samp{+1500000e-3}, and @samp{.15e4} are five ways of writing a floating-point
  190. number whose value is 1500. They are all equivalent.
  191. @xref{Numbers}, for more information.
  192. @node Character Type
  193. @subsection Character Type
  194. @cindex @acronym{ASCII} character codes
  195. A @dfn{character} in Emacs Lisp is nothing more than an integer. In
  196. other words, characters are represented by their character codes. For
  197. example, the character @kbd{A} is represented as the @w{integer 65}.
  198. Individual characters are used occasionally in programs, but it is
  199. more common to work with @emph{strings}, which are sequences composed
  200. of characters. @xref{String Type}.
  201. Characters in strings and buffers are currently limited to the range
  202. of 0 to 4194303---twenty two bits (@pxref{Character Codes}). Codes 0
  203. through 127 are @acronym{ASCII} codes; the rest are
  204. non-@acronym{ASCII} (@pxref{Non-ASCII Characters}). Characters that
  205. represent keyboard input have a much wider range, to encode modifier
  206. keys such as Control, Meta and Shift.
  207. There are special functions for producing a human-readable textual
  208. description of a character for the sake of messages. @xref{Describing
  209. Characters}.
  210. @menu
  211. * Basic Char Syntax:: Syntax for regular characters.
  212. * General Escape Syntax:: How to specify characters by their codes.
  213. * Ctl-Char Syntax:: Syntax for control characters.
  214. * Meta-Char Syntax:: Syntax for meta-characters.
  215. * Other Char Bits:: Syntax for hyper-, super-, and alt-characters.
  216. @end menu
  217. @node Basic Char Syntax
  218. @subsubsection Basic Char Syntax
  219. @cindex read syntax for characters
  220. @cindex printed representation for characters
  221. @cindex syntax for characters
  222. @cindex @samp{?} in character constant
  223. @cindex question mark in character constant
  224. Since characters are really integers, the printed representation of
  225. a character is a decimal number. This is also a possible read syntax
  226. for a character, but writing characters that way in Lisp programs is
  227. not clear programming. You should @emph{always} use the special read
  228. syntax formats that Emacs Lisp provides for characters. These syntax
  229. formats start with a question mark.
  230. The usual read syntax for alphanumeric characters is a question mark
  231. followed by the character; thus, @samp{?A} for the character
  232. @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
  233. character @kbd{a}.
  234. For example:
  235. @example
  236. ?Q @result{} 81 ?q @result{} 113
  237. @end example
  238. You can use the same syntax for punctuation characters, but it is
  239. often a good idea to add a @samp{\} so that the Emacs commands for
  240. editing Lisp code don't get confused. For example, @samp{?\(} is the
  241. way to write the open-paren character. If the character is @samp{\},
  242. you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.
  243. @cindex whitespace
  244. @cindex bell character
  245. @cindex @samp{\a}
  246. @cindex backspace
  247. @cindex @samp{\b}
  248. @cindex tab (ASCII character)
  249. @cindex @samp{\t}
  250. @cindex vertical tab
  251. @cindex @samp{\v}
  252. @cindex formfeed
  253. @cindex @samp{\f}
  254. @cindex newline
  255. @cindex @samp{\n}
  256. @cindex return (ASCII character)
  257. @cindex @samp{\r}
  258. @cindex escape (ASCII character)
  259. @cindex @samp{\e}
  260. @cindex space (ASCII character)
  261. @cindex @samp{\s}
  262. You can express the characters control-g, backspace, tab, newline,
  263. vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
  264. @samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
  265. @samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
  266. (@samp{?\s} followed by a dash has a different meaning---it applies
  267. the Super modifier to the following character.) Thus,
  268. @example
  269. ?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
  270. ?\b @result{} 8 ; @r{backspace, @key{BS}, @kbd{C-h}}
  271. ?\t @result{} 9 ; @r{tab, @key{TAB}, @kbd{C-i}}
  272. ?\n @result{} 10 ; @r{newline, @kbd{C-j}}
  273. ?\v @result{} 11 ; @r{vertical tab, @kbd{C-k}}
  274. ?\f @result{} 12 ; @r{formfeed character, @kbd{C-l}}
  275. ?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
  276. ?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
  277. ?\s @result{} 32 ; @r{space character, @key{SPC}}
  278. ?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
  279. ?\d @result{} 127 ; @r{delete character, @key{DEL}}
  280. @end example
  281. @cindex escape sequence
  282. These sequences which start with backslash are also known as
  283. @dfn{escape sequences}, because backslash plays the role of an
  284. escape character; this has nothing to do with the
  285. character @key{ESC}. @samp{\s} is meant for use in character
  286. constants; in string constants, just write the space.
  287. A backslash is allowed, and harmless, preceding any character without
  288. a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
  289. There is no reason to add a backslash before most characters. However,
  290. you should add a backslash before any of the characters
  291. @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
  292. Lisp code. You can also add a backslash before whitespace characters such as
  293. space, tab, newline and formfeed. However, it is cleaner to use one of
  294. the easily readable escape sequences, such as @samp{\t} or @samp{\s},
  295. instead of an actual whitespace character such as a tab or a space.
  296. (If you do write backslash followed by a space, you should write
  297. an extra space after the character constant to separate it from the
  298. following text.)
  299. @node General Escape Syntax
  300. @subsubsection General Escape Syntax
  301. In addition to the specific escape sequences for special important
  302. control characters, Emacs provides several types of escape syntax that
  303. you can use to specify non-@acronym{ASCII} text characters.
  304. @cindex @samp{\} in character constant
  305. @cindex backslash in character constants
  306. @cindex unicode character escape
  307. Firstly, you can specify characters by their Unicode values.
  308. @code{?\u@var{nnnn}} represents a character with Unicode code point
  309. @samp{U+@var{nnnn}}, where @var{nnnn} is (by convention) a hexadecimal
  310. number with exactly four digits. The backslash indicates that the
  311. subsequent characters form an escape sequence, and the @samp{u}
  312. specifies a Unicode escape sequence.
  313. There is a slightly different syntax for specifying Unicode
  314. characters with code points higher than @code{U+@var{ffff}}:
  315. @code{?\U00@var{nnnnnn}} represents the character with code point
  316. @samp{U+@var{nnnnnn}}, where @var{nnnnnn} is a six-digit hexadecimal
  317. number. The Unicode Standard only defines code points up to
  318. @samp{U+@var{10ffff}}, so if you specify a code point higher than
  319. that, Emacs signals an error.
  320. Secondly, you can specify characters by their hexadecimal character
  321. codes. A hexadecimal escape sequence consists of a backslash,
  322. @samp{x}, and the hexadecimal character code. Thus, @samp{?\x41} is
  323. the character @kbd{A}, @samp{?\x1} is the character @kbd{C-a}, and
  324. @code{?\xe0} is the character @kbd{à} (@kbd{a} with grave accent).
  325. You can use any number of hex digits, so you can represent any
  326. character code in this way.
  327. @cindex octal character code
  328. Thirdly, you can specify characters by their character code in
  329. octal. An octal escape sequence consists of a backslash followed by
  330. up to three octal digits; thus, @samp{?\101} for the character
  331. @kbd{A}, @samp{?\001} for the character @kbd{C-a}, and @code{?\002}
  332. for the character @kbd{C-b}. Only characters up to octal code 777 can
  333. be specified this way.
  334. These escape sequences may also be used in strings. @xref{Non-ASCII
  335. in Strings}.
  336. @node Ctl-Char Syntax
  337. @subsubsection Control-Character Syntax
  338. @cindex control characters
  339. Control characters can be represented using yet another read syntax.
  340. This consists of a question mark followed by a backslash, caret, and the
  341. corresponding non-control character, in either upper or lower case. For
  342. example, both @samp{?\^I} and @samp{?\^i} are valid read syntax for the
  343. character @kbd{C-i}, the character whose value is 9.
  344. Instead of the @samp{^}, you can use @samp{C-}; thus, @samp{?\C-i} is
  345. equivalent to @samp{?\^I} and to @samp{?\^i}:
  346. @example
  347. ?\^I @result{} 9 ?\C-I @result{} 9
  348. @end example
  349. In strings and buffers, the only control characters allowed are those
  350. that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
  351. any character into a control character with @samp{C-}. The character
  352. codes for these non-@acronym{ASCII} control characters include the
  353. @tex
  354. @math{2^{26}}
  355. @end tex
  356. @ifnottex
  357. 2**26
  358. @end ifnottex
  359. bit as well as the code for the corresponding non-control character.
  360. Ordinary text terminals have no way of generating non-@acronym{ASCII}
  361. control characters, but you can generate them straightforwardly using
  362. X and other window systems.
  363. For historical reasons, Emacs treats the @key{DEL} character as
  364. the control equivalent of @kbd{?}:
  365. @example
  366. ?\^? @result{} 127 ?\C-? @result{} 127
  367. @end example
  368. @noindent
  369. As a result, it is currently not possible to represent the character
  370. @kbd{Control-?}, which is a meaningful input character under X, using
  371. @samp{\C-}. It is not easy to change this, as various Lisp files refer
  372. to @key{DEL} in this way.
  373. For representing control characters to be found in files or strings,
  374. we recommend the @samp{^} syntax; for control characters in keyboard
  375. input, we prefer the @samp{C-} syntax. Which one you use does not
  376. affect the meaning of the program, but may guide the understanding of
  377. people who read it.
  378. @node Meta-Char Syntax
  379. @subsubsection Meta-Character Syntax
  380. @cindex meta characters
  381. A @dfn{meta character} is a character typed with the @key{META}
  382. modifier key. The integer that represents such a character has the
  383. @tex
  384. @math{2^{27}}
  385. @end tex
  386. @ifnottex
  387. 2**27
  388. @end ifnottex
  389. bit set. We use high bits for this and other modifiers to make
  390. possible a wide range of basic character codes.
  391. In a string, the
  392. @tex
  393. @math{2^{7}}
  394. @end tex
  395. @ifnottex
  396. 2**7
  397. @end ifnottex
  398. bit attached to an @acronym{ASCII} character indicates a meta
  399. character; thus, the meta characters that can fit in a string have
  400. codes in the range from 128 to 255, and are the meta versions of the
  401. ordinary @acronym{ASCII} characters. @xref{Strings of Events}, for
  402. details about @key{META}-handling in strings.
  403. The read syntax for meta characters uses @samp{\M-}. For example,
  404. @samp{?\M-A} stands for @kbd{M-A}. You can use @samp{\M-} together with
  405. octal character codes (see below), with @samp{\C-}, or with any other
  406. syntax for a character. Thus, you can write @kbd{M-A} as @samp{?\M-A},
  407. or as @samp{?\M-\101}. Likewise, you can write @kbd{C-M-b} as
  408. @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
  409. @node Other Char Bits
  410. @subsubsection Other Character Modifier Bits
  411. The case of a graphic character is indicated by its character code;
  412. for example, @acronym{ASCII} distinguishes between the characters @samp{a}
  413. and @samp{A}. But @acronym{ASCII} has no way to represent whether a control
  414. character is upper case or lower case. Emacs uses the
  415. @tex
  416. @math{2^{25}}
  417. @end tex
  418. @ifnottex
  419. 2**25
  420. @end ifnottex
  421. bit to indicate that the shift key was used in typing a control
  422. character. This distinction is possible only when you use X terminals
  423. or other special terminals; ordinary text terminals do not report the
  424. distinction. The Lisp syntax for the shift bit is @samp{\S-}; thus,
  425. @samp{?\C-\S-o} or @samp{?\C-\S-O} represents the shifted-control-o
  426. character.
  427. @cindex hyper characters
  428. @cindex super characters
  429. @cindex alt characters
  430. The X Window System defines three other
  431. @anchor{modifier bits}modifier bits that can be set
  432. in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}. The syntaxes
  433. for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. (Case is
  434. significant in these prefixes.) Thus, @samp{?\H-\M-\A-x} represents
  435. @kbd{Alt-Hyper-Meta-x}. (Note that @samp{\s} with no following @samp{-}
  436. represents the space character.)
  437. @tex
  438. Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
  439. for super and @math{2^{24}} for hyper.
  440. @end tex
  441. @ifnottex
  442. Numerically, the
  443. bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
  444. @end ifnottex
  445. @node Symbol Type
  446. @subsection Symbol Type
  447. A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The
  448. symbol name serves as the printed representation of the symbol. In
  449. ordinary Lisp use, with one single obarray (@pxref{Creating Symbols}),
  450. a symbol's name is unique---no two symbols have the same name.
  451. A symbol can serve as a variable, as a function name, or to hold a
  452. property list. Or it may serve only to be distinct from all other Lisp
  453. objects, so that its presence in a data structure may be recognized
  454. reliably. In a given context, usually only one of these uses is
  455. intended. But you can use one symbol in all of these ways,
  456. independently.
  457. A symbol whose name starts with a colon (@samp{:}) is called a
  458. @dfn{keyword symbol}. These symbols automatically act as constants,
  459. and are normally used only by comparing an unknown symbol with a few
  460. specific alternatives. @xref{Constant Variables}.
  461. @cindex @samp{\} in symbols
  462. @cindex backslash in symbols
  463. A symbol name can contain any characters whatever. Most symbol names
  464. are written with letters, digits, and the punctuation characters
  465. @samp{-+=*/}. Such names require no special punctuation; the characters
  466. of the name suffice as long as the name does not look like a number.
  467. (If it does, write a @samp{\} at the beginning of the name to force
  468. interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}?} are
  469. less often used but also require no special punctuation. Any other
  470. characters may be included in a symbol's name by escaping them with a
  471. backslash. In contrast to its use in strings, however, a backslash in
  472. the name of a symbol simply quotes the single character that follows the
  473. backslash. For example, in a string, @samp{\t} represents a tab
  474. character; in the name of a symbol, however, @samp{\t} merely quotes the
  475. letter @samp{t}. To have a symbol with a tab character in its name, you
  476. must actually use a tab (preceded with a backslash). But it's rare to
  477. do such a thing.
  478. @cindex CL note---case of letters
  479. @quotation
  480. @b{Common Lisp note:} In Common Lisp, lower case letters are always
  481. folded to upper case, unless they are explicitly escaped. In Emacs
  482. Lisp, upper case and lower case letters are distinct.
  483. @end quotation
  484. Here are several examples of symbol names. Note that the @samp{+} in
  485. the fourth example is escaped to prevent it from being read as a number.
  486. This is not necessary in the sixth example because the rest of the name
  487. makes it invalid as a number.
  488. @example
  489. @group
  490. foo ; @r{A symbol named @samp{foo}.}
  491. FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
  492. @end group
  493. @group
  494. 1+ ; @r{A symbol named @samp{1+}}
  495. ; @r{(not @samp{+1}, which is an integer).}
  496. @end group
  497. @group
  498. \+1 ; @r{A symbol named @samp{+1}}
  499. ; @r{(not a very readable name).}
  500. @end group
  501. @group
  502. \(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
  503. @c the @'s in this next line use up three characters, hence the
  504. @c apparent misalignment of the comment.
  505. +-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
  506. ; @r{These characters need not be escaped.}
  507. @end group
  508. @end example
  509. @cindex @samp{##} read syntax
  510. @ifinfo
  511. @c This uses "colon" instead of a literal ':' because Info cannot
  512. @c cope with a ':' in a menu.
  513. @cindex @samp{#@var{colon}} read syntax
  514. @end ifinfo
  515. @ifnotinfo
  516. @cindex @samp{#:} read syntax
  517. @end ifnotinfo
  518. As an exception to the rule that a symbol's name serves as its
  519. printed representation, @samp{##} is the printed representation for an
  520. interned symbol whose name is an empty string. Furthermore,
  521. @samp{#:@var{foo}} is the printed representation for an uninterned
  522. symbol whose name is @var{foo}. (Normally, the Lisp reader interns
  523. all symbols; @pxref{Creating Symbols}.)
  524. @node Sequence Type
  525. @subsection Sequence Types
  526. A @dfn{sequence} is a Lisp object that represents an ordered set of
  527. elements. There are two kinds of sequence in Emacs Lisp: @dfn{lists}
  528. and @dfn{arrays}.
  529. Lists are the most commonly-used sequences. A list can hold
  530. elements of any type, and its length can be easily changed by adding
  531. or removing elements. See the next subsection for more about lists.
  532. Arrays are fixed-length sequences. They are further subdivided into
  533. strings, vectors, char-tables and bool-vectors. Vectors can hold
  534. elements of any type, whereas string elements must be characters, and
  535. bool-vector elements must be @code{t} or @code{nil}. Char-tables are
  536. like vectors except that they are indexed by any valid character code.
  537. The characters in a string can have text properties like characters in
  538. a buffer (@pxref{Text Properties}), but vectors do not support text
  539. properties, even when their elements happen to be characters.
  540. Lists, strings and the other array types also share important
  541. similarities. For example, all have a length @var{l}, and all have
  542. elements which can be indexed from zero to @var{l} minus one. Several
  543. functions, called sequence functions, accept any kind of sequence.
  544. For example, the function @code{length} reports the length of any kind
  545. of sequence. @xref{Sequences Arrays Vectors}.
  546. It is generally impossible to read the same sequence twice, since
  547. sequences are always created anew upon reading. If you read the read
  548. syntax for a sequence twice, you get two sequences with equal contents.
  549. There is one exception: the empty list @code{()} always stands for the
  550. same object, @code{nil}.
  551. @node Cons Cell Type
  552. @subsection Cons Cell and List Types
  553. @cindex address field of register
  554. @cindex decrement field of register
  555. @cindex pointers
  556. A @dfn{cons cell} is an object that consists of two slots, called
  557. the @sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} any
  558. Lisp object. We also say that the @sc{car} of this cons cell is
  559. whatever object its @sc{car} slot currently holds, and likewise for
  560. the @sc{cdr}.
  561. @cindex list structure
  562. A @dfn{list} is a series of cons cells, linked together so that the
  563. @sc{cdr} slot of each cons cell holds either the next cons cell or the
  564. empty list. The empty list is actually the symbol @code{nil}.
  565. @xref{Lists}, for details. Because most cons cells are used as part
  566. of lists, we refer to any structure made out of cons cells as a
  567. @dfn{list structure}.
  568. @cindex linked list
  569. @quotation
  570. A note to C programmers: a Lisp list thus works as a @dfn{linked list}
  571. built up of cons cells. Because pointers in Lisp are implicit, we do
  572. not distinguish between a cons cell slot holding a value versus
  573. pointing to the value.
  574. @end quotation
  575. @cindex atoms
  576. Because cons cells are so central to Lisp, we also have a word for
  577. an object which is not a cons cell. These objects are called
  578. @dfn{atoms}.
  579. @cindex parenthesis
  580. @cindex @samp{(@dots{})} in lists
  581. The read syntax and printed representation for lists are identical, and
  582. consist of a left parenthesis, an arbitrary number of elements, and a
  583. right parenthesis. Here are examples of lists:
  584. @example
  585. (A 2 "A") ; @r{A list of three elements.}
  586. () ; @r{A list of no elements (the empty list).}
  587. nil ; @r{A list of no elements (the empty list).}
  588. ("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
  589. (A ()) ; @r{A list of two elements: @code{A} and the empty list.}
  590. (A nil) ; @r{Equivalent to the previous.}
  591. ((A B C)) ; @r{A list of one element}
  592. ; @r{(which is a list of three elements).}
  593. @end example
  594. Upon reading, each object inside the parentheses becomes an element
  595. of the list. That is, a cons cell is made for each element. The
  596. @sc{car} slot of the cons cell holds the element, and its @sc{cdr}
  597. slot refers to the next cons cell of the list, which holds the next
  598. element in the list. The @sc{cdr} slot of the last cons cell is set to
  599. hold @code{nil}.
  600. The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
  601. original Lisp implementation ran on an @w{IBM 704} computer which
  602. divided words into two parts, the address and the
  603. decrement; @sc{car} was an instruction to extract the contents of
  604. the address part of a register, and @sc{cdr} an instruction to extract
  605. the contents of the decrement. By contrast, cons cells are named
  606. for the function @code{cons} that creates them, which in turn was named
  607. for its purpose, the construction of cells.
  608. @menu
  609. * Box Diagrams:: Drawing pictures of lists.
  610. * Dotted Pair Notation:: A general syntax for cons cells.
  611. * Association List Type:: A specially constructed list.
  612. @end menu
  613. @node Box Diagrams
  614. @subsubsection Drawing Lists as Box Diagrams
  615. @cindex box diagrams, for lists
  616. @cindex diagrams, boxed, for lists
  617. A list can be illustrated by a diagram in which the cons cells are
  618. shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
  619. such an illustration; unlike the textual notation, which can be
  620. understood by both humans and computers, the box illustrations can be
  621. understood only by humans.) This picture represents the three-element
  622. list @code{(rose violet buttercup)}:
  623. @example
  624. @group
  625. --- --- --- --- --- ---
  626. | | |--> | | |--> | | |--> nil
  627. --- --- --- --- --- ---
  628. | | |
  629. | | |
  630. --> rose --> violet --> buttercup
  631. @end group
  632. @end example
  633. In this diagram, each box represents a slot that can hold or refer to
  634. any Lisp object. Each pair of boxes represents a cons cell. Each arrow
  635. represents a reference to a Lisp object, either an atom or another cons
  636. cell.
  637. In this example, the first box, which holds the @sc{car} of the first
  638. cons cell, refers to or holds @code{rose} (a symbol). The second
  639. box, holding the @sc{cdr} of the first cons cell, refers to the next
  640. pair of boxes, the second cons cell. The @sc{car} of the second cons
  641. cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
  642. @sc{cdr} of the third (and last) cons cell is @code{nil}.
  643. Here is another diagram of the same list, @code{(rose violet
  644. buttercup)}, sketched in a different manner:
  645. @smallexample
  646. @group
  647. --------------- ---------------- -------------------
  648. | car | cdr | | car | cdr | | car | cdr |
  649. | rose | o-------->| violet | o-------->| buttercup | nil |
  650. | | | | | | | | |
  651. --------------- ---------------- -------------------
  652. @end group
  653. @end smallexample
  654. @cindex @code{nil} as a list
  655. @cindex empty list
  656. A list with no elements in it is the @dfn{empty list}; it is identical
  657. to the symbol @code{nil}. In other words, @code{nil} is both a symbol
  658. and a list.
  659. Here is the list @code{(A ())}, or equivalently @code{(A nil)},
  660. depicted with boxes and arrows:
  661. @example
  662. @group
  663. --- --- --- ---
  664. | | |--> | | |--> nil
  665. --- --- --- ---
  666. | |
  667. | |
  668. --> A --> nil
  669. @end group
  670. @end example
  671. Here is a more complex illustration, showing the three-element list,
  672. @code{((pine needles) oak maple)}, the first element of which is a
  673. two-element list:
  674. @example
  675. @group
  676. --- --- --- --- --- ---
  677. | | |--> | | |--> | | |--> nil
  678. --- --- --- --- --- ---
  679. | | |
  680. | | |
  681. | --> oak --> maple
  682. |
  683. | --- --- --- ---
  684. --> | | |--> | | |--> nil
  685. --- --- --- ---
  686. | |
  687. | |
  688. --> pine --> needles
  689. @end group
  690. @end example
  691. The same list represented in the second box notation looks like this:
  692. @example
  693. @group
  694. -------------- -------------- --------------
  695. | car | cdr | | car | cdr | | car | cdr |
  696. | o | o------->| oak | o------->| maple | nil |
  697. | | | | | | | | | |
  698. -- | --------- -------------- --------------
  699. |
  700. |
  701. | -------------- ----------------
  702. | | car | cdr | | car | cdr |
  703. ------>| pine | o------->| needles | nil |
  704. | | | | | |
  705. -------------- ----------------
  706. @end group
  707. @end example
  708. @node Dotted Pair Notation
  709. @subsubsection Dotted Pair Notation
  710. @cindex dotted pair notation
  711. @cindex @samp{.} in lists
  712. @dfn{Dotted pair notation} is a general syntax for cons cells that
  713. represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
  714. @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
  715. the object @var{a} and whose @sc{cdr} is the object @var{b}. Dotted
  716. pair notation is more general than list syntax because the @sc{cdr}
  717. does not have to be a list. However, it is more cumbersome in cases
  718. where list syntax would work. In dotted pair notation, the list
  719. @samp{(1 2 3)} is written as @samp{(1 . (2 . (3 . nil)))}. For
  720. @code{nil}-terminated lists, you can use either notation, but list
  721. notation is usually clearer and more convenient. When printing a
  722. list, the dotted pair notation is only used if the @sc{cdr} of a cons
  723. cell is not a list.
  724. Here's an example using boxes to illustrate dotted pair notation.
  725. This example shows the pair @code{(rose . violet)}:
  726. @example
  727. @group
  728. --- ---
  729. | | |--> violet
  730. --- ---
  731. |
  732. |
  733. --> rose
  734. @end group
  735. @end example
  736. You can combine dotted pair notation with list notation to represent
  737. conveniently a chain of cons cells with a non-@code{nil} final @sc{cdr}.
  738. You write a dot after the last element of the list, followed by the
  739. @sc{cdr} of the final cons cell. For example, @code{(rose violet
  740. . buttercup)} is equivalent to @code{(rose . (violet . buttercup))}.
  741. The object looks like this:
  742. @example
  743. @group
  744. --- --- --- ---
  745. | | |--> | | |--> buttercup
  746. --- --- --- ---
  747. | |
  748. | |
  749. --> rose --> violet
  750. @end group
  751. @end example
  752. The syntax @code{(rose .@: violet .@: buttercup)} is invalid because
  753. there is nothing that it could mean. If anything, it would say to put
  754. @code{buttercup} in the @sc{cdr} of a cons cell whose @sc{cdr} is already
  755. used for @code{violet}.
  756. The list @code{(rose violet)} is equivalent to @code{(rose . (violet))},
  757. and looks like this:
  758. @example
  759. @group
  760. --- --- --- ---
  761. | | |--> | | |--> nil
  762. --- --- --- ---
  763. | |
  764. | |
  765. --> rose --> violet
  766. @end group
  767. @end example
  768. Similarly, the three-element list @code{(rose violet buttercup)}
  769. is equivalent to @code{(rose . (violet . (buttercup)))}.
  770. @ifnottex
  771. It looks like this:
  772. @example
  773. @group
  774. --- --- --- --- --- ---
  775. | | |--> | | |--> | | |--> nil
  776. --- --- --- --- --- ---
  777. | | |
  778. | | |
  779. --> rose --> violet --> buttercup
  780. @end group
  781. @end example
  782. @end ifnottex
  783. @node Association List Type
  784. @subsubsection Association List Type
  785. An @dfn{association list} or @dfn{alist} is a specially-constructed
  786. list whose elements are cons cells. In each element, the @sc{car} is
  787. considered a @dfn{key}, and the @sc{cdr} is considered an
  788. @dfn{associated value}. (In some cases, the associated value is stored
  789. in the @sc{car} of the @sc{cdr}.) Association lists are often used as
  790. stacks, since it is easy to add or remove associations at the front of
  791. the list.
  792. For example,
  793. @example
  794. (setq alist-of-colors
  795. '((rose . red) (lily . white) (buttercup . yellow)))
  796. @end example
  797. @noindent
  798. sets the variable @code{alist-of-colors} to an alist of three elements. In the
  799. first element, @code{rose} is the key and @code{red} is the value.
  800. @xref{Association Lists}, for a further explanation of alists and for
  801. functions that work on alists. @xref{Hash Tables}, for another kind of
  802. lookup table, which is much faster for handling a large number of keys.
  803. @node Array Type
  804. @subsection Array Type
  805. An @dfn{array} is composed of an arbitrary number of slots for
  806. holding or referring to other Lisp objects, arranged in a contiguous block of
  807. memory. Accessing any element of an array takes approximately the same
  808. amount of time. In contrast, accessing an element of a list requires
  809. time proportional to the position of the element in the list. (Elements
  810. at the end of a list take longer to access than elements at the
  811. beginning of a list.)
  812. Emacs defines four types of array: strings, vectors, bool-vectors, and
  813. char-tables.
  814. A string is an array of characters and a vector is an array of
  815. arbitrary objects. A bool-vector can hold only @code{t} or @code{nil}.
  816. These kinds of array may have any length up to the largest integer.
  817. Char-tables are sparse arrays indexed by any valid character code; they
  818. can hold arbitrary objects.
  819. The first element of an array has index zero, the second element has
  820. index 1, and so on. This is called @dfn{zero-origin} indexing. For
  821. example, an array of four elements has indices 0, 1, 2, @w{and 3}. The
  822. largest possible index value is one less than the length of the array.
  823. Once an array is created, its length is fixed.
  824. All Emacs Lisp arrays are one-dimensional. (Most other programming
  825. languages support multidimensional arrays, but they are not essential;
  826. you can get the same effect with nested one-dimensional arrays.) Each
  827. type of array has its own read syntax; see the following sections for
  828. details.
  829. The array type is a subset of the sequence type, and contains the
  830. string type, the vector type, the bool-vector type, and the char-table
  831. type.
  832. @node String Type
  833. @subsection String Type
  834. A @dfn{string} is an array of characters. Strings are used for many
  835. purposes in Emacs, as can be expected in a text editor; for example, as
  836. the names of Lisp symbols, as messages for the user, and to represent
  837. text extracted from buffers. Strings in Lisp are constants: evaluation
  838. of a string returns the same string.
  839. @xref{Strings and Characters}, for functions that operate on strings.
  840. @menu
  841. * Syntax for Strings:: How to specify Lisp strings.
  842. * Non-ASCII in Strings:: International characters in strings.
  843. * Nonprinting Characters:: Literal unprintable characters in strings.
  844. * Text Props and Strings:: Strings with text properties.
  845. @end menu
  846. @node Syntax for Strings
  847. @subsubsection Syntax for Strings
  848. @cindex @samp{"} in strings
  849. @cindex double-quote in strings
  850. @cindex @samp{\} in strings
  851. @cindex backslash in strings
  852. The read syntax for a string is a double-quote, an arbitrary number
  853. of characters, and another double-quote, @code{"like this"}. To
  854. include a double-quote in a string, precede it with a backslash; thus,
  855. @code{"\""} is a string containing just one double-quote
  856. character. Likewise, you can include a backslash by preceding it with
  857. another backslash, like this: @code{"this \\ is a single embedded
  858. backslash"}.
  859. @cindex newline in strings
  860. The newline character is not special in the read syntax for strings;
  861. if you write a new line between the double-quotes, it becomes a
  862. character in the string. But an escaped newline---one that is preceded
  863. by @samp{\}---does not become part of the string; i.e., the Lisp reader
  864. ignores an escaped newline while reading a string. An escaped space
  865. @w{@samp{\ }} is likewise ignored.
  866. @example
  867. "It is useful to include newlines
  868. in documentation strings,
  869. but the newline is \
  870. ignored if escaped."
  871. @result{} "It is useful to include newlines
  872. in documentation strings,
  873. but the newline is ignored if escaped."
  874. @end example
  875. @node Non-ASCII in Strings
  876. @subsubsection Non-@acronym{ASCII} Characters in Strings
  877. There are two text representations for non-@acronym{ASCII}
  878. characters in Emacs strings: multibyte and unibyte (@pxref{Text
  879. Representations}). Roughly speaking, unibyte strings store raw bytes,
  880. while multibyte strings store human-readable text. Each character in
  881. a unibyte string is a byte, i.e., its value is between 0 and 255. By
  882. contrast, each character in a multibyte string may have a value
  883. between 0 to 4194303 (@pxref{Character Type}). In both cases,
  884. characters above 127 are non-@acronym{ASCII}.
  885. You can include a non-@acronym{ASCII} character in a string constant
  886. by writing it literally. If the string constant is read from a
  887. multibyte source, such as a multibyte buffer or string, or a file that
  888. would be visited as multibyte, then Emacs reads each
  889. non-@acronym{ASCII} character as a multibyte character and
  890. automatically makes the string a multibyte string. If the string
  891. constant is read from a unibyte source, then Emacs reads the
  892. non-@acronym{ASCII} character as unibyte, and makes the string
  893. unibyte.
  894. Instead of writing a character literally into a multibyte string,
  895. you can write it as its character code using an escape sequence.
  896. @xref{General Escape Syntax}, for details about escape sequences.
  897. If you use any Unicode-style escape sequence @samp{\uNNNN} or
  898. @samp{\U00NNNNNN} in a string constant (even for an @acronym{ASCII}
  899. character), Emacs automatically assumes that it is multibyte.
  900. You can also use hexadecimal escape sequences (@samp{\x@var{n}}) and
  901. octal escape sequences (@samp{\@var{n}}) in string constants.
  902. @strong{But beware:} If a string constant contains hexadecimal or
  903. octal escape sequences, and these escape sequences all specify unibyte
  904. characters (i.e., less than 256), and there are no other literal
  905. non-@acronym{ASCII} characters or Unicode-style escape sequences in
  906. the string, then Emacs automatically assumes that it is a unibyte
  907. string. That is to say, it assumes that all non-@acronym{ASCII}
  908. characters occurring in the string are 8-bit raw bytes.
  909. In hexadecimal and octal escape sequences, the escaped character
  910. code may contain a variable number of digits, so the first subsequent
  911. character which is not a valid hexadecimal or octal digit terminates
  912. the escape sequence. If the next character in a string could be
  913. interpreted as a hexadecimal or octal digit, write @w{@samp{\ }}
  914. (backslash and space) to terminate the escape sequence. For example,
  915. @w{@samp{\xe0\ }} represents one character, @samp{a} with grave
  916. accent. @w{@samp{\ }} in a string constant is just like
  917. backslash-newline; it does not contribute any character to the string,
  918. but it does terminate any preceding hex escape.
  919. @node Nonprinting Characters
  920. @subsubsection Nonprinting Characters in Strings
  921. You can use the same backslash escape-sequences in a string constant
  922. as in character literals (but do not use the question mark that begins a
  923. character constant). For example, you can write a string containing the
  924. nonprinting characters tab and @kbd{C-a}, with commas and spaces between
  925. them, like this: @code{"\t, \C-a"}. @xref{Character Type}, for a
  926. description of the read syntax for characters.
  927. However, not all of the characters you can write with backslash
  928. escape-sequences are valid in strings. The only control characters that
  929. a string can hold are the @acronym{ASCII} control characters. Strings do not
  930. distinguish case in @acronym{ASCII} control characters.
  931. Properly speaking, strings cannot hold meta characters; but when a
  932. string is to be used as a key sequence, there is a special convention
  933. that provides a way to represent meta versions of @acronym{ASCII}
  934. characters in a string. If you use the @samp{\M-} syntax to indicate
  935. a meta character in a string constant, this sets the
  936. @tex
  937. @math{2^{7}}
  938. @end tex
  939. @ifnottex
  940. 2**7
  941. @end ifnottex
  942. bit of the character in the string. If the string is used in
  943. @code{define-key} or @code{lookup-key}, this numeric code is translated
  944. into the equivalent meta character. @xref{Character Type}.
  945. Strings cannot hold characters that have the hyper, super, or alt
  946. modifiers.
  947. @node Text Props and Strings
  948. @subsubsection Text Properties in Strings
  949. @cindex @samp{#(} read syntax
  950. @cindex text properties, read syntax
  951. A string can hold properties for the characters it contains, in
  952. addition to the characters themselves. This enables programs that copy
  953. text between strings and buffers to copy the text's properties with no
  954. special effort. @xref{Text Properties}, for an explanation of what text
  955. properties mean. Strings with text properties use a special read and
  956. print syntax:
  957. @example
  958. #("@var{characters}" @var{property-data}...)
  959. @end example
  960. @noindent
  961. where @var{property-data} consists of zero or more elements, in groups
  962. of three as follows:
  963. @example
  964. @var{beg} @var{end} @var{plist}
  965. @end example
  966. @noindent
  967. The elements @var{beg} and @var{end} are integers, and together specify
  968. a range of indices in the string; @var{plist} is the property list for
  969. that range. For example,
  970. @example
  971. #("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))
  972. @end example
  973. @noindent
  974. represents a string whose textual contents are @samp{foo bar}, in which
  975. the first three characters have a @code{face} property with value
  976. @code{bold}, and the last three have a @code{face} property with value
  977. @code{italic}. (The fourth character has no text properties, so its
  978. property list is @code{nil}. It is not actually necessary to mention
  979. ranges with @code{nil} as the property list, since any characters not
  980. mentioned in any range will default to having no properties.)
  981. @node Vector Type
  982. @subsection Vector Type
  983. A @dfn{vector} is a one-dimensional array of elements of any type. It
  984. takes a constant amount of time to access any element of a vector. (In
  985. a list, the access time of an element is proportional to the distance of
  986. the element from the beginning of the list.)
  987. The printed representation of a vector consists of a left square
  988. bracket, the elements, and a right square bracket. This is also the
  989. read syntax. Like numbers and strings, vectors are considered constants
  990. for evaluation.
  991. @example
  992. [1 "two" (three)] ; @r{A vector of three elements.}
  993. @result{} [1 "two" (three)]
  994. @end example
  995. @xref{Vectors}, for functions that work with vectors.
  996. @node Char-Table Type
  997. @subsection Char-Table Type
  998. A @dfn{char-table} is a one-dimensional array of elements of any type,
  999. indexed by character codes. Char-tables have certain extra features to
  1000. make them more useful for many jobs that involve assigning information
  1001. to character codes---for example, a char-table can have a parent to
  1002. inherit from, a default value, and a small number of extra slots to use for
  1003. special purposes. A char-table can also specify a single value for
  1004. a whole character set.
  1005. @cindex @samp{#^} read syntax
  1006. The printed representation of a char-table is like a vector
  1007. except that there is an extra @samp{#^} at the beginning.@footnote{You
  1008. may also encounter @samp{#^^}, used for sub-char-tables.}
  1009. @xref{Char-Tables}, for special functions to operate on char-tables.
  1010. Uses of char-tables include:
  1011. @itemize @bullet
  1012. @item
  1013. Case tables (@pxref{Case Tables}).
  1014. @item
  1015. Character category tables (@pxref{Categories}).
  1016. @item
  1017. Display tables (@pxref{Display Tables}).
  1018. @item
  1019. Syntax tables (@pxref{Syntax Tables}).
  1020. @end itemize
  1021. @node Bool-Vector Type
  1022. @subsection Bool-Vector Type
  1023. A @dfn{bool-vector} is a one-dimensional array whose elements must
  1024. be @code{t} or @code{nil}.
  1025. The printed representation of a bool-vector is like a string, except
  1026. that it begins with @samp{#&} followed by the length. The string
  1027. constant that follows actually specifies the contents of the bool-vector
  1028. as a bitmap---each character in the string contains 8 bits, which
  1029. specify the next 8 elements of the bool-vector (1 stands for @code{t},
  1030. and 0 for @code{nil}). The least significant bits of the character
  1031. correspond to the lowest indices in the bool-vector.
  1032. @example
  1033. (make-bool-vector 3 t)
  1034. @result{} #&3"^G"
  1035. (make-bool-vector 3 nil)
  1036. @result{} #&3"^@@"
  1037. @end example
  1038. @noindent
  1039. These results make sense, because the binary code for @samp{C-g} is
  1040. 111 and @samp{C-@@} is the character with code 0.
  1041. If the length is not a multiple of 8, the printed representation
  1042. shows extra elements, but these extras really make no difference. For
  1043. instance, in the next example, the two bool-vectors are equal, because
  1044. only the first 3 bits are used:
  1045. @example
  1046. (equal #&3"\377" #&3"\007")
  1047. @result{} t
  1048. @end example
  1049. @node Hash Table Type
  1050. @subsection Hash Table Type
  1051. A hash table is a very fast kind of lookup table, somewhat like an
  1052. alist in that it maps keys to corresponding values, but much faster.
  1053. The printed representation of a hash table specifies its properties
  1054. and contents, like this:
  1055. @example
  1056. (make-hash-table)
  1057. @result{} #s(hash-table size 65 test eql rehash-size 1.5
  1058. rehash-threshold 0.8 data ())
  1059. @end example
  1060. @noindent
  1061. @xref{Hash Tables}, for more information about hash tables.
  1062. @node Function Type
  1063. @subsection Function Type
  1064. Lisp functions are executable code, just like functions in other
  1065. programming languages. In Lisp, unlike most languages, functions are
  1066. also Lisp objects. A non-compiled function in Lisp is a lambda
  1067. expression: that is, a list whose first element is the symbol
  1068. @code{lambda} (@pxref{Lambda Expressions}).
  1069. In most programming languages, it is impossible to have a function
  1070. without a name. In Lisp, a function has no intrinsic name. A lambda
  1071. expression can be called as a function even though it has no name; to
  1072. emphasize this, we also call it an @dfn{anonymous function}
  1073. (@pxref{Anonymous Functions}). A named function in Lisp is just a
  1074. symbol with a valid function in its function cell (@pxref{Defining
  1075. Functions}).
  1076. Most of the time, functions are called when their names are written in
  1077. Lisp expressions in Lisp programs. However, you can construct or obtain
  1078. a function object at run time and then call it with the primitive
  1079. functions @code{funcall} and @code{apply}. @xref{Calling Functions}.
  1080. @node Macro Type
  1081. @subsection Macro Type
  1082. A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
  1083. language. It is represented as an object much like a function, but with
  1084. different argument-passing semantics. A Lisp macro has the form of a
  1085. list whose first element is the symbol @code{macro} and whose @sc{cdr}
  1086. is a Lisp function object, including the @code{lambda} symbol.
  1087. Lisp macro objects are usually defined with the built-in
  1088. @code{defmacro} macro, but any list that begins with @code{macro} is a
  1089. macro as far as Emacs is concerned. @xref{Macros}, for an explanation
  1090. of how to write a macro.
  1091. @strong{Warning}: Lisp macros and keyboard macros (@pxref{Keyboard
  1092. Macros}) are entirely different things. When we use the word ``macro''
  1093. without qualification, we mean a Lisp macro, not a keyboard macro.
  1094. @node Primitive Function Type
  1095. @subsection Primitive Function Type
  1096. @cindex primitive function
  1097. A @dfn{primitive function} is a function callable from Lisp but
  1098. written in the C programming language. Primitive functions are also
  1099. called @dfn{subrs} or @dfn{built-in functions}. (The word ``subr'' is
  1100. derived from ``subroutine''.) Most primitive functions evaluate all
  1101. their arguments when they are called. A primitive function that does
  1102. not evaluate all its arguments is called a @dfn{special form}
  1103. (@pxref{Special Forms}).
  1104. It does not matter to the caller of a function whether the function is
  1105. primitive. However, this does matter if you try to redefine a primitive
  1106. with a function written in Lisp. The reason is that the primitive
  1107. function may be called directly from C code. Calls to the redefined
  1108. function from Lisp will use the new definition, but calls from C code
  1109. may still use the built-in definition. Therefore, @strong{we discourage
  1110. redefinition of primitive functions}.
  1111. The term @dfn{function} refers to all Emacs functions, whether written
  1112. in Lisp or C@. @xref{Function Type}, for information about the
  1113. functions written in Lisp.
  1114. Primitive functions have no read syntax and print in hash notation
  1115. with the name of the subroutine.
  1116. @example
  1117. @group
  1118. (symbol-function 'car) ; @r{Access the function cell}
  1119. ; @r{of the symbol.}
  1120. @result{} #<subr car>
  1121. (subrp (symbol-function 'car)) ; @r{Is this a primitive function?}
  1122. @result{} t ; @r{Yes.}
  1123. @end group
  1124. @end example
  1125. @node Byte-Code Type
  1126. @subsection Byte-Code Function Type
  1127. @dfn{Byte-code function objects} are produced by byte-compiling Lisp
  1128. code (@pxref{Byte Compilation}). Internally, a byte-code function
  1129. object is much like a vector; however, the evaluator handles this data
  1130. type specially when it appears in a function call. @xref{Byte-Code
  1131. Objects}.
  1132. The printed representation and read syntax for a byte-code function
  1133. object is like that for a vector, with an additional @samp{#} before the
  1134. opening @samp{[}.
  1135. @node Autoload Type
  1136. @subsection Autoload Type
  1137. An @dfn{autoload object} is a list whose first element is the symbol
  1138. @code{autoload}. It is stored as the function definition of a symbol,
  1139. where it serves as a placeholder for the real definition. The autoload
  1140. object says that the real definition is found in a file of Lisp code
  1141. that should be loaded when necessary. It contains the name of the file,
  1142. plus some other information about the real definition.
  1143. After the file has been loaded, the symbol should have a new function
  1144. definition that is not an autoload object. The new definition is then
  1145. called as if it had been there to begin with. From the user's point of
  1146. view, the function call works as expected, using the function definition
  1147. in the loaded file.
  1148. An autoload object is usually created with the function
  1149. @code{autoload}, which stores the object in the function cell of a
  1150. symbol. @xref{Autoload}, for more details.
  1151. @node Finalizer Type
  1152. @subsection Finalizer Type
  1153. A @dfn{finalizer object} helps Lisp code clean up after objects that
  1154. are no longer needed. A finalizer holds a Lisp function object.
  1155. When a finalizer object becomes unreachable after a garbage collection
  1156. pass, Emacs calls the finalizer's associated function object.
  1157. When deciding whether a finalizer is reachable, Emacs does not count
  1158. references from finalizer objects themselves, allowing you to use
  1159. finalizers without having to worry about accidentally capturing
  1160. references to finalized objects themselves.
  1161. Errors in finalizers are printed to @code{*Messages*}. Emacs runs
  1162. a given finalizer object's associated function exactly once, even
  1163. if that function fails.
  1164. @defun make-finalizer function
  1165. Make a finalizer that will run @var{function}. @var{function} will be
  1166. called after garbage collection when the returned finalizer object
  1167. becomes unreachable. If the finalizer object is reachable only
  1168. through references from finalizer objects, it does not count as
  1169. reachable for the purpose of deciding whether to run @var{function}.
  1170. @var{function} will be run once per finalizer object.
  1171. @end defun
  1172. @node Editing Types
  1173. @section Editing Types
  1174. @cindex editing types
  1175. The types in the previous section are used for general programming
  1176. purposes, and most of them are common to most Lisp dialects. Emacs Lisp
  1177. provides several additional data types for purposes connected with
  1178. editing.
  1179. @menu
  1180. * Buffer Type:: The basic object of editing.
  1181. * Marker Type:: A position in a buffer.
  1182. * Window Type:: Buffers are displayed in windows.
  1183. * Frame Type:: Windows subdivide frames.
  1184. * Terminal Type:: A terminal device displays frames.
  1185. * Window Configuration Type:: Recording the way a frame is subdivided.
  1186. * Frame Configuration Type:: Recording the status of all frames.
  1187. * Process Type:: A subprocess of Emacs running on the underlying OS.
  1188. * Stream Type:: Receive or send characters.
  1189. * Keymap Type:: What function a keystroke invokes.
  1190. * Overlay Type:: How an overlay is represented.
  1191. * Font Type:: Fonts for displaying text.
  1192. @end menu
  1193. @node Buffer Type
  1194. @subsection Buffer Type
  1195. A @dfn{buffer} is an object that holds text that can be edited
  1196. (@pxref{Buffers}). Most buffers hold the contents of a disk file
  1197. (@pxref{Files}) so they can be edited, but some are used for other
  1198. purposes. Most buffers are also meant to be seen by the user, and
  1199. therefore displayed, at some time, in a window (@pxref{Windows}). But
  1200. a buffer need not be displayed in any window. Each buffer has a
  1201. designated position called @dfn{point} (@pxref{Positions}); most
  1202. editing commands act on the contents of the current buffer in the
  1203. neighborhood of point. At any time, one buffer is the @dfn{current
  1204. buffer}.
  1205. The contents of a buffer are much like a string, but buffers are not
  1206. used like strings in Emacs Lisp, and the available operations are
  1207. different. For example, you can insert text efficiently into an
  1208. existing buffer, altering the buffer's contents, whereas inserting
  1209. text into a string requires concatenating substrings, and the result
  1210. is an entirely new string object.
  1211. Many of the standard Emacs functions manipulate or test the
  1212. characters in the current buffer; a whole chapter in this manual is
  1213. devoted to describing these functions (@pxref{Text}).
  1214. Several other data structures are associated with each buffer:
  1215. @itemize @bullet
  1216. @item
  1217. a local syntax table (@pxref{Syntax Tables});
  1218. @item
  1219. a local keymap (@pxref{Keymaps}); and,
  1220. @item
  1221. a list of buffer-local variable bindings (@pxref{Buffer-Local Variables}).
  1222. @item
  1223. overlays (@pxref{Overlays}).
  1224. @item
  1225. text properties for the text in the buffer (@pxref{Text Properties}).
  1226. @end itemize
  1227. @noindent
  1228. The local keymap and variable list contain entries that individually
  1229. override global bindings or values. These are used to customize the
  1230. behavior of programs in different buffers, without actually changing the
  1231. programs.
  1232. A buffer may be @dfn{indirect}, which means it shares the text
  1233. of another buffer, but presents it differently. @xref{Indirect Buffers}.
  1234. Buffers have no read syntax. They print in hash notation, showing the
  1235. buffer name.
  1236. @example
  1237. @group
  1238. (current-buffer)
  1239. @result{} #<buffer objects.texi>
  1240. @end group
  1241. @end example
  1242. @node Marker Type
  1243. @subsection Marker Type
  1244. A @dfn{marker} denotes a position in a specific buffer. Markers
  1245. therefore have two components: one for the buffer, and one for the
  1246. position. Changes in the buffer's text automatically relocate the
  1247. position value as necessary to ensure that the marker always points
  1248. between the same two characters in the buffer.
  1249. Markers have no read syntax. They print in hash notation, giving the
  1250. current character position and the name of the buffer.
  1251. @example
  1252. @group
  1253. (point-marker)
  1254. @result{} #<marker at 10779 in objects.texi>
  1255. @end group
  1256. @end example
  1257. @xref{Markers}, for information on how to test, create, copy, and move
  1258. markers.
  1259. @node Window Type
  1260. @subsection Window Type
  1261. A @dfn{window} describes the portion of the terminal screen that Emacs
  1262. uses to display a buffer. Every window has one associated buffer, whose
  1263. contents appear in the window. By contrast, a given buffer may appear
  1264. in one window, no window, or several windows.
  1265. Though many windows may exist simultaneously, at any time one window
  1266. is designated the @dfn{selected window}. This is the window where the
  1267. cursor is (usually) displayed when Emacs is ready for a command. The
  1268. selected window usually displays the current buffer (@pxref{Current
  1269. Buffer}), but this is not necessarily the case.
  1270. Windows are grouped on the screen into frames; each window belongs to
  1271. one and only one frame. @xref{Frame Type}.
  1272. Windows have no read syntax. They print in hash notation, giving the
  1273. window number and the name of the buffer being displayed. The window
  1274. numbers exist to identify windows uniquely, since the buffer displayed
  1275. in any given window can change frequently.
  1276. @example
  1277. @group
  1278. (selected-window)
  1279. @result{} #<window 1 on objects.texi>
  1280. @end group
  1281. @end example
  1282. @xref{Windows}, for a description of the functions that work on windows.
  1283. @node Frame Type
  1284. @subsection Frame Type
  1285. A @dfn{frame} is a screen area that contains one or more Emacs
  1286. windows; we also use the term ``frame'' to refer to the Lisp object
  1287. that Emacs uses to refer to the screen area.
  1288. Frames have no read syntax. They print in hash notation, giving the
  1289. frame's title, plus its address in core (useful to identify the frame
  1290. uniquely).
  1291. @example
  1292. @group
  1293. (selected-frame)
  1294. @result{} #<frame emacs@@psilocin.gnu.org 0xdac80>
  1295. @end group
  1296. @end example
  1297. @xref{Frames}, for a description of the functions that work on frames.
  1298. @node Terminal Type
  1299. @subsection Terminal Type
  1300. @cindex terminal type
  1301. A @dfn{terminal} is a device capable of displaying one or more
  1302. Emacs frames (@pxref{Frame Type}).
  1303. Terminals have no read syntax. They print in hash notation giving
  1304. the terminal's ordinal number and its TTY device file name.
  1305. @example
  1306. @group
  1307. (get-device-terminal nil)
  1308. @result{} #<terminal 1 on /dev/tty>
  1309. @end group
  1310. @end example
  1311. @c FIXME: add an xref to where terminal-related primitives are described.
  1312. @node Window Configuration Type
  1313. @subsection Window Configuration Type
  1314. @cindex window layout in a frame
  1315. A @dfn{window configuration} stores information about the positions,
  1316. sizes, and contents of the windows in a frame, so you can recreate the
  1317. same arrangement of windows later.
  1318. Window configurations do not have a read syntax; their print syntax
  1319. looks like @samp{#<window-configuration>}. @xref{Window
  1320. Configurations}, for a description of several functions related to
  1321. window configurations.
  1322. @node Frame Configuration Type
  1323. @subsection Frame Configuration Type
  1324. @cindex screen layout
  1325. @cindex window layout, all frames
  1326. A @dfn{frame configuration} stores information about the positions,
  1327. sizes, and contents of the windows in all frames. It is not a
  1328. primitive type---it is actually a list whose @sc{car} is
  1329. @code{frame-configuration} and whose @sc{cdr} is an alist. Each alist
  1330. element describes one frame, which appears as the @sc{car} of that
  1331. element.
  1332. @xref{Frame Configurations}, for a description of several functions
  1333. related to frame configurations.
  1334. @node Process Type
  1335. @subsection Process Type
  1336. The word @dfn{process} usually means a running program. Emacs itself
  1337. runs in a process of this sort. However, in Emacs Lisp, a process is a
  1338. Lisp object that designates a subprocess created by the Emacs process.
  1339. Programs such as shells, GDB, ftp, and compilers, running in
  1340. subprocesses of Emacs, extend the capabilities of Emacs.
  1341. An Emacs subprocess takes textual input from Emacs and returns textual
  1342. output to Emacs for further manipulation. Emacs can also send signals
  1343. to the subprocess.
  1344. Process objects have no read syntax. They print in hash notation,
  1345. giving the name of the process:
  1346. @example
  1347. @group
  1348. (process-list)
  1349. @result{} (#<process shell>)
  1350. @end group
  1351. @end example
  1352. @xref{Processes}, for information about functions that create, delete,
  1353. return information about, send input or signals to, and receive output
  1354. from processes.
  1355. @node Stream Type
  1356. @subsection Stream Type
  1357. A @dfn{stream} is an object that can be used as a source or sink for
  1358. characters---either to supply characters for input or to accept them as
  1359. output. Many different types can be used this way: markers, buffers,
  1360. strings, and functions. Most often, input streams (character sources)
  1361. obtain characters from the keyboard, a buffer, or a file, and output
  1362. streams (character sinks) send characters to a buffer, such as a
  1363. @file{*Help*} buffer, or to the echo area.
  1364. The object @code{nil}, in addition to its other meanings, may be used
  1365. as a stream. It stands for the value of the variable
  1366. @code{standard-input} or @code{standard-output}. Also, the object
  1367. @code{t} as a stream specifies input using the minibuffer
  1368. (@pxref{Minibuffers}) or output in the echo area (@pxref{The Echo
  1369. Area}).
  1370. Streams have no special printed representation or read syntax, and
  1371. print as whatever primitive type they are.
  1372. @xref{Read and Print}, for a description of functions
  1373. related to streams, including parsing and printing functions.
  1374. @node Keymap Type
  1375. @subsection Keymap Type
  1376. A @dfn{keymap} maps keys typed by the user to commands. This mapping
  1377. controls how the user's command input is executed. A keymap is actually
  1378. a list whose @sc{car} is the symbol @code{keymap}.
  1379. @xref{Keymaps}, for information about creating keymaps, handling prefix
  1380. keys, local as well as global keymaps, and changing key bindings.
  1381. @node Overlay Type
  1382. @subsection Overlay Type
  1383. An @dfn{overlay} specifies properties that apply to a part of a
  1384. buffer. Each overlay applies to a specified range of the buffer, and
  1385. contains a property list (a list whose elements are alternating property
  1386. names and values). Overlay properties are used to present parts of the
  1387. buffer temporarily in a different display style. Overlays have no read
  1388. syntax, and print in hash notation, giving the buffer name and range of
  1389. positions.
  1390. @xref{Overlays}, for information on how you can create and use overlays.
  1391. @node Font Type
  1392. @subsection Font Type
  1393. A @dfn{font} specifies how to display text on a graphical terminal.
  1394. There are actually three separate font types---@dfn{font objects},
  1395. @dfn{font specs}, and @dfn{font entities}---each of which has slightly
  1396. different properties. None of them have a read syntax; their print
  1397. syntax looks like @samp{#<font-object>}, @samp{#<font-spec>}, and
  1398. @samp{#<font-entity>} respectively. @xref{Low-Level Font}, for a
  1399. description of these Lisp objects.
  1400. @node Circular Objects
  1401. @section Read Syntax for Circular Objects
  1402. @cindex circular structure, read syntax
  1403. @cindex shared structure, read syntax
  1404. @cindex @samp{#@var{n}=} read syntax
  1405. @cindex @samp{#@var{n}#} read syntax
  1406. To represent shared or circular structures within a complex of Lisp
  1407. objects, you can use the reader constructs @samp{#@var{n}=} and
  1408. @samp{#@var{n}#}.
  1409. Use @code{#@var{n}=} before an object to label it for later reference;
  1410. subsequently, you can use @code{#@var{n}#} to refer the same object in
  1411. another place. Here, @var{n} is some integer. For example, here is how
  1412. to make a list in which the first element recurs as the third element:
  1413. @example
  1414. (#1=(a) b #1#)
  1415. @end example
  1416. @noindent
  1417. This differs from ordinary syntax such as this
  1418. @example
  1419. ((a) b (a))
  1420. @end example
  1421. @noindent
  1422. which would result in a list whose first and third elements
  1423. look alike but are not the same Lisp object. This shows the difference:
  1424. @example
  1425. (prog1 nil
  1426. (setq x '(#1=(a) b #1#)))
  1427. (eq (nth 0 x) (nth 2 x))
  1428. @result{} t
  1429. (setq x '((a) b (a)))
  1430. (eq (nth 0 x) (nth 2 x))
  1431. @result{} nil
  1432. @end example
  1433. You can also use the same syntax to make a circular structure, which
  1434. appears as an element within itself. Here is an example:
  1435. @example
  1436. #1=(a #1#)
  1437. @end example
  1438. @noindent
  1439. This makes a list whose second element is the list itself.
  1440. Here's how you can see that it really works:
  1441. @example
  1442. (prog1 nil
  1443. (setq x '#1=(a #1#)))
  1444. (eq x (cadr x))
  1445. @result{} t
  1446. @end example
  1447. The Lisp printer can produce this syntax to record circular and shared
  1448. structure in a Lisp object, if you bind the variable @code{print-circle}
  1449. to a non-@code{nil} value. @xref{Output Variables}.
  1450. @node Type Predicates
  1451. @section Type Predicates
  1452. @cindex type checking
  1453. @kindex wrong-type-argument
  1454. The Emacs Lisp interpreter itself does not perform type checking on
  1455. the actual arguments passed to functions when they are called. It could
  1456. not do so, since function arguments in Lisp do not have declared data
  1457. types, as they do in other programming languages. It is therefore up to
  1458. the individual function to test whether each actual argument belongs to
  1459. a type that the function can use.
  1460. All built-in functions do check the types of their actual arguments
  1461. when appropriate, and signal a @code{wrong-type-argument} error if an
  1462. argument is of the wrong type. For example, here is what happens if you
  1463. pass an argument to @code{+} that it cannot handle:
  1464. @example
  1465. @group
  1466. (+ 2 'a)
  1467. @error{} Wrong type argument: number-or-marker-p, a
  1468. @end group
  1469. @end example
  1470. @cindex type predicates
  1471. @cindex testing types
  1472. If you want your program to handle different types differently, you
  1473. must do explicit type checking. The most common way to check the type
  1474. of an object is to call a @dfn{type predicate} function. Emacs has a
  1475. type predicate for each type, as well as some predicates for
  1476. combinations of types.
  1477. A type predicate function takes one argument; it returns @code{t} if
  1478. the argument belongs to the appropriate type, and @code{nil} otherwise.
  1479. Following a general Lisp convention for predicate functions, most type
  1480. predicates' names end with @samp{p}.
  1481. Here is an example which uses the predicates @code{listp} to check for
  1482. a list and @code{symbolp} to check for a symbol.
  1483. @example
  1484. (defun add-on (x)
  1485. (cond ((symbolp x)
  1486. ;; If X is a symbol, put it on LIST.
  1487. (setq list (cons x list)))
  1488. ((listp x)
  1489. ;; If X is a list, add its elements to LIST.
  1490. (setq list (append x list)))
  1491. (t
  1492. ;; We handle only symbols and lists.
  1493. (error "Invalid argument %s in add-on" x))))
  1494. @end example
  1495. Here is a table of predefined type predicates, in alphabetical order,
  1496. with references to further information.
  1497. @table @code
  1498. @item atom
  1499. @xref{List-related Predicates, atom}.
  1500. @item arrayp
  1501. @xref{Array Functions, arrayp}.
  1502. @item bool-vector-p
  1503. @xref{Bool-Vectors, bool-vector-p}.
  1504. @item bufferp
  1505. @xref{Buffer Basics, bufferp}.
  1506. @item byte-code-function-p
  1507. @xref{Byte-Code Type, byte-code-function-p}.
  1508. @item case-table-p
  1509. @xref{Case Tables, case-table-p}.
  1510. @item char-or-string-p
  1511. @xref{Predicates for Strings, char-or-string-p}.
  1512. @item char-table-p
  1513. @xref{Char-Tables, char-table-p}.
  1514. @item commandp
  1515. @xref{Interactive Call, commandp}.
  1516. @item consp
  1517. @xref{List-related Predicates, consp}.
  1518. @item custom-variable-p
  1519. @xref{Variable Definitions, custom-variable-p}.
  1520. @item floatp
  1521. @xref{Predicates on Numbers, floatp}.
  1522. @item fontp
  1523. @xref{Low-Level Font}.
  1524. @item frame-configuration-p
  1525. @xref{Frame Configurations, frame-configuration-p}.
  1526. @item frame-live-p
  1527. @xref{Deleting Frames, frame-live-p}.
  1528. @item framep
  1529. @xref{Frames, framep}.
  1530. @item functionp
  1531. @xref{Functions, functionp}.
  1532. @item hash-table-p
  1533. @xref{Other Hash, hash-table-p}.
  1534. @item integer-or-marker-p
  1535. @xref{Predicates on Markers, integer-or-marker-p}.
  1536. @item integerp
  1537. @xref{Predicates on Numbers, integerp}.
  1538. @item keymapp
  1539. @xref{Creating Keymaps, keymapp}.
  1540. @item keywordp
  1541. @xref{Constant Variables}.
  1542. @item listp
  1543. @xref{List-related Predicates, listp}.
  1544. @item markerp
  1545. @xref{Predicates on Markers, markerp}.
  1546. @item wholenump
  1547. @xref{Predicates on Numbers, wholenump}.
  1548. @item nlistp
  1549. @xref{List-related Predicates, nlistp}.
  1550. @item numberp
  1551. @xref{Predicates on Numbers, numberp}.
  1552. @item number-or-marker-p
  1553. @xref{Predicates on Markers, number-or-marker-p}.
  1554. @item overlayp
  1555. @xref{Overlays, overlayp}.
  1556. @item processp
  1557. @xref{Processes, processp}.
  1558. @item sequencep
  1559. @xref{Sequence Functions, sequencep}.
  1560. @item stringp
  1561. @xref{Predicates for Strings, stringp}.
  1562. @item subrp
  1563. @xref{Function Cells, subrp}.
  1564. @item symbolp
  1565. @xref{Symbols, symbolp}.
  1566. @item syntax-table-p
  1567. @xref{Syntax Tables, syntax-table-p}.
  1568. @item vectorp
  1569. @xref{Vectors, vectorp}.
  1570. @item window-configuration-p
  1571. @xref{Window Configurations, window-configuration-p}.
  1572. @item window-live-p
  1573. @xref{Deleting Windows, window-live-p}.
  1574. @item windowp
  1575. @xref{Basic Windows, windowp}.
  1576. @item booleanp
  1577. @xref{nil and t, booleanp}.
  1578. @item string-or-null-p
  1579. @xref{Predicates for Strings, string-or-null-p}.
  1580. @end table
  1581. The most general way to check the type of an object is to call the
  1582. function @code{type-of}. Recall that each object belongs to one and
  1583. only one primitive type; @code{type-of} tells you which one (@pxref{Lisp
  1584. Data Types}). But @code{type-of} knows nothing about non-primitive
  1585. types. In most cases, it is more convenient to use type predicates than
  1586. @code{type-of}.
  1587. @defun type-of object
  1588. This function returns a symbol naming the primitive type of
  1589. @var{object}. The value is one of the symbols @code{bool-vector},
  1590. @code{buffer}, @code{char-table}, @code{compiled-function},
  1591. @code{cons}, @code{finalizer}, @code{float}, @code{font-entity},
  1592. @code{font-object}, @code{font-spec}, @code{frame}, @code{hash-table},
  1593. @code{integer}, @code{marker}, @code{overlay}, @code{process},
  1594. @code{string}, @code{subr}, @code{symbol}, @code{vector},
  1595. @code{window}, or @code{window-configuration}.
  1596. @example
  1597. (type-of 1)
  1598. @result{} integer
  1599. @group
  1600. (type-of 'nil)
  1601. @result{} symbol
  1602. (type-of '()) ; @r{@code{()} is @code{nil}.}
  1603. @result{} symbol
  1604. (type-of '(x))
  1605. @result{} cons
  1606. @end group
  1607. @end example
  1608. @end defun
  1609. @node Equality Predicates
  1610. @section Equality Predicates
  1611. @cindex equality
  1612. Here we describe functions that test for equality between two
  1613. objects. Other functions test equality of contents between objects of
  1614. specific types, e.g., strings. For these predicates, see the
  1615. appropriate chapter describing the data type.
  1616. @defun eq object1 object2
  1617. This function returns @code{t} if @var{object1} and @var{object2} are
  1618. the same object, and @code{nil} otherwise.
  1619. If @var{object1} and @var{object2} are integers with the same value,
  1620. they are considered to be the same object (i.e., @code{eq} returns
  1621. @code{t}). If @var{object1} and @var{object2} are symbols with the
  1622. same name, they are normally the same object---but see @ref{Creating
  1623. Symbols} for exceptions. For other types (e.g., lists, vectors,
  1624. strings), two arguments with the same contents or elements are not
  1625. necessarily @code{eq} to each other: they are @code{eq} only if they
  1626. are the same object, meaning that a change in the contents of one will
  1627. be reflected by the same change in the contents of the other.
  1628. @example
  1629. @group
  1630. (eq 'foo 'foo)
  1631. @result{} t
  1632. @end group
  1633. @group
  1634. (eq 456 456)
  1635. @result{} t
  1636. @end group
  1637. @group
  1638. (eq "asdf" "asdf")
  1639. @result{} nil
  1640. @end group
  1641. @group
  1642. (eq "" "")
  1643. @result{} t
  1644. ;; @r{This exception occurs because Emacs Lisp}
  1645. ;; @r{makes just one multibyte empty string, to save space.}
  1646. @end group
  1647. @group
  1648. (eq '(1 (2 (3))) '(1 (2 (3))))
  1649. @result{} nil
  1650. @end group
  1651. @group
  1652. (setq foo '(1 (2 (3))))
  1653. @result{} (1 (2 (3)))
  1654. (eq foo foo)
  1655. @result{} t
  1656. (eq foo '(1 (2 (3))))
  1657. @result{} nil
  1658. @end group
  1659. @group
  1660. (eq [(1 2) 3] [(1 2) 3])
  1661. @result{} nil
  1662. @end group
  1663. @group
  1664. (eq (point-marker) (point-marker))
  1665. @result{} nil
  1666. @end group
  1667. @end example
  1668. @noindent
  1669. The @code{make-symbol} function returns an uninterned symbol, distinct
  1670. from the symbol that is used if you write the name in a Lisp expression.
  1671. Distinct symbols with the same name are not @code{eq}. @xref{Creating
  1672. Symbols}.
  1673. @example
  1674. @group
  1675. (eq (make-symbol "foo") 'foo)
  1676. @result{} nil
  1677. @end group
  1678. @end example
  1679. @end defun
  1680. @defun equal object1 object2
  1681. This function returns @code{t} if @var{object1} and @var{object2} have
  1682. equal components, and @code{nil} otherwise. Whereas @code{eq} tests
  1683. if its arguments are the same object, @code{equal} looks inside
  1684. nonidentical arguments to see if their elements or contents are the
  1685. same. So, if two objects are @code{eq}, they are @code{equal}, but
  1686. the converse is not always true.
  1687. @example
  1688. @group
  1689. (equal 'foo 'foo)
  1690. @result{} t
  1691. @end group
  1692. @group
  1693. (equal 456 456)
  1694. @result{} t
  1695. @end group
  1696. @group
  1697. (equal "asdf" "asdf")
  1698. @result{} t
  1699. @end group
  1700. @group
  1701. (eq "asdf" "asdf")
  1702. @result{} nil
  1703. @end group
  1704. @group
  1705. (equal '(1 (2 (3))) '(1 (2 (3))))
  1706. @result{} t
  1707. @end group
  1708. @group
  1709. (eq '(1 (2 (3))) '(1 (2 (3))))
  1710. @result{} nil
  1711. @end group
  1712. @group
  1713. (equal [(1 2) 3] [(1 2) 3])
  1714. @result{} t
  1715. @end group
  1716. @group
  1717. (eq [(1 2) 3] [(1 2) 3])
  1718. @result{} nil
  1719. @end group
  1720. @group
  1721. (equal (point-marker) (point-marker))
  1722. @result{} t
  1723. @end group
  1724. @group
  1725. (eq (point-marker) (point-marker))
  1726. @result{} nil
  1727. @end group
  1728. @end example
  1729. Comparison of strings is case-sensitive, but does not take account of
  1730. text properties---it compares only the characters in the strings.
  1731. @xref{Text Properties}. Use @code{equal-including-properties} to also
  1732. compare text properties. For technical reasons, a unibyte string and
  1733. a multibyte string are @code{equal} if and only if they contain the
  1734. same sequence of character codes and all these codes are either in the
  1735. range 0 through 127 (@acronym{ASCII}) or 160 through 255
  1736. (@code{eight-bit-graphic}). (@pxref{Text Representations}).
  1737. @example
  1738. @group
  1739. (equal "asdf" "ASDF")
  1740. @result{} nil
  1741. @end group
  1742. @end example
  1743. However, two distinct buffers are never considered @code{equal}, even if
  1744. their textual contents are the same.
  1745. @end defun
  1746. The test for equality is implemented recursively; for example, given
  1747. two cons cells @var{x} and @var{y}, @code{(equal @var{x} @var{y})}
  1748. returns @code{t} if and only if both the expressions below return
  1749. @code{t}:
  1750. @example
  1751. (equal (car @var{x}) (car @var{y}))
  1752. (equal (cdr @var{x}) (cdr @var{y}))
  1753. @end example
  1754. Because of this recursive method, circular lists may therefore cause
  1755. infinite recursion (leading to an error).
  1756. @defun equal-including-properties object1 object2
  1757. This function behaves like @code{equal} in all cases but also requires
  1758. that for two strings to be equal, they have the same text properties.
  1759. @example
  1760. @group
  1761. (equal "asdf" (propertize "asdf" 'asdf t))
  1762. @result{} t
  1763. @end group
  1764. @group
  1765. (equal-including-properties "asdf"
  1766. (propertize "asdf" 'asdf t))
  1767. @result{} nil
  1768. @end group
  1769. @end example
  1770. @end defun