Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the incf-cl Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:01:05 2018 GMT+0.
• Introduction: | What incf-cl is all about | |
• Systems: | The systems documentation | |
• Files: | The files documentation | |
• Packages: | The packages documentation | |
• Definitions: | The symbols documentation | |
• Indexes: | Concepts, functions, variables and data types |
#+TITLE: (INCF CL) #+AUTHOR: Juan M. Bello Rivas #+EMAIL: jmbr@superadditive.com #+DATE: <2010-09-05 Sun> * Overview The library =(INCF CL)= is a collection of convenience functions and macros for Common Lisp. The features it provides are: - List comprehensions. - Doctest suite for automatic verification of examples in docstrings. - List manipulation functions similar to those in Haskell's prelude. - Nesting functions akin to those available in Mathematica. This library is released under the X11 license and it has been tested with the following Common Lisp implementations: - [[http://www.clozure.com/clozurecl.html][Clozure Common Lisp]] 1.6 - [[http://www.sbcl.org][Steel Bank Common Lisp]] 1.0.41 - [[http://common-lisp.net/project/armedbear/][Armed Bear Common Lisp]] 0.22.0 * Usage ** Installation The easiest way to install =(INCF CL)= is to use ASDF-INSTALL: #+BEGIN_SRC lisp (asdf:load-system :asdf-install) (asdf-install:install :incf-cl) #+END_SRC lisp If you don't have ASDF-INSTALL, [[http://github.com/jmbr/incf-cl/tarball/master][download the latest snapshot]] or clone [[http://github.com/jmbr/incf-cl][the source code repository]] by issuing the following command: #+BEGIN_SRC sh $ git clone git://github.com/jmbr/incf-cl.git #+END_SRC and then follow the ASDF installation procedure for your CL implementation. Note that you will need [[http://common-lisp.net/project/stefil/][Stefil]] if you want to run the test suite. ** Loading the library To begin using the library write: #+BEGIN_SRC lisp (asdf:load-system :incf-cl) (use-package :incf-cl) #+END_SRC ** Features *** Ranges The function =RANGE= is similar to MATLAB's vector notation. Some use cases are: #+BEGIN_SRC lisp CL-USER> (range 1 10) (1 2 3 4 5 6 7 8 9 10) CL-USER> (range 0 1/4 1) (0 1/4 1/2 3/4 1) #+END_SRC *** List comprehensions List comprehensions are a programming language construct that closely mimics the way you declare a set in mathematics and are sometimes more succinct and readable than a composition of =MAPCAR= and =DELETE-IF= or a loop. Here are two examples of how to use the =LC= (short for List Comprehension) macro: #+BEGIN_SRC lisp CL-USER> (lc (sin x) (<- x (range 0 .25 (/ pi 2)))) (0.0 0.24740396 0.47942555 0.6816388 0.84147096 0.9489846 0.997495) CL-USER> (lc (cons x y) (<- x (range 0 2)) (<- y (range 0 2)) (= (+ x y) 2)) ((0 . 2) (1 . 1) (2 . 0)) #+END_SRC *** Doctests =DOCTEST= checks documentation strings for correctness. For every exported function in the package name passed to =DOCTEST=, 1. each docstring is scanned for pieces of text resembling interactive sessions, 2. then those snippets are evaluated, 3. and the resulting values are checked against the expected ones. For example, consider the package =TEST=: #+BEGIN_SRC lisp (defpackage :test (:use :common-lisp :incf-cl) (:export :factorial)) (in-package :test) (defun factorial (n &optional (acc 1)) "Returns the factorial of N, where N is an integer >= 0. Examples: TEST> (lc (factorial n) (<- n (range 1 5))) (1 2 6 24 120) TEST> (factorial 450/15) 265252859812191058636308480000000 TEST> (signals-p arithmetic-error (factorial -1)) T TEST> (signals-p type-error (factorial 30.1)) T TEST> (factorial 0) 1" (declare (type integer n)) (cond ((minusp n) (error 'arithmetic-error)) ((/= n (floor n)) (error 'type-error))) (if (= n 0) acc (factorial (1- n) (* n acc)))) #+END_SRC You can use =DOCTEST= to make sure the examples given in =FACTORIAL='s documentation string work as expected by writing #+BEGIN_SRC lisp CL-USER> (doctest :test) ..... T #+END_SRC Or, equivalently, #+BEGIN_SRC lisp CL-USER> (doctest 'test::factorial) ..... T #+END_SRC *** Prelude Some list manipulation functions patterned after Haskell's prelude are available. Namely, - =BREAK*= - =CYCLE= (and its destructive version =NCYCLE=). - =DROP= - =DROP-WHILE= - =FLIP= - =GROUP= - =INSERT= - =INTERSPERSE= (and its destructive version =NINTERSPERSE=). - =PARTITION= - =REPLICATE= - =SCAN*= (using the key parameters =:INITIAL-VALUE= and =:FROM-END= it works as =scanl=, =scanl1=, =scanr=, or =scanr1=) - =SPAN= - =SPLIT-AT= - =TAKE= - =TAKE-WHILE= - =UNZIP= The on-line documentation for each of them can be read using =DESCRIBE= (or =M-x slime-describe-symbol= in [[http://common-lisp.net/project/slime/][SLIME]]). See also [[http://ww2.cs.mu.oz.au/~bjpop/papers/haskell.tour.tar.gz][A Tour of the Haskell Prelude]] for more information. Since Common Lisp doesn't guarantee tail call elimination, these functions are written iteratively to avoid stack overflows. *** Nesting The function =NEST-LIST= applies a function to an initial value, then applies the same function to the previous result, and so on. This stops after a specified number of evaluations or when a given predicate is true and a list containing all the results is returned. =NEST= works as =NEST-LIST= but it only returns the last result, not the whole list. Some examples: #+BEGIN_SRC lisp CL-USER> (setf *print-circle* nil) NIL CL-USER> (nest-list (lambda (x) `(sin ,x)) 'z :max 3) (Z (SIN Z) (SIN (SIN Z)) (SIN (SIN (SIN Z)))) CL-USER> (nest-list #'+ '(1 1) :max 10) (1 1 2 3 5 8 13 21 34 55 89 144) CL-USER> (nest #'+ '(1 1) :max 10) 144 CL-USER> (nest-list (lambda (x) (mod (* 2 x) 19)) 2 :test (lambda (x) (/= x 1))) (2 4 8 16 13 7 14 9 18 17 15 11 3 6 12 5 10 1) #+END_SRC The closely related function =FIXED-POINT= returns the fixed point of a function starting from an initial value. Whether a fixed point has been reached or not is determined by a test function (=EQL= by default). For example, the square root of 2 using Newton's method can be computed as: #+BEGIN_SRC lisp CL-USER> (fixed-point (lambda (x) (float (- x (/ (- (expt x 2) 2) (* 2 x))))) 1) 1.4142135 #+END_SRC *** Unfolds There's an implementation of =UNFOLD= and =UNFOLD-RIGHT= as specified in [[http://srfi.schemers.org/srfi-1/srfi-1.html#unfold][SRFI 1: List library]]. Here's an example of =UNFOLD=: #+BEGIN_SRC lisp (defun euler (f x0 y0 interval h) "Computes an approximate solution of the initial value problem: y' = f(x, y), x in interval; y(x0) = y0 using Euler's explicit method. Interval is a list of two elements representing a closed interval. The function returns a list of points and the values of the approximate solution at those points. For example, EULER> (euler (lambda (x y) (declare (ignore y)) (- (sin x))) 0 1 (list 0 (/ pi 2)) 0.5) ((0 1) (0.5 1.0) (1.0 0.7602872) (1.5 0.33955175))" (assert (<= (first interval) (second interval))) (unfold (lambda (x) (> (first x) (second interval))) #'identity (lambda (pair) (destructuring-bind (x y) pair (list (+ x h) (+ y (* h (funcall f x y)))))) (list x0 y0))) #+END_SRC *** Functions The function =$= returns the composition of several functions. The following example illustrates its use: #+BEGIN_SRC lisp CL-USER> (funcall ($ (lambda (x) (* x x)) (lambda (x) (+ x 2))) 2) 16 #+END_SRC *** Hash table utilities =DOHASH= iterates over a hash table with semantics similar to those of =DOLIST=: #+BEGIN_SRC lisp CL-USER> (defparameter *hash-table* (make-hash-table)) *HASH-TABLE* CL-USER> (setf (gethash "one" *hash-table*) 1) 1 CL-USER> (setf (gethash "two" *hash-table*) 2) 2 CL-USER> (setf (gethash "three" *hash-table*) 3) 3 CL-USER> (dohash (key value *hash-table*) (format t "~a => ~d~%" key value)) three => 3 two => 2 one => 1 NIL CL-USER> (let ((product 1)) (dohash (key value *hash-table* product) (setf product (* product value)))) 6 #+END_SRC *** Strings =STRING-JOIN= glues together a list of strings placing a given separator between each string. By default, the separator is a space. #+BEGIN_SRC lisp CL-USER> (string-join '("Hello" "world")) "Hello world" CL-USER> (string-join '("Hello" "world") ", ") "Hello, world" #+END_SRC * Links Some of the features of =(INCF CL)= are discussed in: - [[http://kyle-burton.livejournal.com/8219.html][Playing with List Comprehensions in CL]] - [[http://i-need-closures.blogspot.com/2008/01/programming-collective-intelligence-in.html][Programming Collective Intelligence in Common Lisp, Chapter 5 - Optimizations]] * Feedback Please send suggestions, patches, and bug reports to the [[http://superadditive.com/contact/][author's email address]]. # Some extra directives for HTML generation follow. These have nothing to do with the document's content. #+STYLE: #+STYLE: #+STYLE: #+OPTIONS: toc:2
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The incf-cl system: |
Juan M. Bello Rivas <jmbr@superadditive.com>
X11
INCF CL is a library of convenience functions for Common Lisp
cl-ppcre
incf-cl.asd (file)
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files: |
Next: The incf-cl/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
incf-cl.asd
incf-cl (system)
Next: The incf-cl/function<dot>lisp file, Previous: The incf-cl<dot>asd file, Up: Lisp files [Contents][Index]
Next: The incf-cl/lc<dot>lisp file, Previous: The incf-cl/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
incf-cl (system)
function.lisp
$ (function)
canonicalize-test (function)
Next: The incf-cl/nest<dot>lisp file, Previous: The incf-cl/function<dot>lisp file, Up: Lisp files [Contents][Index]
function.lisp (file)
incf-cl (system)
lc.lisp
lc (macro)
Next: The incf-cl/unfold<dot>lisp file, Previous: The incf-cl/lc<dot>lisp file, Up: Lisp files [Contents][Index]
lc.lisp (file)
incf-cl (system)
nest.lisp
Next: The incf-cl/range<dot>lisp file, Previous: The incf-cl/nest<dot>lisp file, Up: Lisp files [Contents][Index]
nest.lisp (file)
incf-cl (system)
unfold.lisp
Next: The incf-cl/prelude<dot>lisp file, Previous: The incf-cl/unfold<dot>lisp file, Up: Lisp files [Contents][Index]
unfold.lisp (file)
incf-cl (system)
range.lisp
range (function)
Next: The incf-cl/unscan<dot>lisp file, Previous: The incf-cl/range<dot>lisp file, Up: Lisp files [Contents][Index]
range.lisp (file)
incf-cl (system)
prelude.lisp
Next: The incf-cl/fixed-point<dot>lisp file, Previous: The incf-cl/prelude<dot>lisp file, Up: Lisp files [Contents][Index]
prelude.lisp (file)
incf-cl (system)
unscan.lisp
Next: The incf-cl/hash-table<dot>lisp file, Previous: The incf-cl/unscan<dot>lisp file, Up: Lisp files [Contents][Index]
unscan.lisp (file)
incf-cl (system)
fixed-point.lisp
fixed-point (function)
Next: The incf-cl/iteration<dot>lisp file, Previous: The incf-cl/fixed-point<dot>lisp file, Up: Lisp files [Contents][Index]
fixed-point.lisp (file)
incf-cl (system)
hash-table.lisp
dohash (macro)
Next: The incf-cl/string<dot>lisp file, Previous: The incf-cl/hash-table<dot>lisp file, Up: Lisp files [Contents][Index]
hash-table.lisp (file)
incf-cl (system)
iteration.lisp
while (macro)
Next: The incf-cl/doctest<dot>lisp file, Previous: The incf-cl/iteration<dot>lisp file, Up: Lisp files [Contents][Index]
iteration.lisp (file)
incf-cl (system)
string.lisp
string-join (function)
Next: The incf-cl/symbol<dot>lisp file, Previous: The incf-cl/string<dot>lisp file, Up: Lisp files [Contents][Index]
string.lisp (file)
incf-cl (system)
doctest.lisp
Previous: The incf-cl/doctest<dot>lisp file, Up: Lisp files [Contents][Index]
doctest.lisp (file)
incf-cl (system)
symbol.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The incf-cl package: |
package.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions: | ||
• Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported special variables: | ||
• Exported macros: | ||
• Exported functions: | ||
• Exported generic functions: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Determines if a dot will be displayed for each passed test.
doctest.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
DOHASH iterates over the keys and values of HASH-TABLE. It returns NIL or the result of evaluating RESULT-FORM if it was specified.
hash-table.lisp (file)
Assembles a multiset containing the results of evaluating COLLECTION-FORM and subject to QUANTIFIERS.
Returns T if evaluating BODY results in CONDITION being signalled, NIL otherwise.
doctest.lisp (file)
Executes BODY while PREDICATE-FORM is non NIL.
iteration.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Returns the composition of FUNCTIONS. Note that FUNCTIONS must
be composable in the order specified.
For example,
INCF-CL> (funcall ($ (lambda (x) (* x x))
(lambda (x) (+ x 2)))
2)
16
INCF-CL> (funcall ($ #’values #’floor #’sqrt (lambda (x) (expt x 2))) -2) 2
function.lisp (file)
If SYMBOL corresponds to a function, then its documentation string
is tested and the results are printed to STREAM. If SYMBOL refers to
a package, then all the functions corresponding to the external
symbols in the package are tested.
DOCTEST returns T if the tests succeed, NIL otherwise.
doctest.lisp (file)
Returns the fixed point of FUNCTION starting with INITIAL-VALUE.
The keyword argument TEST determines when a fixed point has been
reached. Use MAX-STEPS to stop after a certain (positive) number of
iterations.
For example, the square root of 2 using Newton’s method can be
computed as:
INCF-CL> (fixed-point (lambda (x)
(float (- x (/ (- (expt x 2) 2) (* 2 x)))))
1)
1.4142135
INCF-CL> (sqrt 2)
1.4142135
fixed-point.lisp (file)
Applied to a binary function F, returns the same function with the order of the arguments reversed.
prelude.lisp (file)
Returns a list containing all the symbols in PACKAGE.
symbol.lisp (file)
Returns a list containing all the exported symbols in PACKAGE.
symbol.lisp (file)
Returns a list of the results of applying FUNCTION successively to
INITIAL-VALUES and continuing until applying TEST (respectively
TEST-NOT) to the result is non NIL.
If M is specified, then NEST-LIST supplies the M most recent results
as arguments for TEST (respectivelly TEST-NOT) at each step.
If MAX is specified then FUNCTION is applied at most MAX times.
range.lisp (file)
Returns a list contaning N times the value X
prelude.lisp (file)
Returns a string joining each string in LIST by SEP. If SEP is not specified, the default separator is a space.
string.lisp (file)
Returns a list built following the pattern:
transformer(initial-value), transformer(incrementor(initial-value)), ...
Examples:
1. List of squares: 1^2, ..., 10^2
INCF-CL> (unfold (lambda (x) (> x 10)) (lambda (x) (expt x 2)) #’1+ 1)
(1 4 9 16 25 36 49 64 81 100)
2. Append (3 4 5) onto (1 2)
INCF-CL> (unfold #’null #’first #’rest (list 1 2) (lambda (x)
(declare (ignore x))
(list 3 4 5)))
(1 2 3 4 5)
See also:
http://srfi.schemers.org/srfi-1/srfi-1.html#unfold
unfold.lisp (file)
Returns a list built following the pattern:
... transformer(incrementor(initial-value)), transformer(initial-value)
Examples:
1. List of squares: 1^2, ..., 10^2
INCF-CL> (unfold-right #’zerop (lambda (x) (* x x)) #’1- 10)
(1 4 9 16 25 36 49 64 81 100)
2. Reverse a proper list:
INCF-CL> (unfold-right #’null #’first #’rest (list 1 2 3 4 5))
(5 4 3 2 1)
See also: http://srfi.schemers.org/srfi-1/srfi-1.html#unfold-right
unfold.lisp (file)
Applied to the association list ALIST, returns two lists (as VALUES) containing the keys and values of each element in ALIST respectively. This function is the inverse of PAIRLIS.
prelude.lisp (file)
Previous: Exported functions, Up: Exported definitions [Contents][Index]
Given a PREDICATE and a LIST, breaks LIST into two
lists (returned as VALUES) at the point where PREDICATE is first
satisfied. If PREDICATE is never satisfied then the first returned
value is the entire LIST and the second element is NIL.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
Returns a circular list containing the elements in LIST (which should be a proper list).
prelude.lisp (file)
Applied to N (a non-negative integer) and LIST,
returns the list with the specified number of elements removed from
the front of LIST. If LIST has less than N elements then it returns
NIL.
prelude.lisp (file)
Applied to PREDICATE and LIST, removes elements
from the front of LIST while PREDICATE is satisfied.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
Returns a list of lists where every item in each
sublist satisfies TEST and the concatenation of the result is equal to
LIST.
KEY is a designator for a function of one argument, or NIL. If KEY
is supplied, it is applied once to each element of LIST before it is
passed to PREDICATE. If it is not supplied or is NIL, the element of
LIST itself is used.
For example,
INCF-CL> (mapcar (lambda (x) (concatenate ’string x))
(group (coerce "Mississippi" ’list)))
("M" "i" "ss" "i" "ss" "i" "pp" "i")
prelude.lisp (file)
Inserts X before the first element in LIST which is
greater than X. The order relation can be specified by either one of
the keyword arguments TEST and TEST-NOT.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
Returns a list where ELEMENT is interspersed
between the elements of SEQUENCE.
For example,
INCF-CL> (intersperse ’x (replicate 3 ’z)) (Z X Z X Z)
prelude.lisp (file)
Destructive version of CYCLE. Again, keep in mind that LIST must be a proper list.
prelude.lisp (file)
Destructive version of INTERSPERSE.
prelude.lisp (file)
Applied to PREDICATE and LIST, returns two values: a list
containing all the elements from LIST that satisfy PREDICATE, and its
complementary list.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
SCAN* is similar to REDUCE, but returns a list of
successive reduced values:
(scan* f (list x1 x2 ...) :initial-value z)
==> (z (funcall f z x1) (funcall f (funcall f z x1) x2) ...)
(scan* f (list x1 x2 ...))
==> (x1 (funcall f x1 x2) (funcall f (funcall f x1 x2) x2) ...)
(scan* f (list x1 ... x_n-1 x_n) :initial-value z :from-end t)
==> (... (funcall f x_n-1 (funcall f x_n z)) (funcall f x_n z) z)
(scan* f (list x1 ... x_n-1 x_n) :from-end t)
==> (... (funcall f x_n-1 (funcall f x_n-1 x_n)) (funcall f x_n-1 x_n) x_n)
Examples:
INCF-CL> (scan* #’/ (list 4 2 4) :initial-value 64)
(64 16 8 2)
INCF-CL> (scan* #’max (range 1 7) :initial-value 5)
(5 5 5 5 5 5 6 7)
INCF-CL> (scan* (lambda (x y) (+ (* 2 x) y)) (list 1 2 3) :initial-value 4)
(4 9 20 43)
INCF-CL> (scan* #’+ (list 1 2 3 4))
(1 3 6 10)
INCF-CL> (scan* #’+ (list 1 2 3 4) :initial-value 5 :from-end t)
(15 14 12 9 5)
INCF-CL> (scan* #’+ (list 1 2 3 4) :from-end t)
(10 9 7 4)
prelude.lisp (file)
Splits LIST into two lists (returned as VALUES)
such that elements in the first list are taken from the head of LIST
while PREDICATE is satisfied, and elements in the second list are the
remaining elements from LIST once PREDICATE is not satisfied.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
Given a non-negative integer N and LIST, splits
LIST into two lists (returned as VALUES) at the position corresponding
to the given integer. If N is greater than the length of LIST, it
returns the entire list first and the empty list second in VALUES.
prelude.lisp (file)
Applied to the integer N and LIST, returns the specified number of elements from the front of LIST. If LIST has less than N elements, TAKE returns the entire LIST.
prelude.lisp (file)
Applied to PREDICATE and LIST, returns a list
containing elements from the front of LIST while PREDICATE is
satisfied.
KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.
prelude.lisp (file)
Semi-inverse of SCAN*.
INCF-CL> (equal (unscan (flip #’-) (scan* #’+ ’(1 2 3)) :initial-value 0)
’(1 2 3))
T
unscan.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal functions: | ||
• Internal generic functions: | ||
• Internal conditions: | ||
• Internal types: |
Next: Internal generic functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
prelude.lisp (file)
Returns a validated test function for those functions that use TEST and TEST-NOT keyword arguments.
function.lisp (file)
prelude.lisp (file)
prelude.lisp (file)
prelude.lisp (file)
Returns T if the first doctest found in DOCUMENTATION passes, signals DOCTEST-FAILURE otherwise.
doctest.lisp (file)
Returns T if every test in FUNCTION’s docstring passes, NIL otherwise.
doctest.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
doctest.lisp (file)
doctest.lisp (file)
doctest.lisp (file)
Next: Internal types, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
doctest.lisp (file)
condition (condition)
:sexpr
sexpr (generic function)
:actual-values
actual-values (generic function)
:expected-values
expected-values (generic function)
Previous: Internal conditions, Up: Internal definitions [Contents][Index]
prelude.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index: | ||
• Function index: | ||
• Variable index: | ||
• Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | F I L |
---|
Jump to: | F I L |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | $
%
A B C D E F G I L M N P R S T U W |
---|
Jump to: | $
%
A B C D E F G I L M N P R S T U W |
---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Jump to: | *
A E S |
---|
Jump to: | *
A E S |
---|
Previous: Variable index, Up: Indexes [Contents][Index]
Jump to: | C D F I P S T |
---|
Jump to: | C D F I P S T |
---|