picolisp

Unnamed repository; edit this file to name it for gitweb.
git clone https://logand.com/git/picolisp.git/
Log | Files | Refs | README | LICENSE

refL.html (21087B)


      1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/1998/REC-html40-19980424/loose.dtd">
      2 <html lang="en">
      3 <head>
      4 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      5 <title>L</title>
      6 <link rel="stylesheet" href="doc.css" type="text/css">
      7 </head>
      8 <body>
      9 
     10 <h1>L</h1>
     11 
     12 <dl>
     13 
     14 <dt><a name="*Led"><code>*Led</code></a>
     15 <dd>(Debug mode only) A global variable holding a (possibly empty)
     16 <code>prg</code> body that implements a "Line editor". When
     17 non-<code>NIL</code>, it should return a single symbol (string) upon execution.
     18 
     19 <pre><code>
     20 : (de *Led "(bye)")
     21 # *Led redefined
     22 -> *Led
     23 : $                                    # Exit
     24 </code></pre>
     25 
     26 <dt><a name="+Link"><code>+Link</code></a>
     27 <dd>Class for object relations, a subclass of <code><a
     28 href="refR.html#+relation">+relation</a></code>. Expects a list of classes as
     29 <code><a href="refT.html#type">type</a></code> of the referred database object
     30 (of class <code><a href="refE.html#+Entity">+Entity</a></code>). See also <a
     31 href="ref.html#dbase">Database</a>.
     32 
     33 <pre><code>
     34 (rel sup (+Ref +Link) NIL (+CuSu))  # Supplier (class Customer/Supplier)
     35 </code></pre>
     36 
     37 <dt><a name="+List"><code>+List</code></a>
     38 <dd>Prefix class for a list of identical relations. Objects of that class
     39 maintain a list of Lisp data of uniform type. See also <a
     40 href="ref.html#dbase">Database</a>.
     41 
     42 <pre><code>
     43 (rel pos (+List +Joint) ord (+Pos))  # Positions
     44 (rel nm (+List +Fold +Ref +String))  # List of folded and indexed names
     45 (rel val (+Ref +List +Number))       # Indexed list of numeric values
     46 </code></pre>
     47 
     48 <dt><a name="last"><code>(last 'lst) -> any</code></a>
     49 <dd>Returns the last element of <code>lst</code>. See also <code><a
     50 href="refF.html#fin">fin</a></code> and <code><a
     51 href="refT.html#tail">tail</a></code>.
     52 
     53 <pre><code>
     54 : (last (1 2 3 4))
     55 -> 4
     56 : (last '((a b) c (d e f)))
     57 -> (d e f)
     58 </code></pre>
     59 
     60 <dt><a name="later"><code>(later 'var . prg) -> var</code></a>
     61 <dd>Executes <code>prg</code> in a <code><a
     62 href="refP.html#pipe">pipe</a></code>'ed child process. The return value of
     63 <code>prg</code> will later be available in <code>var</code>.
     64 
     65 <pre><code>
     66 : (prog1  # Parallel background calculation of square numbers
     67    (mapcan '((N) (later (cons) (* N N))) (1 2 3 4))
     68    (wait NIL (full @)) )
     69 -> (1 4 9 16)
     70 </code></pre>
     71 
     72 <dt><a name="ld"><code>(ld) -> any</code></a>
     73 <dd>(Debug mode only) <code><a href="refL.html#load">load</a></code>s the last
     74 file edited with <code><a href="refV.html#vi">vi</a></code> or <code><a
     75 href="refE.html#em">em</a></code>.
     76 
     77 <pre><code>
     78 : (vi 'main)
     79 -> T
     80 : (ld)
     81 # main redefined
     82 -> go
     83 </code></pre>
     84 
     85 <dt><a name="le0"><code>(le0 'any) -> num | NIL</code></a>
     86 <dd>Returns <code>num</code> when the argument is a number less or equal zero,
     87 otherwise <code>NIL</code>. See also <code><a
     88 href="refL.html#lt0">lt0</a></code>, <code><a
     89 href="refG.html#ge0">ge0</a></code>, <code><a
     90 href="refG.html#gt0">gt0</a></code>, <code><a href="ref_.html#=0">=0</a></code>
     91 and <code><a href="refN.html#n0">n0</a></code>.
     92 
     93 <pre><code>
     94 : (le0 -2)
     95 -> -2
     96 : (le0 0)
     97 -> 0
     98 : (le0 3)
     99 -> NIL
    100 </code></pre>
    101 
    102 <dt><a name="leaf"><code>(leaf 'tree) -> any</code></a>
    103 <dd>Returns the first leaf (i.e. the value of the smallest key) in a database
    104 tree. See also <code><a href="refT.html#tree">tree</a></code>, <code><a
    105 href="refM.html#minKey">minKey</a></code>, <code><a
    106 href="refM.html#maxKey">maxKey</a></code> and <code><a
    107 href="refS.html#step">step</a></code>.
    108 
    109 <pre><code>
    110 : (leaf (tree 'nr '+Item))
    111 -> {3-1}
    112 : (db 'nr '+Item (minKey (tree 'nr '+Item)))
    113 -> {3-1}
    114 </code></pre>
    115 
    116 <dt><a name="length"><code>(length 'any) -> cnt | T</code></a>
    117 <dd>Returns the "length" of <code>any</code>. For numbers this is the number of
    118 decimal digits in the value (plus 1 for negative values), for symbols it is the
    119 number of characters in the name, and for lists it is the number of cells (or
    120 <code>T</code> for circular lists). See also <code><a
    121 href="refS.html#size">size</a></code> and <code><a
    122 href="refB.html#bytes">bytes</a></code>.
    123 
    124 <pre><code>
    125 : (length "abc")
    126 -> 3
    127 : (length "äbc")
    128 -> 3
    129 : (length 123)
    130 -> 3
    131 : (length (1 (2) 3))
    132 -> 3
    133 : (length (1 2 3 .))
    134 -> T
    135 </code></pre>
    136 
    137 <dt><a name="let"><code>(let sym 'any . prg) -> any</code></a>
    138 <dt><code>(let (sym 'any ..) . prg) -> any</code>
    139 <dd>Defines local variables. The value of the symbol <code>sym</code> - or the
    140 values of the symbols <code>sym</code> in the list of the second form - are
    141 saved and the symbols are bound to the evaluated <code>any</code> arguments.
    142 <code>prg</code> is executed, then the symbols are restored to their original
    143 values. The result of <code>prg</code> is returned. It is an error condition to
    144 pass <code>NIL</code> as a <code>sym</code> argument. See also <code><a
    145 href="refL.html#let?">let?</a></code>, <code><a
    146 href="refB.html#bind">bind</a></code>, <code><a
    147 href="refR.html#recur">recur</a></code>, <code><a
    148 href="refW.html#with">with</a></code>, <code><a
    149 href="refF.html#for">for</a></code>, <code><a
    150 href="refJ.html#job">job</a></code> and <code><a
    151 href="refU.html#use">use</a></code>.
    152 
    153 <pre><code>
    154 : (setq  X 123  Y 456)
    155 -> 456
    156 : (let X "Hello" (println X))
    157 "Hello"
    158 -> "Hello"
    159 : (let (X "Hello" Y "world") (prinl X " " Y))
    160 Hello world
    161 -> "world"
    162 : X
    163 -> 123
    164 : Y
    165 -> 456
    166 </code></pre>
    167 
    168 <dt><a name="let?"><code>(let? sym 'any . prg) -> any</code></a>
    169 <dd>Conditional local variable binding and execution: If <code>any</code>
    170 evalutes to <code>NIL</code>, <code>NIL</code> is returned. Otherwise, the value
    171 of the symbol <code>sym</code> is saved and <code>sym</code> is bound to the
    172 evaluated <code>any</code> argument. <code>prg</code> is executed, then
    173 <code>sym</code> is restored to its original value. The result of
    174 <code>prg</code> is returned. It is an error condition to pass <code>NIL</code>
    175 as the <code>sym</code> argument. <code>(let? sym 'any ..)</code> is equivalent
    176 to <code>(when 'any (let sym @ ..))</code>. See also <code><a
    177 href="refL.html#let">let</a></code>, <code><a
    178 href="refB.html#bind">bind</a></code>, <code><a
    179 href="refJ.html#job">job</a></code> and <code><a
    180 href="refU.html#use">use</a></code>.
    181 
    182 <pre><code>
    183 : (setq Lst (1 NIL 2 NIL 3))
    184 -> (1 NIL 2 NIL 3)
    185 : (let? A (pop 'Lst) (println 'A A))
    186 A 1
    187 -> 1
    188 : (let? A (pop 'Lst) (println 'A A))
    189 -> NIL
    190 </code></pre>
    191 
    192 <dt><a name="lieu"><code>(lieu 'any) -> sym | NIL</code></a>
    193 <dd>Returns the argument <code>any</code> when it is an external symbol and
    194 currently manifest in heap space, otherwise <code>NIL</code>. See also <code><a
    195 href="refE.html#ext?">ext?</a></code>.
    196 
    197 <pre><code>
    198 : (lieu *DB)
    199 -> {1}
    200 </code></pre>
    201 
    202 <dt><a name="line"><code>(line 'flg ['cnt ..]) -> lst|sym</code></a>
    203 <dd>Reads a line of characters from the current input channel. End of line is
    204 recognized as linefeed (hex "0A"), carriage return (hex "0D"), or the
    205 combination of both. (Note that a single carriage return may not work on network
    206 connections, because the character look-ahead to distinguish from
    207 return+linefeed can block the connection.) If <code>flg</code> is
    208 <code>NIL</code>, a list of single-character transient symbols is returned. When
    209 <code>cnt</code> arguments are given, subsequent characters of the input line
    210 are grouped into sublists, to allow parsing of fixed field length records. If
    211 <code>flg</code> is non-<code>NIL</code>, strings are returned instead of
    212 single-character lists. <code>NIL</code> is returned upon end of file. See also
    213 <code><a href="refC.html#char">char</a></code>, <code><a
    214 href="refR.html#read">read</a></code>, <code><a
    215 href="refT.html#till">till</a></code> and <code><a
    216 href="refE.html#eof">eof</a></code>.
    217 
    218 <pre><code>
    219 : (line)
    220 abcdefghijkl
    221 -> ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l")
    222 : (line T)
    223 abcdefghijkl
    224 -> "abcdefghijkl"
    225 : (line NIL 1 2 3)
    226 abcdefghijkl
    227 -> (("a") ("b" "c") ("d" "e" "f") "g" "h" "i" "j" "k" "l")
    228 : (line T 1 2 3)
    229 abcdefghijkl
    230 -> ("a" "bc" "def" "g" "h" "i" "j" "k" "l")
    231 </code></pre>
    232 
    233 <dt><a name="lines"><code>(lines 'any ..) -> cnt</code></a>
    234 <dd>Returns the sum of the number of lines in the files with the names
    235 <code>any</code>, or <code>NIL</code> if none was found. See also <code><a
    236 href="refI.html#info">info</a></code>.
    237 
    238 <pre><code>
    239 : (lines "x.l")
    240 -> 11
    241 </code></pre>
    242 
    243 <dt><a name="link"><code>(link 'any ..) -> any</code></a>
    244 <dd>Links one or several new elements <code>any</code> to the end of the list in
    245 the current <code><a href="refM.html#make">make</a></code> environment. This
    246 operation is efficient also for long lists, because a pointer to the last
    247 element of the list is maintained. <code>link</code> returns the last linked
    248 argument. See also <code><a href="refY.html#yoke">yoke</a></code>, <code><a
    249 href="refC.html#chain">chain</a></code> and <code><a
    250 href="refM.html#made">made</a></code>.
    251 
    252 <pre><code>
    253 : (make
    254    (println (link 1))
    255    (println (link 2 3)) )
    256 1
    257 3
    258 -> (1 2 3)
    259 </code></pre>
    260 
    261 <dt><a name="lint"><code>(lint 'sym) -> lst</code></a>
    262 <dt><code>(lint 'sym 'cls) -> lst</code>
    263 <dt><code>(lint '(sym . cls)) -> lst</code>
    264 <dd>(Debug mode only) Checks the function definition or file contents (in the
    265 first form), or the method body of sym (second and third form), for possible
    266 pitfalls. Returns an association list of diagnoses, where <code>var</code>
    267 indicates improper variables, <code>dup</code> duplicate parameters,
    268 <code>def</code> an undefined function, <code>bnd</code> an unbound variable,
    269 and <code>use</code> unused variables. See also <code><a
    270 href="refN.html#noLint">noLint</a></code>, <code><a
    271 href="refL.html#lintAll">lintAll</a></code>, <code><a
    272 href="refD.html#debug">debug</a></code>, <code><a
    273 href="refT.html#trace">trace</a></code> and <code><a
    274 href="refD.html#*Dbg">*Dbg</a></code>.
    275 
    276 <pre><code>
    277 : (de foo (R S T R)     # 'T' is a improper parameter, 'R' is duplicated
    278    (let N 7             # 'N' is unused
    279       (bar X Y) ) )     # 'bar' is undefined, 'X' and 'Y' are not bound
    280 -> foo
    281 : (lint 'foo)
    282 -> ((var T) (dup R) (def bar) (bnd Y X) (use N))
    283 </code></pre>
    284 
    285 <dt><a name="lintAll"><code>(lintAll ['sym ..]) -> lst</code></a>
    286 <dd>(Debug mode only) Applies <code><a href="refL.html#lint">lint</a></code> to
    287 <code><a href="refA.html#all">all</a></code> internal symbols - and optionally
    288 to all files <code>sym</code> - and returns a list of diagnoses. See also
    289 <code><a href="refN.html#noLint">noLint</a></code>.
    290 
    291 <pre><code>
    292 : (more (lintAll "file1.l" "file2.l"))
    293 ...
    294 </code></pre>
    295 
    296 <dt><a name="lisp"><code>(lisp 'sym ['fun]) -> num</code></a>
    297 <dd>(64-bit version only) Installs under the tag <code>sym</code> a callback
    298 function <code>fun</code>, and returns a pointer <code>num</code> suitable to be
    299 passed to a C function via 'native'. If <code>fun</code> is <code>NIL</code>,
    300 the corresponding entry is freed. Maximally 24 callback functions can be
    301 installed that way. 'fun' should be a function of maximally five numbers, and
    302 should return a number. "Numbers" in this context are 64-bit scalars, and may
    303 not only represent integers, but also pointers or other encoded data. See also
    304 <code><a href="refN.html#native">native</a></code> and <code><a
    305 href="refS.html#struct">struct</a></code>.
    306 
    307 <pre><code>
    308 (load "lib/native.l")
    309 
    310 (gcc "ltest" NIL
    311    (cbTest (Fun) cbTest 'N Fun) )
    312 
    313 long cbTest(int(*fun)(int,int,int,int,int)) {
    314    return fun(1,2,3,4,5);
    315 }
    316 /**/
    317 
    318 : (cbTest
    319    (lisp 'cbTest
    320       '((A B C D E)
    321          (msg (list A B C D E))
    322          (* A B C D E) ) ) )
    323 (1 2 3 4 5)
    324 -> 120
    325 </code></pre>
    326 
    327 <dt><a name="list"><code>(list 'any ['any ..]) -> lst</code></a>
    328 <dd>Returns a list of all <code>any</code> arguments. See also <code><a
    329 href="refC.html#cons">cons</a></code>.
    330 
    331 <pre><code>
    332 : (list 1 2 3 4)
    333 -> (1 2 3 4)
    334 : (list 'a (2 3) "OK")
    335 -> (a (2 3) "OK")
    336 </code></pre>
    337 
    338 <dt><a name="lst/3"><code>lst/3</code></a>
    339 <dd><a href="ref.html#pilog">Pilog</a> predicate that returns subsequent list
    340 elements, after applying the <code><a href="refG.html#get">get</a></code>
    341 algorithm to that object and the following arguments. Often used in database
    342 queries. See also <code><a href="refM.html#map/3">map/3</a></code>.
    343 
    344 <pre><code>
    345 : (? (db nr +Ord 1 @Ord) (lst @Pos @Ord pos))
    346  @Ord={3-7} @Pos={4-1}
    347  @Ord={3-7} @Pos={4-2}
    348  @Ord={3-7} @Pos={4-3}
    349 -> NIL
    350 </code></pre>
    351 
    352 <dt><a name="lst?"><code>(lst? 'any) -> flg</code></a>
    353 <dd>Returns <code>T</code> when the argument <code>any</code> is a (possibly
    354 empty) list (<code>NIL</code> or a cons pair). See also <code><a
    355 href="refP.html#pair">pair</a></code>.
    356 
    357 <pre><code>
    358 : (lst? NIL)
    359 -> T
    360 : (lst? (1 . 2))
    361 -> T
    362 : (lst? (1 2 3))
    363 -> T
    364 </code></pre>
    365 
    366 <dt><a name="listen"><code>(listen 'cnt1 ['cnt2]) -> cnt | NIL</code></a>
    367 <dd>Listens at a socket descriptor <code>cnt1</code> (as received by <code><a
    368 href="refP.html#port">port</a></code>) for an incoming connection, and returns
    369 the new socket descriptor <code>cnt</code>. While waiting for a connection, a
    370 <code>select</code> system call is executed for all file descriptors and timers
    371 in the <code>VAL</code> of the global variable <code><a
    372 href="refR.html#*Run">*Run</a></code>. If <code>cnt2</code> is
    373 non-<code>NIL</code>, that amount of milliseconds is waited maximally, and
    374 <code>NIL</code> is returned upon timeout. The global variable <code>*Adr</code>
    375 is set to the IP address of the client. See also <code><a
    376 href="refA.html#accept">accept</a></code>, <code><a
    377 href="refC.html#connect">connect</a></code>, <code><a
    378 href="refA.html#*Adr">*Adr</a></code>.
    379 
    380 <pre><code>
    381 : (setq *Socket
    382    (listen (port 6789) 60000) )  # Listen at port 6789 for max 60 seconds
    383 -> 4
    384 : *Adr
    385 -> "127.0.0.1"
    386 </code></pre>
    387 
    388 <dt><a name="lit"><code>(lit 'any) -> any</code></a>
    389 <dd>Returns the literal (i.e. quoted) value of <code>any</code>, by
    390 <code>cons</code>ing it with the <code><a
    391 href="refQ.html#quote">quote</a></code> function if necessary.
    392 
    393 <pre><code>
    394 : (lit T)
    395 -> T
    396 : (lit 1)
    397 -> 1
    398 : (lit '(1))
    399 -> (1)
    400 : (lit '(a))
    401 -> '(a)
    402 </code></pre>
    403 
    404 <dt><a name="load"><code>(load 'any ..) -> any</code></a>
    405 <dd>Loads all <code>any</code> arguments. Normally, the name of each argument is
    406 taken as a file to be executed in a read-eval loop. The argument semantics are
    407 identical to that of <code><a href="refI.html#in">in</a></code>, with the
    408 exception that if an argument is a symbol and its first character is a hyphen
    409 '-', then that argument is parsed as an executable list (without the surrounding
    410 parentheses). When <code>any</code> is <code>T</code>, all remaining command
    411 line arguments are <code>load</code>ed recursively. When <code>any</code> is
    412 <code>NIL</code>, standard input is read, a prompt is issued before each read
    413 operation, the results are printed to standard output (read-eval-print loop),
    414 and <code>load</code> terminates when an empty line is entered. In any case,
    415 <code>load</code> terminates upon end of file, or when <code>NIL</code> is read.
    416 The index for transient symbols is cleared before and after the load, so that
    417 all transient symbols in a file have a local scope. If the namespace was
    418 switched (with <code><a href="refS.html#symbols">symbols</a></code>) while
    419 executing a file, it is restored to the previous one. Returns the value of the
    420 last evaluated expression. See also <code><a
    421 href="refS.html#script">script</a></code>, <code><a
    422 href="refI.html#ipid">ipid</a></code>, <code><a
    423 href="refC.html#call">call</a></code>, <code><a
    424 href="refF.html#file">file</a></code>, <code><a
    425 href="refI.html#in">in</a></code>, <code><a href="refO.html#out">out</a></code>
    426 and <code><a href="refS.html#str">str</a></code>.
    427 
    428 <pre><code>
    429 : (load "lib.l" "-* 1 2 3")
    430 -> 6
    431 </code></pre>
    432 
    433 <dt><a name="loc"><code>(loc 'sym 'lst) -> sym</code></a>
    434 <dd>Locates in <code>lst</code> a <code><a
    435 href="ref.html#transient">transient</a></code> symbol with the same name as
    436 <code>sym</code>. Allows to get hold of otherwise inaccessible symbols. See also
    437 <code><a href="ref_.html#====">====</a></code>.
    438 
    439 <pre><code>
    440 : (loc "X" curry)
    441 -> "X"
    442 : (== @ "X")
    443 -> NIL
    444 </code></pre>
    445 
    446 <dt><a name="local"><code>(local . lst) -> sym</code></a>
    447 <dd>Wrapper function for <code><a href="refZ.html#zap">zap</a></code>. Typically
    448 used to create namespace-local symbols. <code>lst</code> should be a list of
    449 symbols. See also <code><a href="refP.html#pico">pico</a></code>, <code><a
    450 href="refS.html#symbols">symbols</a></code>, <code><a
    451 href="refI.html#import">import</a></code> and <code><a
    452 href="refI.html#intern">intern</a></code>.
    453 
    454 <pre><code>
    455 : (symbols 'myLib 'pico)
    456 -> pico
    457 myLib: (local bar foo)
    458 -> "foo"
    459 
    460 myLib: (de foo (A)  # 'foo' is local to 'myLib'
    461    ...
    462 myLib: (de bar (B)  # 'bar' is local to 'myLib'
    463    ...
    464 </code></pre>
    465 
    466 <dt><a name="locale"><code>(locale 'sym1 'sym2 ['sym ..])</code></a>
    467 <dd>Sets the current locale to that given by the country file <code>sym1</code>
    468 and the language file <code>sym2</code> (both located in the "loc/" directory),
    469 and optional application-specific directories <code>sym</code>. The locale
    470 influences the language, and numerical, date and other formats. See also
    471 <code><a href="refU.html#*Uni">*Uni</a></code>, <code><a
    472 href="refD.html#datStr">datStr</a></code>, <code><a
    473 href="refS.html#strDat">strDat</a></code>, <code><a
    474 href="refE.html#expDat">expDat</a></code>, <code><a
    475 href="refD.html#day">day</a></code>, <code><a
    476 href="refT.html#telStr">telStr</a></code>, <code><a
    477 href="refE.html#expTel">expTel</a></code> and and <code><a
    478 href="refM.html#money">money</a></code>.
    479 
    480 <pre><code>
    481 : (locale "DE" "de" "app/loc/")
    482 -> "Zip"
    483 : ,"Yes"
    484 -> "Ja"
    485 </code></pre>
    486 
    487 <dt><a name="lock"><code>(lock ['sym]) -> cnt | NIL</code></a>
    488 <dd>Write-locks an external symbol <code>sym</code> (file record locking), or
    489 the whole database root file if <code>sym</code> is <code>NIL</code>. Returns
    490 <code>NIL</code> if successful, or the ID of the process currently holding the
    491 lock. When <code>sym</code> is non-<code>NIL</code>, the lock is released at the
    492 next top level call to <code><a href="refC.html#commit">commit</a></code> or
    493 <code><a href="refR.html#rollback">rollback</a></code>, otherwise only when
    494 another database is opened with <code><a href="refP.html#pool">pool</a></code>,
    495 or when the process terminates. See also <code><a
    496 href="refS.html#*Solo">*Solo</a></code>.
    497 
    498 <pre><code>
    499 : (lock '{1})        # Lock single object
    500 -> NIL
    501 : (lock)             # Lock whole database
    502 -> NIL
    503 </code></pre>
    504 
    505 <dt><a name="loop"><code>(loop ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any</code></a>
    506 <dd>Endless loop with multiple conditional exits: The body is executed an
    507 unlimited number of times. If a clause has <code>NIL</code> or <code>T</code> as
    508 its CAR, the clause's second element is evaluated as a condition and - if the
    509 result is <code>NIL</code> or non-<code>NIL</code>, respectively - the
    510 <code>prg</code> is executed and the result returned. See also <code><a
    511 href="refD.html#do">do</a></code> and <code><a
    512 href="refF.html#for">for</a></code>.
    513 
    514 <pre><code>
    515 : (let N 3
    516    (loop
    517       (prinl N)
    518       (T (=0 (dec 'N)) 'done) ) )
    519 3
    520 2
    521 1
    522 -> done
    523 </code></pre>
    524 
    525 <dt><a name="low?"><code>(low? 'any) -> sym | NIL</code></a> <dd>Returns
    526 <code>any</code> when the argument is a string (symbol) that starts with a
    527 lowercase character. See also <code><a href="refL.html#lowc">lowc</a></code> and
    528 <code><a href="refU.html#upp?">upp?</a></code>
    529 
    530 <pre><code>
    531 : (low? "a")
    532 -> "a"
    533 : (low? "A")
    534 -> NIL
    535 : (low? 123)
    536 -> NIL
    537 : (low? ".")
    538 -> NIL
    539 </code></pre>
    540 
    541 <dt><a name="lowc"><code>(lowc 'any) -> any</code></a>
    542 <dd>Lower case conversion: If <code>any</code> is not a symbol, it is returned
    543 as it is. Otherwise, a new transient symbol with all characters of
    544 <code>any</code>, converted to lower case, is returned. See also <code><a
    545 href="refU.html#uppc">uppc</a></code>, <code><a
    546 href="refF.html#fold">fold</a></code> and <code><a
    547 href="refL.html#low?">low?</a></code>.
    548 
    549 <pre><code>
    550 : (lowc 123)
    551 -> 123
    552 : (lowc "ABC")
    553 -> "abc"
    554 </code></pre>
    555 
    556 <dt><a name="lt0"><code>(lt0 'any) -> num | NIL</code></a>
    557 <dd>Returns <code>num</code> when the argument is a number and less than zero,
    558 otherwise <code>NIL</code>. See also <code><a
    559 href="refL.html#le0">le0</a></code>, <code><a
    560 href="refG.html#ge0">ge0</a></code>, <code><a
    561 href="refG.html#gt0">gt0</a></code>, <code><a href="ref_.html#=0">=0</a></code>
    562 and <code><a href="refN.html#n0">n0</a></code>.
    563 
    564 <pre><code>
    565 : (lt0 -2)
    566 -> -2
    567 : (lt0 3)
    568 -> NIL
    569 </code></pre>
    570 
    571 <dt><a name="lup"><code>(lup 'lst 'any) -> lst</code></a>
    572 <dt><code>(lup 'lst 'any 'any2) -> lst</code>
    573 <dd>Looks up <code>any</code> in the CAR-elements of cons pairs stored in the
    574 index tree <code>lst</code>, as built-up by <code><a
    575 href="refI.html#idx">idx</a></code>. In the first form, the first found cons
    576 pair is returned, in the second form a list of all pairs whose CAR is in the
    577 range <code>any</code> .. <code>any2</code>. See also <code><a
    578 href="refA.html#assoc">assoc</a></code>.
    579 
    580 <pre><code>
    581 : (idx 'A 'a T)
    582 -> NIL
    583 : (idx 'A (1 . b) T)
    584 -> NIL
    585 : (idx 'A 123 T)
    586 -> NIL
    587 : (idx 'A (1 . a) T)
    588 -> NIL
    589 : (idx 'A (1 . c) T)
    590 -> NIL
    591 : (idx 'A (2 . d) T)
    592 -> NIL
    593 : (idx 'A)
    594 -> (123 a (1 . a) (1 . b) (1 . c) (2 . d))
    595 : (lup A 1)
    596 -> (1 . b)
    597 : (lup A 2)
    598 -> (2 . d)
    599 : (lup A 1 1)
    600 -> ((1 . a) (1 . b) (1 . c))
    601 : (lup A 1 2)
    602 -> ((1 . a) (1 . b) (1 . c) (2 . d))
    603 </code></pre>
    604 
    605 </dl>
    606 
    607 </body>
    608 </html>