Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the clods-export Reference Manual, version 1.0.1, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:34:40 2018 GMT+0.
| • Introduction: | What clods-export is all about | |
| • Systems: | The systems documentation | |
| • Modules: | The modules documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
It is sometimes necessary to offer users of e.g. a web service the option to export their data from your application to the outside world. Often, a good format would be a spreadsheet document, as it offers a simple way of displaying and editing tabular data, and people have over the years become quite familiar in misusing Excel for a variety of things Excel was not designed for.
clods-export helps you by writing out OpenDocument Spreadsheet files. It does not try to implement functionality needed by proper spreadsheet applications and it does not support reading in ODS formatted data, but it tries to make creation of ODS files straightforward and easy.
For a quick start, look at example.lisp. A short API reference is given below, but to fully understand how all parameters work I recommend studying the OpenDocument XML format specification as well.
Caveat! Different software (Excel, LibreOffice, OpenOffice) handle ODS data in a different manner, and are a bit incompatible. So, you should check your generated data on all of the applicable programs in order to see that all formatting goes through as you intended.
An ODS document consists of three parts: Definitions for fonts, definitions for styles, and the actual data content. These parts must be specified, in this order, to clods-export as well.
Start by wrapping your export functionality inside a with-spreadsheet
form. The name of the generated ODS file is given as an argument,
along with metadata (name of the application generating the document
and the human creator of the data). Inside the spreadsheet, you then
define fonts, styles and content:
(clods:with-spreadsheet ("my.ods" :generator "My app" :creator "Me")
(clods:using-fonts ()
...)
(clods:using-styles (:locale ...)
...)
(clods:with-body ()
(clods:with-table ("Sheet one")
...)
(clods:with-table ("Sheet two")
...)
...))
Fonts are specified using the clods:font function inside a
clods:using-fonts form. clods:font takes the name of the font
definition as its first argument, and a number of optional key
arguments describing the font properties:
:family (string), for example as "Arial":family-generic (keyword), from clods:font-generic-families:size (string), length value such as "12pt" or "0.8cm":style (keyword), from clods:font-styles:weight (keyword), from clods:font-weights:variant (keyword), from clods:font-variants:stretch (keyword), from clods:font-stretches:adornments (string).Note that certain font details can be specified along with text properties when defining cell styles, as well.
Excel understands the name of the font definition as a synonym for the
font family. That is, if you want to be Excel compatible, you must
match the font's name argument with the :family argument:
;; works on LibreOffice and OpenOffice but not on Excel:
(clods:font "normal" :family "Arial")
;; works on all three:
(clods:font "Arial" :family "Arial")
ODS defines formatting on several levels. On the lowest level, there are data styles (number styles) that specify how data is formatted into strings to be displayed. Then, cell styles specify formatting inside a single cell. Column and row styles define the width/height of the column/row as well as the default cell style to be applied.
Styles are defined hierarchically, so that styles can inherit properties from other styles. However, this inheritance fails spectacularly on LibreOffice and OpenOffice (but does seem to work on Excel), so it is probably a good idea to define every style from the bottom up.
Both data styles and cell styles also contain text properties that define visual aspects of the displayed text.
Locale, as defined by clods-export, is a simple object that contains
the following four slots:
country (string) the associated ISO 3166 country codegrouping-separator (base-char) the character inserted between number groupsgrouping-count (integer) length of a single number groupdecimal-separator (base-char) the character between integer and decimal parts of a real number.Locales can be created with the function clods:make-locale. For
example, the Finnish locale, where a large decimal number is written
as "1 234 567,89", would be defined as follows:
(clods:make-locale "FI" #\space 3 #\,)
Text property definitions are lists containing pairs of keywords and
values. The set of supported keywords is listed in
clods:*text-properties* and they map directly to those defined in the OpenDocument specification.
Numbers can be displayed in three different representations: standard numbers, scientific numbers and fractions. The representation to be used is deduced from the arguments in the number format specification, which is a list of keyword-value pairs. The following keywords are supported:
:min-integer-digits specifies the minimum number of digits in the
integer part of the number. Supported by all number
representations.:decimal-places specifies the minimum number of decimal digits
after the decimal separator. Supported by standard and scientific
numbers.:decimal-replacement specifies the string to be added (instead of
zeros) as the decimal part of an integer number, if
:decimal-places is specified as well.:display-factor scales down the number for displaying. Supported
by standard numbers only.:number-grouping groups the integer part of the number according
to the locale. Supported by standard numbers only.:min-exponent-digits specifies the minimum number of exponent
digits to be shown. Supported by scientific numbers only; adding
this flag forces scientific representation.:denominator-value forces the use of a specific denominator in the
fraction. Supported by fractions only; adding this flag forces
fractional representation.:min-denominator-digits specifies the minimum number of digits on
the denominator of the fractional number. Supported by fractions
only; adding this flag forces fractional representation.:min-numerator-digits specifies the minimum number of digits on
the numerator of the fractional number. Supported by fractions
only; adding this flag forces fractional representation.Note that LibreOffice and OpenOffice require quite complete number
specifications in order to display numbers correctly. Thus, you
should specify things like :min-integer-digits 1 even though they
seem superfluous, if you wish these applications to show your data
correctly.
There are several different data formatting types. In addition to the
type-specific arguments described below, they all accept the keyword
arguments :locale (of type locale) and :text-properties (a list
that contains text property definitions).
(number-boolean-style name true false &key prefix suffix) formats
data that must be one of the keywords :true and :false into the
textual representations given on the true and false (string)
arguments. An optional prefix or suffix can be added.(number-time-style name format) formats a local-time:timestamp
into a textual representation given in format. format must be a
list that contains strings (which will be formatted as such) and
keywords from the following set: :long-hours, :short-hours,
:long-minutes, :short-minutes, :long-seconds, :short-seconds
and :am-pm. If the :am-pm keyword is present, hours will be
formatted in 12-hour format, otherwise in 24-hour format. The
long versions will format the data in two digits, short versions
using one or two digits.(number-date-style name format) formats a local-time:timestamp
in a similar manner to the number-time-style. All the formatting
directives specified above work here as well, with the addition of
the following keywords: :long-day, :short-day, :long-month,
:short-month, :long-year, :short-year, :long-era,
:short-era, :short-day-of-week, :long-day-of-week,
:short-week-of-year, :long-week-of-year, :short-quarter and
:long-quarter. However, clods-export does not currently support
formatting era, day-of-week and week-of-year.(number-number-style name format &key prefix suffix) is the main
number formatting facility. The format argument is a list as
defined above in the Number formatting section. Additionally,
arbitrary strings given in the prefix and suffix arguments can
be prefixed or appended to the formatting result.(number-percentage-style name format &key prefix suffix) formats a
number as a percentage value. In essence, this means that the value
is multiplied by 100 before being displayed. Also, suffix
defaults to the string " %".(number-currency-style name format) formats a number as a monetary
value. The format here is a list of keyword-value pairs. The
keyword :number precedes a list that specifies number formatting
as in the previous number styles, and the keywords :symbol and
:text should be followed by strings that are printed verbatim.
The difference between :symbol and :text values is semantic;
visually, they produce similar results.(number-text-style name &key prefix suffix) simply formats a
string input by preceding it with the optional prefix and appending
the optional suffix.For a cell style, you can define text properties, and a set of other formatting keyword arguments:
(clods:cell-style name parent-style text-properties &key ...)
Cell styles support inheritance, so you can build your styles on top of each other by using the parent-style argument. Note, though, that not all applications obey the inheritance.
The available keyword arguments are:
:horizontal-align (one of :start, :center, :end, :justify, :left, :right):vertical-align (one of :top, :middle, :bottom, :automatic):text-align-source (one of :fix, :value-type):background (:transparent or a string color definition "#xxxxxx"):border, :border-left, :border-top, :border-right,
:border-bottom specify a list of three elements: (width style
color), where width is one of :auto, :normal, :bold,
:thin, :medium, :thick; style is one of :none :solid
:dotted :dash :long-dash :dot-dash :dot-dot-dash :wave,
and color is a string color definition "#xxxxxx". Specifying
:border applies the same border to all edges.:wrap takes a generalized boolean defining if the cell's contents wrap or not.Row styles are defined as follows:
(clods:row-style name parent-style &key ...)
The available keyword arguments are:
:height (string) height of the row, as a length value (e.g. "16pt" or "12mm"):min-height (string) as above:use-optimal-height (generalized boolean) allow the application to
automatically set the row's height according to content:background (:transparent or a string color definition "#xxxxxx")Column styles are defined as follows:
(clods:column-style name parent-style &key ...)
The available keyword arguments are:
:width (string) width of the row, as a length value (e.g. "90pt" or "5.5cm"):rel-width (string) as above:use-optimal-width (generalized boolean) allow the application to
automatically set the column's width according to contentTable styles are included for the sake of completeness.
(clods:table-style name parent-style &key ...)
The available keyword arguments are:
:width:rel-width:align:background.Each worksheet on the document are defined inside a clods:with-table
form. The sheet's name, usually shown on a tab at the bottom of the
spreadsheet application's view, is given as an argument. Inside the
with-table form first the table's columns are defined, followed by
the rows containing the actual data in cells:
(clods:with-table ("Table name")
(clods:with-header-columns ()
(clods:column ...)
...)
(clods:with-header-rows ()
(clods:with-row (...)
(clods:cell ...)
...)
...)
(clods:with-row (...)
(clods:cell ...)
...))
The semantic grouping of certain columns and rows into the header columns/rows groups is optional and has no visual effect on the table.
(clods:column &key repeat style visibility cell-style)
:repeat argument is specified, the column is repeated the
specified number of times, making it easy to define a table with many
similarly formatted columns.:style refers to a previously defined column-style.:visibility is one of :visible, :collapse and :filter.:cell-style refers to a previously defined cell-style, and defines
the default style to be applied for all cells in this column.(clods:with-row (&key repeat style visibility cell-style) ...)
The keyword arguments are similar to those given to clods:column.
(clods:cell content &key style formula span-columns span-rows link)
Cells contain the actual data on the table. The content of each cell
is given in the content argument that may be nil if the cell is
empty. The keyword arguments are as follows:
:style refers to a previously defined cell-style.:formula is a string that contains a formula for the cell. Formulas
are not understood or processed by clods-export; they are simply
written to the document as-is.:span-columns and :span-rows can be used to make the cell span
several adjacent cells in either direction. Horizontally spanned
cells (:span-columns) are automatically marked as covered, but
vertically covered cells must be handled by the application (see
clods:covered-cell below).:link is specified, the cell is made into a hyperlink with the
link argument as the target.If the cell contains a :style argument, that style is used for
formatting. Otherwise, if the current row has specified a
:cell-style, that is used. If not, but the current column specifies
a :cell-style, it takes effect. Otherwise, only string content is
supported.
In addition to the data style specified by the active cell style, the
formatting of the cell's content depends on the type of the content
argument.
null content means an empty cell.real numbers are written using a number formatter. The active data style
must be one of number-number-style, number-currency-style and number-percentage-style.local-time:timestamp specify dates and times. The active data style
must be one of number-time-style and number-date-style.keyword, one of :true and :false, means boolean content. The
active data style must be a number-boolean-style.string content is written out as-is, regardless of the active data style.
However, if the active data style is number-text-style, the possible
prefix and suffix information are used in the formatting.(clods:cells &rest content)
For convenience, a set of adjacent cells on the same row requiring no
special formatting can be written out in a single function call to
clods:cells.
(clods:covered-cell &optional n)
When a cell has a :span-rows argument larger than 1, the adjacent
cells on the following rows in the same column (that is, those cells
covered by the spanning cell) have to be marked as covered.
clods-export does not take care of this; it is left to the
application.
If you have a bug to report, or an enhancement to suggest, you can reach me at jussi@lahdenniemi.fi.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The clods-export system: |
Jussi Lahdenniemi <jussi@lahdenniemi.fi>
Jussi Lahdenniemi <jussi@lahdenniemi.fi>
MIT
Common Lisp OpenDocument spreadsheet export library
1.0.1
clods-export.asd (file)
clods (module)
Modules are listed depth-first from the system components tree.
| • The clods-export/clods module: |
clods-export (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files: |
Next: The clods-export/clods/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
clods-export.asd
clods-export (system)
Next: The clods-export/clods/namespaces<dot>lisp file, Previous: The clods-export<dot>asd file, Up: Lisp files [Contents][Index]
clods (module)
src/package.lisp
Next: The clods-export/clods/util<dot>lisp file, Previous: The clods-export/clods/package<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/namespaces.lisp
Next: The clods-export/clods/locale<dot>lisp file, Previous: The clods-export/clods/namespaces<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/util.lisp
Next: The clods-export/clods/ods<dot>lisp file, Previous: The clods-export/clods/util<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/locale.lisp
make-locale (function)
Next: The clods-export/clods/fonts<dot>lisp file, Previous: The clods-export/clods/locale<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/ods.lisp
with-spreadsheet (macro)
Next: The clods-export/clods/text<dot>lisp file, Previous: The clods-export/clods/ods<dot>lisp file, Up: Lisp files [Contents][Index]
ods.lisp (file)
clods (module)
src/fonts.lisp
Next: The clods-export/clods/numbers<dot>lisp file, Previous: The clods-export/clods/fonts<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/text.lisp
Next: The clods-export/clods/styles<dot>lisp file, Previous: The clods-export/clods/text<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/numbers.lisp
Next: The clods-export/clods/content<dot>lisp file, Previous: The clods-export/clods/numbers<dot>lisp file, Up: Lisp files [Contents][Index]
clods (module)
src/styles.lisp
Previous: The clods-export/clods/styles<dot>lisp file, Up: Lisp files [Contents][Index]
ods.lisp (file)
clods (module)
src/content.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The clods-export-system package: | ||
| • The clods-export package: |
Next: The clods-export package, Previous: Packages, Up: Packages [Contents][Index]
clods-export.asd
Previous: The clods-export-system package, Up: Packages [Contents][Index]
package.lisp (file)
clods
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 classes: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
The list of generic font families supported by ODS documents.
fonts.lisp (file)
The list of font pitches supported by ODS documents.
text.lisp (file)
The valid font relief modes.
text.lisp (file)
The list of font sizes supported by ODS documents.
Alternatively, a string value can be used specifying the font size in CSS format (e.g. "18pt" or "1.2cm)".
fonts.lisp (file)
The list of font stretch values supported by ODS documents.
fonts.lisp (file)
The list of font styles supported by ODS documents.
fonts.lisp (file)
The list of font variants supported by ODS documents.
fonts.lisp (file)
The list of font weights supported by ODS documents. Additionally, numeric values 100-900 can be used.
fonts.lisp (file)
The valid line modes.
text.lisp (file)
The valid ODS line styles.
text.lisp (file)
The valid ODS line types.
text.lisp (file)
The valid line widths. Alternatively, a standard CSS length spec can be used (e.g. "2pt" or "0.1cm").
text.lisp (file)
The valid script types.
text.lisp (file)
The set of supported keywords for text-properties.
text.lisp (file)
The valid text transformations.
text.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Specify the fonts to be used in the document.
fonts.lisp (file)
Specify the styles to be used in the document. The default locale can be specified; in this case, all styles get that locale automatically.
styles.lisp (file)
This form encloses the actual content of the spreadsheet document.
The document consists of 1 to n tables that are written with the with-table macro.
content.lisp (file)
Header columns may be grouped together with this form.
They do not have a visual effect, but may carry a semantic meaning.
content.lisp (file)
Header rows may be grouped together with this form.
They do not have a visual effect, but may carry a semantic meaning.
content.lisp (file)
Encloses a single row (or several similar, if the repeat arugment is used) on the table.
content.lisp (file)
The main interface macro for CLODS-EXPORT.
Creates a ODS document out of the body of the form and stores it into
the specified file. The optional keyword arguments generator and
creator are written in the document’s metadata.
ods.lisp (file)
Content of a single table (work sheet) on the document.
content.lisp (file)
Next: Exported classes, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Write out the contents of a data cell.
The cell may span several columns or rows, and it can contain a
formula or formatted data. The content is formatted according to the
chosen data style (first cell style; if not specified, current row
style; if not specified, current column style; if not specified, an
error is signalled unless content is a string).
The following content types are supported:
* _real_ maps to ODS float, currency, or percentage type, according to the chosen style.
* _local-time:timestamp_ maps to ODS date or time type, according to the chosen style.
* the keywords :true and :false map to the ODS boolean type
* _string_ is the content as-is, without formatting or numeric value.
content.lisp (file)
Generator for <style:style style:family="table-cell">.
styles.lisp (file)
A convenience function for writing out a set of cells with no special formatting.
content.lisp (file)
Define a column (or, with the repeat argument, several similar columns).
content.lisp (file)
Generator for <style:style style:family="table-column">.
styles.lisp (file)
Write out a set of covered cells.
When a cell spans several columns horizontally, the covered cells are
written automatically, but when spanning over rows vertically, the
user of the library is responsible of adding the covered cells where
the vertical spanning takes place.
content.lisp (file)
Define a font with the given name and specs.
The font can be referenced in style definition using the given name.
fonts.lisp (file)
Make a new locale with the given ISO 3166 country code, number grouping separator, number grouping length, and decimal separator.
locale.lisp (file)
Specify a number:boolean-style. The value is formatted as the strings given in the true and false arguments.
styles.lisp (file)
Specify a number:currencty-style.
The format is a plist of the tags :symbol, :text and :number; for
example, ’(:number (:min-integer-digits 1 :decimal-places 2) :text " " :symbol "€").
styles.lisp (file)
Specify a number:date-style.
The format is a list of the tags :[long/short]-[day/month/year/era/day-of-week/week-of-year/quarter/hours/minutes/seconds/am-pm]
and strings, for example ’(:long-year "-" :long-month "-" :long-day).
styles.lisp (file)
Specify a number:number-style. The format is a plist with the following tags:
* :min-integer-digits :number-grouping for all number styles,
* :decimal-replacement :display-factor for normal number styles,
* :decimal-places for normal and scientific styles,
* :min-exponent-digits for scientific styles,
* :denominator-value :min-denominator-digits :min-numerator-digits for fraction styles.
styles.lisp (file)
Specify a number:percentage-style. The format is the same as for number-number-style.
styles.lisp (file)
Specify a number:text-style. Used for simple text content.
styles.lisp (file)
Specify a number:time-style.
The format is a list of the tags :[long/short]-[hours/minutes/seconds/am-pm]
and strings, for example ’(:long-hours ":" :long-minutes ":" :long-seconds).
styles.lisp (file)
Generator for <style:style style:family="table-row">.
styles.lisp (file)
Generator for <style:style style:family="table">.
styles.lisp (file)
Previous: Exported functions, Up: Exported definitions [Contents][Index]
styles.lisp (file)
base-style (class)
content.lisp (file)
standard-object (class)
:style
col-style (generic function)
:repeat
1
col-repeat (generic function)
styles.lisp (file)
base-style (class)
numbers.lisp (file)
number-base-style (class)
:prefix
:suffix
:true
:false
numbers.lisp (file)
number-base-style (class)
:format
numbers.lisp (file)
number-date-time-style (class)
ods-value-type (method)
numbers.lisp (file)
number-base-style (class)
number-percentage-style (class)
:format
:prefix
:suffix
numbers.lisp (file)
number-number-style (class)
numbers.lisp (file)
number-base-style (class)
:prefix
:suffix
numbers.lisp (file)
number-date-time-style (class)
ods-value-type (method)
styles.lisp (file)
base-style (class)
styles.lisp (file)
base-style (class)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables: | ||
| • Internal macros: | ||
| • Internal functions: | ||
| • Internal generic functions: | ||
| • Internal classes: |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
The set of columns defined for the current document.
content.lisp (file)
Track the current column when filling in data.
content.lisp (file)
Holds the default style specified for the current row.
content.lisp (file)
numbers.lisp (file)
locale.lisp (file)
Pointer to the last cons cell of the columns list, to facilitate appending of new columns.
content.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
namespaces.lisp (file)
Tracks the state of the document being constructed.
Various forms appearing in a with-spreadsheet form must be specified
in the correct order; if the order is violated, an error is signalled.
ods.lisp (file)
A dictionary of all defined styles in the document.
ods.lisp (file)
The set of text properties supported, with the validation rules for their content.
text.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
Helper macro for defining number styles.
styles.lisp (file)
Helper macro for style:style generators.
styles.lisp (file)
namespaces.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
Helper function for writing out a date or time style.
styles.lisp (file)
Helper function to enforce state on the various style specs.
styles.lisp (file)
Format a number according to number formatting flags and the given locale.
numbers.lisp (file)
Convert a keyword into a lower-case string.
The optional allowed parameter can be specified to restrict the set of
accepted keywords (:kw1 :kw2 ...) and/or to specify different strings
for the keywords ((:kw1 "kw1-string") (:kw2 "kw2-string") ...).
A keyword not on the allowed keywords list will signal a type-error.
util.lisp (file)
Create a manifest document for files in the ODS zip
ods.lisp (file)
Create a meta.xml document, specifying a generator and creator
ods.lisp (file)
Create a mimetype file for the ODS zip
ods.lisp (file)
Create an empty styles.xml document
ods.lisp (file)
princ-to-string a number, enforcing a decimal, non-exponential form.
util.lisp (file)
Remove the nanoseconds part from a local-time generated timestring, e.g. "2015-02-18T08:07:02.000000Z" to "2015-02-18T08:07:02Z"
util.lisp (file)
Validate a color specification.
A valid color is a six-digit hexadecimal number preceded by a #.
util.lisp (file)
Check that the given datum is a valid font weight.
text.lisp (file)
Helper function for writing the background color specification.
styles.lisp (file)
Helper function for writing out attributes that are common to rows and columns.
content.lisp (file)
Helper function to write out a number specification.
Type of the number (normal/scientific/fraction) is deduced from the flags.
styles.lisp (file)
Write a list containing text properties into the XML document.
text.lisp (file)
Package a set of files into a zip archive
ods.lisp (file)
Next: Internal classes, Previous: Internal functions, Up: Internal definitions [Contents][Index]
automatically generated reader method
content.lisp (file)
automatically generated reader method
content.lisp (file)
automatically generated reader method
locale.lisp (file)
Format data according to a number-*-style.
numbers.lisp (file)
automatically generated reader method
locale.lisp (file)
automatically generated reader method
locale.lisp (file)
automatically generated reader method
locale.lisp (file)
Retrieve the ODS value-type for the number-*-style.
numbers.lisp (file)
automatically generated reader method
styles.lisp (file)
automatically generated reader method
numbers.lisp (file)
Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
styles.lisp (file)
standard-object (class)
:name
style-name (generic function)
:data-style
:%-data-style
locale.lisp (file)
standard-object (class)
:country
locale-country (generic function)
:grouping-separator
grouping-separator (generic function)
:grouping-count
grouping-count (generic function)
:decimal-separator
#\full_stop
decimal-separator (generic function)
numbers.lisp (file)
standard-object (class)
:name
style-name (generic function)
:locale
numbers.lisp (file)
number-base-style (class)
format-data (method)
:format
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: | C F L M |
|---|
| Jump to: | C F L M |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | C D E F G K L M N O P R S T U V W Z |
|---|
| Jump to: | C D E F G K L M N O P R S T U V W Z |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | %
*
C D F G L N P R S T |
|---|
| Jump to: | %
*
C D F G L N P R S T |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | B C L N P R S T |
|---|
| Jump to: | B C L N P R S T |
|---|