The vellum Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The vellum Reference Manual

This is the vellum Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 06:06:16 2022 GMT+0.

Table of Contents


1 Introduction

#+BEGIN_QUOTE
Si vis memoriae, para vellum.
#+END_QUOTE

** What is Vellum?
   Vellum is a data frame library build for Common Lisp. It is designed to be easy to both learn and use (especially in interactive fashion), practical, and reasonably efficient. Note that this software is in beta quality at the moment.

** Why I made Vellum?
Common Lisp is a fine language with exceptional interactivity, multiple implementations providing the potential for acceptable performance, useful features like condition system, and a stable standard base. This, in theory, makes is very much suited toward data processing and analysis. Although practice paints a less favorable picture, there are still use cases where Common Lisp could be considered to be a very good pick. Also, I simply like writing Lisp code.

Before Vellum existed I usually represented my data as vector-of-vectors (outer vector hold rows, inner vectors are rows). Then I would define accessors to obtain specific value from the data structure. This works but has a few distinct shortcomings. First off, it is not very flexible: I don't want to keep track of what a column with a specific number holds, I just want to refer to it by name. Secondly, I found that code written around such representations is difficult to read. After getting back to an old file I had to explain each individual line back to myself and this means that I am very likely to introduce mistakes If I have to change a thing. Higher-level semantics would help with that. Finally, I often work with a very sparse, and rather large, datasets. Enough so actually that I may simply run out of memory to represent all of my giganulls.

None of the above issues alone is substantial enough to be considered a real problem. However, in combination, and especially in an interactive programming context; when you want to get your code running as soon as possible, they really add up to a frustrating environment. I needed a nice, easy to use data frame library. Vellum is a such library for me, and I sincerely hope that it is a useful tool for you as well!

** Mindset
The main goal of the Vellum was to create a lispy data frame library, and therefore it should come with no surprise that the design is very different from a more famous Pandas for python. Although I attempted to emulate R lang workflow, Common Lisp, even with all of its awesomeness, lacks some of the R features (namely first-class expressions and environments) therefore the end result can be considered to be quite a bit unique. You are probably considering this is a drawback. However, I hope to demonstrate that Vellum is a approachable library.

** Header + Columns = Data Frame
Data Frame is composed of header and columns. The header can be thought of as a data schema, containing column names, and column types for stored values and is required to create a table. Let's construct an empty data frame.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (vellum:make-table
     :header (vellum:make-header '(:name first-column)
                                 '(:name second-column :type fixnum))))
#+END_SRC

You may be under impression that there has to be a better way to it. You would be correct.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (vellum:make-table :columns '(first-column
                                  (:name second-column :type fixnum))))
#+END_SRC

** Read and write data
A freshly constructed data frame is obviously empty. However, the meaning of empty is somewhat blurred in vellum. Data frames are sparse in concept, meaning that they lack a natural bound. This means that although, you can locate the last non-empty row...

#+BEGIN_SRC common-lisp
(print (vellum:row-count *table*)) ; => 0
#+END_SRC

But an attempt to get non-existing data won't signal error.

#+BEGIN_SRC common-lisp
(print (vellum:at *table* 5 'first-column)) ; => :NULL
;; oh, btw, column names are actually strings, meaning that this...
(print (vellum:at *table* 5 "first-column")) ; => :NULL
;; will also work. Also, this means that you don't have to import symbols just to access data.
#+END_SRC

Furthermore, VELLUM:AT is actually a setfable place which means that you can even...

#+BEGIN_SRC common-lisp
(setf (vellum:at *table* 5 'first-column) "first value")
(print (vellum:at *table* 5 'first-column)) ; => first value
(print (vellum:row-count *table*)) ; => 6
(setf (vellum:at *table* 5 'first-column) :null) ; => error signalled, to remove value from the table use erase! function
(vellum:erase! *table* 5 'first-column)
(print (vellum:row-count *table*)) ; => 0
#+END_SRC

If one would want to, he could fill the content of the data frame in a loop. But that would be awkward, wouldn't it? I suspect that you would prefer some sort of a batch method that would be handier.

** TRANSFORM and BIND-ROW
This is where the TRANSFORM function and BIND-ROW macro combination comes in. The intent is to construct simple to use and universal facility to perform all kinds of row operations in a handy way. It is easy to demonstrate this on an example For instance, let's say that we want to calculate body mass index from weight and height. The formula is simple enough: weight (in kilograms) divided by height (in meters) squared. Given that our data frame already contains weight, height, and BMI columns, code becomes...

#+BEGIN_SRC common-lisp
  (vellum:transform *table*
                    (vellum:bind-row (bmi weight height)
                      (setf bmi (/ weight (* height height))))
                    :in-place t)
#+END_SRC

BIND-ROW is a macro that will expand to a lambda form returning another lambda form with a variables corresponding to the columns designated and extra boilerplate code for putting those values back into the data frame. Keyword argument :in-place allows for destructive changes. You may think that this is a bad idea sometimes given that a stray condition will leave your data messed up and I am happy to inform you that this is not the case. TRANSFORM is an exception-safe function that will alter the content of the table only after completion. IN-PLACE defaults to NIL anyway though.

TRANSFORM allows for a few extra tricks though. For instance, if we want to calculate BMI for individuals above a certain height, we can do this by using DROP-ROW. To demonstrate this idea:

#+BEGIN_SRC common-lisp
  (defparameter *above-170-only*
    (vellum:transform *table*
                      (vellum:bind-row (bmi weight height)
                        (if (<= height 1.7)
                            (vellum:drop-row)
                            (setf bmi (/ weight (* height height))))))))
#+END_SRC

Notice that this time I've left the original frame untouched. Other keyword arguments for the transform functions are :START (the first row that should be touched, defaults to 0) and :END (1+ the last row that should be touched, defaults to the ROW-COUNT). It is possible to pass NIL as :END which will mean that the programmer decided to terminate transform manually. This is quite handy when populating an empty data frame...

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (alexandria:with-input-from-file (stream "bmi data.txt")
      (vellum:transform (vellum:make-table :columns '((:name weight)
                                                      (:name bmi)
                                                      (:name height)))
                        (vellum:bind-row (weight height bmi)
                          (let ((line (read-line stream nil nil)))
                            (if (null line)
                                (vellum:finish-transformation)
                                (destructuring-bind ((new-weight new-height) (parse-data-line line))
                                    (setf weight new-weight
                                          height new-height
                                          bmi (/ weight (* height height)))))))
                        :end nil)))
#+END_SRC

This won't work if your data source insists on driving reading data. If API has just MAP-DATA function and no iterator you may think that you are screwed. Don't worry, there is also TRANSFORMATION that construct a sort of transform iterator that you can move on your own. More of that later.

One more thing: you can actually use name different from :name in the column. This comes in handy when the name is a reserved symbol or (perhaps even more often) when there is simply no name, to begin with. In such case, the following will do the trick.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (alexandria:with-input-from-file (stream "bmi data.txt")
      (vellum:transform (vellum:make-table :columns '((:name weight)
                                                      (:name bmi)
                                                      (:name height)))
                        (vellum:bind-row ((weight-but-different 0) height bmi)
                          (let ((line (read-line stream nil nil)))
                            (if (null line)
                                (vellum:finish-transformation)
                                (destructuring-bind ((new-weight new-height) (parse-data-line line))
                                    (setf weight-but-different new-weight
                                          height new-height
                                          bmi (/ weight-but-different (* height height)))))))
                        :end nil)))
#+END_SRC

** TO-TABLE and COPY-FROM
Instead of bothering with TRANSFORM just to create table, one can use either TO-TABLE or COPY-FROM. They actually do almost the same thing. TO-TABLE is a CL-DS aggregation function, meaning that it works on all kinds of CL-DS ranges (as long as they return CL:SEQUENCE) and SEQUENCEs holding SEQUENCEs. The inner SEQUENCE is a row. It is probabbly easier to demonstrate.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (vellum:to-table '((:moose 1 2) (:gazelle 3 4))
                     :columns '(animal category1 category2)))
#+END_SRC

The above will construct table with 3 columns: ANIMAL, CATEGORY1 and CATEGORY2 and 2 rows. The first row is :moose 1 2, the second row is :gazelle 3 4. CL-DS ranges sometimes can be more memory efficient then the plain vector/list of vectors/lists. CL-DS:XPR for instance can be used to construct a lazy generator. Table with 500 numbers...

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (vellum:to-table (cl-ds:xpr (:i 0)
                       (when (< i 500)
                         (cl-ds:send-recur (list i) :i (1+ i))))
                     :columns '(iota)))
#+END_SRC

Aleternatively, one can use simpler CL-DS:XPR form, combined with the CL-DS.ALG:RESTRAIN-SIZE function.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (vellum:to-table (cl-ds.alg:restrain-size
                      (cl-ds:xpr (:i 0)
                        (cl-ds:send-recur (list i) :i (1+ i)))
                      500)
                     :columns '(iota)))
#+END_SRC

TO-TABLE is an CL-DS aggregation function, meaning that it can be used in conjuction with GROUP-BY and other layer functions. This makes certain operations very simple. For instance, if we have a list with some montly values, and we want to calculate 3 months average for the each data point...

#+BEGIN_SRC common-lisp
  (defparameter *monthly-numbers*
    '(1000 5000 2000
      3000 2130 150
      4000 9000 1130
      390 2000 1000))

  (defparameter *table*
    (vellum:to-table
     (cl-ds.alg:sliding-window *monthly-numbers* 3)
     :columns '(month-1 month month+1 avg)
     :body (vellum:bind-row (avg)
             (setf avg (cl-ds.math:average (vellum:vs 0 1 2) :sum 0.0)))))
#+END_SRC

But more on that later.

COPY-FROM is almost like TO-TABLE, but the input it is inteded to be used on objects that are not CL-DS ranges or CL sequences. This includes, for instance, paths to files, SQL queries, network handlers, and so one. If you want to implement new data source, just specialize COPY-FROM generic function and you are done! Let me demonstrate...

#+BEGIN_SRC common-lisp
  (defmethod vellum:copy-from ((format (eql :custom-tab-separated-format)) file-path &key columns)
    (let ((columns-count (length columns)))
      (with-open-file (stream file-path)
        (vellum:transform (vellum:make-table :columns columns)
          (vellum:bind-row ()
             (let ((row (read-line stream nil nil)))
               (when (null row)
                 (vellum:finish-transformation))
               (let ((values (cl-ppcre:split #\tab row)))
                 (loop :for i :from 0 :below columns-count
                       :for elt :in values
                       :do (setf (vellum:rr i) elt)))))
          :in-place t))))
#+END_SRC

The above example sacrifices some of the features (most notably: converting from the textual format to a lisp data type) in the name of clarity. By the way, generic functions can make wonders for the extensions! As for the extensions... vellum-csv system implements COPY-FROM :CSV while vellum-postmodern implements COPY-FROM :POSTMODERN. If you want to see more examples of COPY-FROM implementations you can check the source code of these systems.

** Columns manipulation
Usually, BMI would not be present in the data frame from the start and must be somehow added. Vellum does not make this needlessly complex. Simply use NEW-COLUMNS function.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (alexandria:with-input-from-file (stream "bmi data.txt")
      (vellum:add-columns (vellum:transform (vellum:make-table :columns '((:name weight)
                                                                          (:name height)))
                                            (vellum:bind-row (weight height)
                                              (let ((line (read-line stream nil nil)))
                                                (if (null line)
                                                    (vellum:finish-transformation)
                                                    (destructuring-bind (new-weight new-height) (parse-data-line line)
                                                        (setf weight new-weight
                                                              height new-height)))))
                                            :end nil)
                          '(:name bmi))))
#+END_SRC

Let's admit it: this is getting a little bit nested. From now one I will use threading macro ~> from serapeum. By using this macro we are getting a somewhat more understandable form that does the exact same thing.

#+BEGIN_SRC common-lisp
  (defparameter *table*
    (alexandria:with-input-from-file (stream "bmi data.txt")
      (serapeum:~>
       (vellum:make-table :columns '((:name weight) (:name height)))
       (vellum:transform (vellum:bind-row (weight height)
                           (let ((line (read-line stream nil nil)))
                             (if (null line)
                                 (vellum:finish-transformation)
                                 (destructuring-bind (new-weight new-height) (parse-data-line line)
                                     (setf weight new-weight
                                           height new-height)))))
                         :end nil)
       (vellum:add-columns '(:name bmi))))
#+END_SRC

Either way, it is impossible to change the number of columns in the table in a destructive way. This is by design as vellum headers are immutable as well.

Selecting a subset of the columns is equally important to add new columns. To do this in Vellum we should use VELLUM:SELECT function. Now, this function is slightly more complex, and it is all because of the input. For instance, to select just a single column…

#+BEGIN_SRC common-lisp
  (defparameter *table* (vellum:make-table :columns '((:name first-colum)
                                                      (:name second-column)
                                                      (:name third-column))))
  (defparameter *just-second-and-third* (vellum:select *table*
                                          :columns '(1 2)))
  (defparameter *just-second-and-third* (vellum:select *table*
                                          :columns '(second-column third-column)))
  (defparameter *just-second-and-third* (vellum:select *table*
                                          :columns (vellum:s (vellum:from :from 'second-column)))
  (defparameter *just-second-and-third* (vellum:select *table*
                                          :columns (vellum:s (vellum:from :from 1))))
#+END_SRC

All four ways to select second and third columns are equally valid. Selecting by range is probably not all that useful in the context of columns, however, the exact same syntax is used for :ROWS where it really it is in it's element.

#+BEGIN_SRC common-lisp
  (defparameter *table* (vellum:make-table :columns '((:name first-colum)
                                                      (:name second-column)
                                                      (:name third-column)
                                                      (:name fourth-column)
                                                      (:name fifth-column)
                                                      (:name sixth-column)
                                                      (:name seventh-column)
                                                      (:name eight-column)
                                                      (:name nine-column))))
  (defparameter *columns-subset* (vellum:select *table*
                                   :columns '(2 3 4 7 8 9)))
  (defparameter *columns-subset* (vellum:select *table*
                                   :columns (alexandria:iota 6 :start 2)))
  (defparameter *columns-subset* (vellum:select *table*
                                   :columns (vellum:s '(2 . 10))))
  (defparameter *columns-subset* (vellum:select *table*
                                   :columns (vellum:s 2 (vellum:between :to 10))))
  (defparameter *columns-subset* (vellum:select *table*
                                   :columns (vellum:s 2 3 4 7 (vellum:between :to 10))))
#+END_SRC

Depending on the specific use case each of those ways can be the most suitable.

Select can be also used to establish new names for columns. To do so, provide list with two elements.

#+BEGIN_SRC common-lisp
(defparameter *table* (vellum:make-table :columns '((:name first-colum)
                                                    (:name second-column)
                                                    (:name third-column))))
(defparameter *just-second-and-third* (vellum:select *table*
                                        :columns '((1 (:name new-first-column)) 2)))
(defparameter *just-second-and-third* (vellum:select *table*
                                        :columns '((second-column new-first-column)
                                                   third-column)))
#+END_SRC

The second element supports all the same options as the make-table :columns element itself.

Instead of using select for renaming columns, you can also use rename-columns, like this:
#+BEGIN_SRC common-lisp
  (vellum:rename-columns *table* 1 'new-first-column)
#+END_SRC

** Joins
So, working with relations? Chances are you gonna use JOIN.

#+BEGIN_SRC common-lisp
(let* ((frame-1 (transform (vellum:make-table :columns '(a b))
                           (vellum:bind-row (a b)
                             (setf a vellum.table:*current-row*)
                             (setf b (format nil "a~a" a)))
                             :end 5))
         (frame-2 (transform (vellum:make-table :columns '(a b))
                             (vellum:bind-row (a b)
                               (setf a vellum.table:*current-row*)
                               (setf b (format nil "b~a" a)))
                             :end 5))
         (result (vellum:join :hash :inner
                              `((:frame-1 ,frame-1 a)
                                (:frame-2 ,frame-2 a)))))
    (vellum:show :text result))
#+END_SRC

The above example demonstrates how to use the join function to construct a new data frame containing columns from both frame-1 and frame-2. As you may noticed, both frame-1 and frame-2 contain the columns of the same names, meaning that the input to the join function must contain the co called label (the first element of the inner list, in this specific example :frame-1 and :frame-2). Labels will be used to construct names of columns in the result table. In this specific example the result table looks as follows.

#+begin_src
FRAME-1/A  FRAME-1/B  FRAME-2/A  FRAME-2/B
==========================================
4          a4         4          b4
3          a3         3          b3
2          a2         2          b2
1          a1         1          b1
0          a0         0          b0
#+end_src

Column A in both columns was used to perform the join (third element in the inner list). It is also possible to use multiple columns as a join key , in which case they will be combined into list. To do so, simply add additional columns after the second argument, for instance: (:frame-1 frame-1 a b). Note, that hash-join uses by default 'eql test for the internal hash-table, which is not suited to such use case.

Notice that the label was used as a prefix. This often means that you will want to rename columns. Use the SELECT function to do that (either on the join arguments, or the join result). It is also possible that the column names won't conflict in the resulting table, in such case you can place NIL as the label. For example:

#+begin_src
(let* ((frame-1 (transform (make-table :columns '(a b))
                           (vellum:bind-row (a b)
                             (setf a vellum.table:*current-row*)
                             (setf b (format nil "a~a" a)))
                           :end 5))
       (frame-2 (transform (make-table :columns '(a b))
                           (vellum:bind-row (a b)
                             (setf a vellum.table:*current-row*)
                             (setf b (format nil "b~a" a)))
                           :end 5))
       (result (join :hash :inner
                     `((nil ,frame-1 a)
                       (:frame-2 ,frame-2 a)))))
  (vellum:show :text result))

A  B   FRAME-2/A  FRAME-2/B
===========================
4  a4  4          b4
3  a3  3          b3
2  a2  2          b2
1  a1  1          b1
0  a0  0          b0
#+end_src

Currently only the hash join algorithm is supported. On the other hand, you can use both :left and :inner joins, just like in the SQL.

** Other functions
Use HSTACK and VSTACK to concatenate tables column-wise and row-wise. Use ORDER-BY to sort table content. Use NEW-COLUMNS to add new columns to a table (non destructive).

** A few remarks about the inner representation and efficiency
Vellum stores data in a column format, where each column is a sparse variant of an RRB trie. I've chosen this type of representation for efficient copy-on-write. Copy-on-write is important as it allows for exception safety in the transform function as well as reduces memory usage by allowing safe sharing of the common data bits. However, at the same time, data frames expose a mutable interface. You could consider it to be unusual.

In fact, Vellum has a concept of ownership, meaning that each RRB trie node is owned by a data frame instance. If it happens that you are attempting to mutate a node owned by the current data frame, mutating is allowed. Otherwise, a new copy of the node is created but owned by the current data frame. This prevents spilling side effects outside of the data frame.

This also means that constructing a copy of the data frame can be optimized beyond a deep copy. REPLICA function will return a new instance of a data frame passed as the first argument. Changes performed on the returned data frame won't leak to the passed data frame. Additionally, if you pass T as the second argument (defaults to NIL) changes to the original data frame won't leak the new data frame. You probably won't be using REPLICA function all that often, but if you want to keep a history of your data changes in your lisp process this trick can be quite useful.

** Riding on the cl-data-structures
CL-data-structures is my other library. The name is a misnomer as the library grew into a hulking abomination of feature creep. I want to eventually divide it into smaller pieces but it is useful regardless. This is especially because of the ranges and algorithms implemented within. They work like Java Stream interface. Consider a common task of calculating the average of column. To do it with cl-data-structures you will just…

#+BEGIN_SRC common-lisp
  (vellum:with-table (*table*)
    (cl-ds.math:average *table* :key (vellum:bind-row-closure (vellum:bind-row (column-name) column-name))))
#+END_SRC

Form passed as a :KEY is a very common pattern. Enough so that there is a shortening macro.

#+BEGIN_SRC common-lisp
  (vellum:with-table (*table*)
    (cl-ds.math:average *table* :key (vellum:brr column-name)))
#+END_SRC

BRR stands for body row reference if you are wondering. The above code can be shortened further…

#+BEGIN_SRC common-lisp
  (vellum:pipeline (*table*)
    (cl-ds.math:average :key (vellum:brr column-name)))
#+END_SRC

PIPELINE is called so because it is typically used to build longer control flows. For instance, by incorporating GROUP-BY.

#+BEGIN_SRC common-lisp
  (vellum:pipeline (*table*)
    (cl-ds.alg:group-by :key (vellum:brr grouping-column-name))
    (cl-ds.math:average :key (vellum:brr column-name)))
#+END_SRC

Besides GROUP-BY there are also other functions altering how aggregation is performed. For instance CL-DS.ALG:ARRAY-ELEMENTWISE will apply aggregation function independently for each position in the array of the input and will return array as a result. Anyway, you probably would rather have GROUP-BY return a data frame instead of the cl-data-structures range. This will require just one more extra form.

#+BEGIN_SRC common-lisp
  (vellum:pipeline (*table*)
    (cl-ds.alg:group-by :key (vellum:brr grouping-column-name))
    (cl-ds.math:average :key (vellum:brr column-name))
    (vellum:to-table :columns '((:name group) (:name aggregation-result))))
#+END_SRC

And if you simply want to write code that mimics MS Excel, you can do that as well by using AGGREGATE-ROWS macro.

#+BEGIN_SRC common-lisp
  (vellum:aggregate-rows *table*
   :column1 ((cl-ds.math:average) :skip-nulls t)
   :column2 ((cl-ds.math:average) :skip-nulls t))
#+END_SRC

The above will construct a new data frame containing two columns (with names :column1 and :column2) and one row, holding the average of the column1 and column2 of the original table. The :SKIP-NULLS option prevents code from erroring out on the :NULL. It also improves performance somewhat.

** Integrating with other stuff
As hinted before, Vellum is designed to be easy to use with other libraries. For instance, let's say you want to use postmodern to access the postgres database where you are keeping your data safe and warm. To do so, you can do the following.

#+BEGIN_SRC common-lisp
  (defparameter *table* (vellum:make-table :columns '((:name first-column) (:name second-column))))
  (vellum:with-table (*table*)
    (postmodern:with-connection '("database" "username" "password" "localhost")
      (let ((transformation (vellum.table:transformation *table* nil :in-place t :start 0))
            (vellum.header:set-row (vellum.table:standard-transformation-row transformation))
            (postmodern:doquery (:select 'first_column 'second_column :from 'table)
                (first_column second_column)
              (vellum.table:transform-row
               transformation
               (vellum:bind-row (first-column second-column)
                 (setf first-colum first_column
                       second-column second_column)))))
            (vellum.table:transformation-result transformation))))
#+END_SRC

Postmodern is a really nice library, but doquery insists on driving its own iteration. As you can see that's not a big deal. For libraries that present us with an iterator-like interface, you can simply use TRANSFORM directly. Just don't forget to pass NIL as :END and call VELLUM:FINISH-TRANSFORMATION from the BIND-ROW form. I already showed you how.

** The future
Support for additional data sources and storage formats will be added into seperated systems in the vellum project itself. I actually already added support for constructing data frames out of the postmodern queries as well as CSV file handling build with fare-csv library. I would like to also support parquet files (with the help of cl-apache-arrow). Stay tuned.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 vellum

Data Frames for Common Lisp

Author

Marek Kochanowicz

License

BSD simplified

Version

1.0.0

Dependencies
  • iterate (system).
  • serapeum (system).
  • lparallel (system).
  • closer-mop (system).
  • metabang-bind (system).
  • alexandria (system).
  • cl-data-structures (system)., at least version ((>= asdf/user::|1.0.0|))
  • documentation-utils-extensions (system).
Source

vellum.asd.

Child Components

3 Modules

Modules are listed depth-first from the system components tree.


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 vellum/column

Dependency

aux-package.lisp (file).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.2 vellum/header

Dependency

column (module).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.3 vellum/selection

Dependency

header (module).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.4 vellum/table

Dependency

selection (module).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.5 vellum/api

Dependency

table (module).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

Previous: , Up: Modules   [Contents][Index]

3.6 vellum/integration

Dependency

api (module).

Source

vellum.asd.

Parent Component

vellum (system).

Child Components

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

4.1.1 vellum/vellum.asd

Source

vellum.asd.

Parent Component

vellum (system).

ASDF Systems

vellum.


4.1.2 vellum/aux-package.lisp

Source

vellum.asd.

Parent Component

vellum (system).

Packages

vellum.aux-package.


4.1.3 vellum/column/package.lisp

Source

vellum.asd.

Parent Component

column (module).

Packages

vellum.column.


4.1.4 vellum/column/protocol.lisp

Source

vellum.asd.

Parent Component

column (module).

Public Interface

4.1.5 vellum/column/types.lisp

Source

vellum.asd.

Parent Component

column (module).

Public Interface
Internals

4.1.6 vellum/column/conditions.lisp

Source

vellum.asd.

Parent Component

column (module).

Public Interface

column-type-error (condition).

Internals

4.1.7 vellum/column/docstring.lisp

Source

vellum.asd.

Parent Component

column (module).


4.1.8 vellum/column/internal.lisp

Source

vellum.asd.

Parent Component

column (module).

Internals

4.1.9 vellum/column/implementation.lisp

Source

vellum.asd.

Parent Component

column (module).

Public Interface
Internals

4.1.10 vellum/header/package.lisp

Source

vellum.asd.

Parent Component

header (module).

Packages

vellum.header.


4.1.11 vellum/header/variables.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface

4.1.12 vellum/header/types.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface
Internals

4.1.13 vellum/header/macros.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface

with-header (macro).


4.1.14 vellum/header/protocol.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface
Internals

column-signature-spec (generic function).


4.1.15 vellum/header/utils.lisp

Source

vellum.asd.

Parent Component

header (module).


4.1.16 vellum/header/functions.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface
Internals

4.1.17 vellum/header/conditions.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface
Internals

no-row (condition).


4.1.18 vellum/header/internal.lisp

Source

vellum.asd.

Parent Component

header (module).

Internals

4.1.19 vellum/header/implementation.lisp

Source

vellum.asd.

Parent Component

header (module).

Public Interface
Internals

4.1.20 vellum/header/documentation.lisp

Source

vellum.asd.

Parent Component

header (module).


4.1.21 vellum/selection/package.lisp

Source

vellum.asd.

Parent Component

selection (module).

Packages

vellum.selection.


4.1.22 vellum/selection/implementation.lisp

Source

vellum.asd.

Parent Component

selection (module).

Public Interface
Internals

4.1.23 vellum/table/package.lisp

Source

vellum.asd.

Parent Component

table (module).

Packages

vellum.table.


4.1.24 vellum/table/variables.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

*transform-control* (special variable).


4.1.25 vellum/table/macros.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface

4.1.26 vellum/table/generics.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

4.1.27 vellum/table/types.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

4.1.28 vellum/table/conditions.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface

4.1.29 vellum/table/functions.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

4.1.30 vellum/table/documentation.lisp

Source

vellum.asd.

Parent Component

table (module).


4.1.31 vellum/table/to-table.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

to-table-function (class).


4.1.32 vellum/table/internal.lisp

Source

vellum.asd.

Parent Component

table (module).

Internals

4.1.33 vellum/table/implementation.lisp

Source

vellum.asd.

Parent Component

table (module).

Public Interface
Internals

read-iterator (method).


4.1.34 vellum/api/package.lisp

Source

vellum.asd.

Parent Component

api (module).

Packages

vellum.


4.1.35 vellum/api/conditions.lisp

Source

vellum.asd.

Parent Component

api (module).

Public Interface

4.1.36 vellum/api/generics.lisp

Source

vellum.asd.

Parent Component

api (module).

Public Interface

4.1.37 vellum/api/functions.lisp

Source

vellum.asd.

Parent Component

api (module).

Public Interface
Internals

4.1.38 vellum/api/macros.lisp

Source

vellum.asd.

Parent Component

api (module).

Public Interface

4.1.39 vellum/integration/package.lisp

Source

vellum.asd.

Parent Component

integration (module).

Packages

vellum.integration.


4.1.40 vellum/integration/cl-ds.lisp

Source

vellum.asd.

Parent Component

integration (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 vellum.integration

Source

package.lisp.

Nickname

vellum.int

Use List
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 vellum.column

Source

package.lisp.

Use List
Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 vellum

Source

package.lisp.

Use List
Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 vellum.table

Source

package.lisp.

Use List
Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 vellum.selection

Source

package.lisp.

Use List
Public Interface
Internals

Previous: , Up: Packages   [Contents][Index]

5.7 vellum.header

Source

package.lisp.

Use List
Public Interface
Internals

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.1 Special variables

Special Variable: *current-row*
Package

vellum.table.

Source

variables.lisp.

Special Variable: *header*
Package

vellum.header.

Source

variables.lisp.

Special Variable: *row*
Package

vellum.header.

Source

variables.lisp.

Special Variable: *table*
Package

vellum.table.

Source

variables.lisp.

Special Variable: *transform-in-place*
Package

vellum.table.

Source

variables.lisp.


6.1.2 Macros

Macro: aggregate-columns (table expression &key name skip-nulls type)
Package

vellum.

Source

macros.lisp.

Macro: aggregate-rows (table column params &rest more)
Package

vellum.

Source

macros.lisp.

Macro: bind-row (selected-columns &body body)
Package

vellum.table.

Source

macros.lisp.

Macro: brr (column &rest other-columns)

Description:
Expands to a closure extracting COLUMN from the CURRENT-ROW if only one argument has been passed to the macro, or expands to a closure extracting multiple values packed into a list, elementwise.

Exceptional situations:
Expanded closure signals NO-COLUMN, NO-HEADER, NO-ROW exception if: column is not found in the current header, there is no active header, there is no active row.

Notes:
Expanded closure is not thread safe.

Package

vellum.table.

Source

macros.lisp.

Macro: drop-row-when (predicate)
Package

vellum.

Source

macros.lisp.

Macro: pipeline ((table) &body body)
Package

vellum.

Source

macros.lisp.

Macro: with-header ((header) &body body)

Description:
Expands to form binding *HEADER* and establishing *CURRENT-ROW*.

Notes:
Call SET-ROW to actually set the value of the row to a specific object.

Package

vellum.header.

Source

macros.lisp.

Macro: with-standard-header (columns &body body)
Package

vellum.

Source

macros.lisp.

Macro: with-table ((table) &body body)
Package

vellum.table.

Source

macros.lisp.


6.1.3 Ordinary functions

Function: %aggregate-columns (table aggregator-constructor &key skip-nulls type name)
Package

vellum.

Source

functions.lisp.

Function: %aggregate-rows (table &rest params)
Package

vellum.

Source

functions.lisp.

Function: add-columns (frame &rest column-specs)
Package

vellum.

Source

functions.lisp.

Function: between (&key from to)
Package

vellum.selection.

Source

implementation.lisp.

Function: column-names (table)
Package

vellum.table.

Source

functions.lisp.

Function: column-names (header)
Package

vellum.header.

Source

functions.lisp.

Function: column-signature (header name)

Description:
Returns the complete COLUMN-SIGNATURE object from the HEADER for the specified COLUMN.

Exceptional situations:
Will signal NO-COLUMN if no COLUMN in the HEADER.

Package

vellum.header.

Source

functions.lisp.

Function: column-type (header column)

Description:
What is the type stored inside the COLUMN?

Exceptional situations:
Will signal NO-COLUMN if no COLUMN in the HEADER.

Package

vellum.header.

Source

functions.lisp.

Function: columns (iterator)
Package

vellum.column.

Source

types.lisp.

Function: current-row-as-vector (&optional header row)
Package

vellum.table.

Source

functions.lisp.

Function: drop-row ()

Description:
Should be called from dynamic environment established in the callback passed to the TRANSFORM. When called, removes row from the data-frame and pefrorms non-local exit.

Package

vellum.table.

Source

functions.lisp.

Function: empty-column (&rest row-parameters)
Package

vellum.

Source

functions.lisp.

Function: ensure-index (header index/name)

Description:
Converts strings and symbols to index of column in the HEADER. If a numeric index is passed it is returned unaltered.

Exceptional situations:
Will signal NO-COLUMN if no column in the HEADER with such INDEX/NAME exists.

Package

vellum.header.

Source

functions.lisp.

Function: finish-transformation ()
Package

vellum.table.

Source

functions.lisp.

Function: header ()

Description:
Returns the current active header.

Exceptional situations:
Will signal NO-HEADER when there is no active header.

Package

vellum.header.

Source

functions.lisp.

Function: hstack (frames &key isolate)
Package

vellum.table.

Source

functions.lisp.

Function: index (iterator)
Package

vellum.column.

Source

types.lisp.

Function: index-to-name (header index)

Description:
Converts a numeric INDEX designating column to the column name in the HEADER.

Exceptional situations:
Signalls NO-COLUMN when the INDEX is not found in the HEADER.

Package

vellum.header.

Source

functions.lisp.

Function: iterator-at ()
Package

vellum.column.

Source

implementation.lisp.

Function: (setf iterator-at) ()
Package

vellum.column.

Source

implementation.lisp.

Function: make-header (&rest columns)

Description:
Construct the header instance of CLASS.

Package

vellum.header.

Source

functions.lisp.

Function: make-setfable-table-row (&key iterator)
Package

vellum.table.

Source

types.lisp.

Function: make-sparse-material-column (&key element-type)
Package

vellum.column.

Source

types.lisp.

Function: make-table (&key class columns header)
Package

vellum.table.

Source

functions.lisp.

Function: make-table-row (&key iterator)
Package

vellum.table.

Source

types.lisp.

Function: move-iterator (iterator times)
Package

vellum.column.

Source

implementation.lisp.

Function: move-iterator-to (iterator new-index)
Package

vellum.column.

Source

implementation.lisp.

Function: name-to-index (header name)

Description:
Converts a column NAME (which is either string or symbol) to the numeric index designating column in the HAEDER.

Exceptional situations:
Signalls NO-COLUMN when the NAME is not found in the HEADER.

Package

vellum.header.

Source

functions.lisp.

Function: nullify ()

Description:
Should be called from dynamic environment established in the callback passed to the TRANSFORM. Deletes all values in the current row, leaving :NULLs.

Package

vellum.table.

Source

functions.lisp.

Function: order-by (table column comparator &rest columns-comparators)
Package

vellum.

Source

functions.lisp.

Function: read-name (column-signature)
Package

vellum.header.

Source

types.lisp.

Function: read-new-value ()

Description:
This function is used only in order to provide interactive restarts.

Package

vellum.header.

Source

functions.lisp.

Function: rename-columns (table old-name new-name &rest more-names)
Package

vellum.

Source

functions.lisp.

Function: row ()
Package

vellum.header.

Source

functions.lisp.

Function: row-at (header row name)
Package

vellum.table.

Source

functions.lisp.

Function: (setf row-at) (header row name)
Package

vellum.table.

Source

functions.lisp.

Function: row-to-list (&rest forms)
Package

vellum.table.

Source

functions.lisp.

Function: row-to-vector (&rest forms)
Package

vellum.table.

Source

functions.lisp.

Function: rr (index &optional row header)

Description:
Extracts value from the current row.

Exceptional situations:
Signals NO-COLUMN, NO-HEADER, NO-ROW exception if: column is not found in the current header, there is no active header, there is no active row.

Package

vellum.table.

Source

functions.lisp.

Function: (setf rr) (index &optional row header)
Package

vellum.table.

Source

functions.lisp.

Function: rs (&rest forms)
Package

vellum.selection.

Source

implementation.lisp.

Function: s (&rest forms)
Package

vellum.selection.

Source

implementation.lisp.

Function: s-list (table &rest forms)
Package

vellum.

Source

functions.lisp.

Function: s-list (header &rest forms)
Package

vellum.selection.

Source

implementation.lisp.

Function: set-row (row)

Description:
Sets the inner value of *CURRENT-ROW* to the passed ROW.

Exceptional situations:
Will signal NO-ROW when *CURRENT-ROW* is unbound.

Package

vellum.header.

Source

functions.lisp.

Reader: sparse-material-column-iterator-index (instance)
Writer: (setf sparse-material-column-iterator-index) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

index.

Reader: standard-transformation-row (instance)
Writer: (setf standard-transformation-row) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

row.

Function: to-matrix (frame &key element-type key)
Package

vellum.

Source

functions.lisp.

Function: untouch (iterator)
Package

vellum.column.

Source

implementation.lisp.

Function: vstack (frames)
Package

vellum.table.

Source

functions.lisp.


6.1.4 Generic functions

Generic Function: address-range (selector/sequence translate limit)
Package

vellum.selection.

Source

implementation.lisp.

Methods
Method: address-range ((selector/sequence sequence) translate limit)
Method: address-range ((selector/sequence selector) translate limit)
Generic Function: alter-columns (table &rest columns)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: alter-columns ((frame standard-table) &rest columns)
Source

implementation.lisp.

Generic Function: alter-columns (header columns)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: alter-columns ((header standard-header) columns)
Source

implementation.lisp.

Generic Function: at (frame row column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: at ((frame standard-table) (row integer) column)
Source

implementation.lisp.

Generic Function: (setf at) (frame row column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: (setf at) ((frame standard-table) (row integer) column)
Source

implementation.lisp.

Generic Function: augment-iterator (iterator column)
Package

vellum.column.

Source

protocol.lisp.

Methods
Method: augment-iterator ((iterator sparse-material-column-iterator) (column sparse-material-column))
Source

implementation.lisp.

Generic Function: bind-row-closure (bind-row-object &key header)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: bind-row-closure (fn &key header)
Source

implementation.lisp.

Method: bind-row-closure ((bind-row (eql nil)) &key header)
Source

implementation.lisp.

Method: bind-row-closure ((bind-row bind-row) &key header)
Source

implementation.lisp.

Generic Function: check-column-signatures-compatibility (old-signature new-signature)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: check-column-signatures-compatibility ((first-signature column-signature) (second-signature column-signature))
Source

implementation.lisp.

Generic Function: column-at (column index)

Description:
Obtains value under INDEX from the COLUMN.

Returns:
Value under INDEX of the COLUMN. :NULL if location is empty.

Exceptional situations:
–Will signal INDEX-OUT-OF-COLUMN-BOUNDS if INDEX is out of column bounds. –Will signal type-error if INDEX is not NON-NEGATIVE-INTEGER.

Package

vellum.column.

Source

protocol.lisp.

Methods
Method: column-at ((column sparse-material-column) index)
Source

implementation.lisp.

Generic Function: (setf column-at) (column index)

Description:
Sets value under INDEX in the COLUMN.

Exceptional situations:
–Will signal INDEX-OUT-OF-COLUMN-BOUNDS if INDEX is out of column bounds. –Will signal type-error if INDEX is not NON-NEGATIVE-INTEGER.

Package

vellum.column.

Source

protocol.lisp.

Methods
Method: (setf column-at) ((column sparse-material-column) index)
Source

implementation.lisp.

Generic Function: column-at (frame column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: column-at ((frame standard-table) (column integer))
Source

implementation.lisp.

Method: column-at ((frame standard-table) column)
Source

implementation.lisp.

Generic Function: column-count (frame)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: column-count ((frame standard-table))
Source

implementation.lisp.

Generic Function: column-count (header)

Description:
How many columns header specifies?

Package

vellum.header.

Source

protocol.lisp.

Methods
Method: column-count ((header standard-header))
Source

implementation.lisp.

Generic Function: column-name (frame column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: column-name ((frame standard-table) (column integer))
Source

implementation.lisp.

Generic Function: column-size (column)

Description:
The total size of the COLUMN.

Package

vellum.column.

Source

protocol.lisp.

Methods
Method: column-size ((column sparse-material-column))
Source

implementation.lisp.

Generic Function: column-specs (header)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: column-specs ((header standard-header))
Source

implementation.lisp.

Generic Function: column-type (column)

Arguments:
–COLUMN, Data frame column.

Description:
Type of the elements stored in the column.

Package

vellum.column.

Source

protocol.lisp.

Methods
Method: column-type ((column sparse-material-column))
Source

implementation.lisp.

Generic Function: column-type (frame column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: column-type ((frame standard-table) column)
Source

implementation.lisp.

Generic Function: concatenate-headers (header &rest more-headers)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: concatenate-headers ((header standard-header) &rest more-headers)
Source

implementation.lisp.

Generic Function: content (selection translate current-position limit)
Package

vellum.selection.

Source

implementation.lisp.

Methods
Method: content ((selection between) translate current-position limit)
Generic Function: copy-from (format input &rest options &key body key class header-class columns header &allow-other-keys)
Package

vellum.

Source

generics.lisp.

Methods
Method: copy-from ((format (eql nil)) input &rest options &key body key class header-class columns header)
Generic Function: copy-to (format output input &rest options &key &allow-other-keys)
Package

vellum.

Source

generics.lisp.

Generic Function: erase! (frame row column)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: erase! ((frame standard-table) (row integer) column)
Source

implementation.lisp.

Generic Function: finish-iterator (iterator)
Package

vellum.column.

Source

protocol.lisp.

Methods
Method: finish-iterator ((iterator sparse-material-column-iterator))
Source

implementation.lisp.

Generic Reader: header (frame)
Package

vellum.table.

Source

generics.lisp.

Methods
Reader Method: header ((standard-table-range standard-table-range))

automatically generated reader method

Source

types.lisp.

Target Slot

%header.

Reader Method: header ((standard-table standard-table))

automatically generated reader method

Source

types.lisp.

Target Slot

%header.

Generic Function: hstack* (frame more-frames &key isolate)

Arguments:
–FRAME, A data frame. Columns from this data frame will be placed as first. –MORE-FRAMES, Traversable object presenting more of the data frames.

Description:
Concatenates multiple frames row-wise.

Package

vellum.table.

Source

generics.lisp.

Methods
Method: hstack* ((frame standard-table) more-frames &key isolate)
Source

implementation.lisp.

Generic Function: iterator (frame in-place)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: iterator ((frame standard-table) in-place)
Source

implementation.lisp.

Generic Function: join (algorithm method frame-specs &key header class header-class columns test &allow-other-keys)
Package

vellum.

Source

generics.lisp.

Methods
Method: join ((algorithm (eql :hash)) (method (eql :left)) (frame-specs list) &key class columns header test)
Source

functions.lisp.

Method: join ((algorithm (eql :hash)) (method (eql :inner)) (frame-specs list) &key class columns header test)
Source

functions.lisp.

Method: join :before (algorithm method (frame-specs list) &key &allow-other-keys)
Generic Function: make-iterator (columns &key transformation &allow-other-keys)

Description:
Constructs iterator from the column. Extra columns can be added into iterator with augment-iterator function.

Package

vellum.column.

Source

protocol.lisp.

Methods
Method: make-iterator (columns &key transformation)
Source

implementation.lisp.

Generic Function: make-row (range data)

Description:
Constructs new row validated for the HEADERs predicates from the DATA.

Notes:
Since there is no column at this level, you may expect that the COLUMN-TYPE-ERROR can’t be signalled. This is not true, as this function is used to implement the data-frame behavior for various streams. Examples of this is vellum-csv which depends on the whole base vellum package as a whole.

Package

vellum.header.

Source

protocol.lisp.

Methods
Method: make-row ((range frame-range-mixin) (data list))
Source

implementation.lisp.

Method: make-row :around (range data)
Source

implementation.lisp.

Method: make-row ((range frame-range-mixin) (data vector))
Source

implementation.lisp.

Generic Function: make-table* (class &optional header)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: make-table* ((class (eql vellum.table:standard-table)) &optional header)
Source

implementation.lisp.

Generic Reader: read-header (object)
Package

vellum.header.

Methods
Reader Method: read-header ((frame-range-mixin frame-range-mixin))

automatically generated reader method

Source

types.lisp.

Target Slot

%header.

Generic Function: remove-nulls (iterator)
Package

vellum.column.

Source

protocol.lisp.

Methods
Method: remove-nulls ((iterator sparse-material-column-iterator))
Source

implementation.lisp.

Generic Function: remove-nulls (frame &key in-place)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: remove-nulls ((frame standard-table) &key in-place)
Source

implementation.lisp.

Generic Function: row-count (frame)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: row-count ((frame standard-table))
Source

implementation.lisp.

Generic Function: select (frame &key columns rows)

Description:
Select subset of COLUMNS and ROWS from the FRAME.

Package

vellum.table.

Source

generics.lisp.

Methods
Method: select ((frame standard-table) &key rows columns)
Source

implementation.lisp.

Generic Function: select-columns (header columns)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: select-columns ((header standard-header) columns)
Source

implementation.lisp.

Generic Function: show (as table &key output start end &allow-other-keys)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: show ((as (eql :text)) (table fundamental-table) &key output start end)
Source

implementation.lisp.

Generic Function: to-table (range &key body key class columns header restarts-enabled &allow-other-keys)
Package

vellum.table.

Source

to-table.lisp.

Methods
Method: to-table ((range summary-result-range) &key key class columns body header &allow-other-keys)
Source

cl-ds.lisp.

Method: to-table ((range group-by-result-range) &key key class columns body header &allow-other-keys)
Source

cl-ds.lisp.

Method: to-table ((input array) &key class key columns body restarts-enabled header)
Method: to-table ((input sequence) &key key class columns body restarts-enabled header)
Method: to-table ((range frame-range-mixin) &key class body restarts-enabled &allow-other-keys)
Method: to-table (range &key key body class restarts-enabled columns header)
Generic Function: transform (frame function &key in-place start end restarts-enabled)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: transform ((frame standard-table) bind-row &key restarts-enabled in-place start end)
Source

implementation.lisp.

Generic Function: transform-row (transformation &optional bind-row-closure)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: transform-row ((object standard-transformation) &optional bind-row-closure)
Source

implementation.lisp.

Generic Function: transformation (frame bind-row &key in-place start restarts-enabled)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: transformation ((frame standard-table) bind-row &key in-place restarts-enabled start)
Source

implementation.lisp.

Generic Function: transformation-result (transformation)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: transformation-result ((object standard-transformation))
Source

implementation.lisp.

Generic Function: truncate-to-length (column length)
Package

vellum.column.

Source

protocol.lisp.

Methods
Method: truncate-to-length ((column sparse-material-column) length)
Source

implementation.lisp.

Generic Function: visualize (format data destination)
Package

vellum.

Source

generics.lisp.

Generic Function: vmask (frame mask &key in-place)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: vmask ((frame standard-table) mask &key in-place)
Source

implementation.lisp.

Generic Function: vstack* (frame more-frames)

Description:
Concatenates multiple frames column-wise.

Package

vellum.table.

Source

generics.lisp.

Methods
Method: vstack* ((frame standard-table) more-frames)
Source

implementation.lisp.


6.1.5 Standalone methods

Method: across ((container sparse-material-column) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: across ((table standard-table) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: across ((range frame-range-mixin) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: aggregator-constructor ((!range2 sequence) (!outer-constructor3 (eql nil)) (!function4 to-table-function) (!arguments6 list))
Package

cl-data-structures.algorithms.meta.

Source

to-table.lisp.

Method: aggregator-constructor ((!range2 traversable) (!outer-constructor3 (eql nil)) (!function4 to-table-function) (!arguments6 list))
Package

cl-data-structures.algorithms.meta.

Source

to-table.lisp.

Method: apply-range-function ((range fundamental-table) (function aggregation-function) all)
Package

cl-data-structures.algorithms.meta.

Source

implementation.lisp.

Method: apply-range-function ((range fundamental-table) (function layer-function) all)
Package

cl-data-structures.algorithms.meta.

Source

implementation.lisp.

Method: become-transactional ((container standard-table))
Package

cl-data-structures.

Source

implementation.lisp.

Method: clone ((range sparse-material-column-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: clone ((iterator sparse-material-column-iterator))
Package

cl-data-structures.

Source

implementation.lisp.

Method: clone ((range standard-table-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: cloning-information append ((column sparse-material-column))
Package

cl-data-structures.utils.

Source

types.lisp.

Method: cloning-information append ((range standard-table-range))
Package

cl-data-structures.utils.

Source

types.lisp.

Method: cloning-information append ((table standard-table))
Package

cl-data-structures.utils.

Source

types.lisp.

Method: cloning-information append ((header standard-header))
Package

cl-data-structures.utils.

Source

types.lisp.

Method: cloning-information append ((range frame-range-mixin))
Package

cl-data-structures.utils.

Source

types.lisp.

Method: consume-front ((range sparse-material-column-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: consume-front ((range standard-table-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: consume-front ((range frame-range-mixin))
Package

cl-data-structures.

Source

implementation.lisp.

Method: drop-front ((range sparse-material-column-range) count)
Package

cl-data-structures.

Source

implementation.lisp.

Method: drop-front ((range standard-table-range) count)
Package

cl-data-structures.

Source

implementation.lisp.

Method: peek-front ((range sparse-material-column-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: peek-front ((range standard-table-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: peek-front ((range frame-range-mixin))
Package

cl-data-structures.

Source

implementation.lisp.

Method: position-modification ((operation shrink-function) (structure sparse-material-column) container position &rest all)
Package

cl-data-structures.meta.

Source

implementation.lisp.

Method: position-modification ((operation grow-function) (structure sparse-material-column) container position &rest all &key value)
Package

cl-data-structures.meta.

Source

implementation.lisp.

Method: print-object ((object fundamental-table) stream)
Source

implementation.lisp.

Method: replica ((container standard-table) &optional isolate)
Package

cl-data-structures.

Source

implementation.lisp.

Method: reset! ((range sparse-material-column-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: reset! ((iterator sparse-material-column-iterator))
Package

cl-data-structures.

Source

implementation.lisp.

Method: reset! ((range standard-table-range))
Package

cl-data-structures.

Source

implementation.lisp.

Method: traverse ((container sparse-material-column) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: traverse ((range standard-table-range) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: traverse ((frame standard-table) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: traverse ((range frame-range-mixin) function)
Package

cl-data-structures.

Source

implementation.lisp.

Method: whole-range ((container sparse-material-column))
Package

cl-data-structures.

Source

implementation.lisp.

Method: whole-range ((container standard-table))
Package

cl-data-structures.

Source

implementation.lisp.


6.1.6 Conditions

Condition: column-type-error
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses

type-error.

Direct methods

column-type-error-column.

Direct slots
Slot: %column
Initargs

:column

Readers

column-type-error-column.

Writers

This slot is read-only.

Condition: file-input-row-cant-be-created
Package

vellum.

Source

conditions.lisp.

Direct superclasses
Condition: headers-incompatible
Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

operation-not-allowed.

Direct Default Initargs
InitargValue
:format-controlheaders are incompatible.
Direct slots
Slot: %headers
Initargs

:headers

Condition: invalid-input-for-row
Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

invalid-value.

Condition: invalid-name
Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

invalid-value.

Condition: name-duplicated

Description:
Names in the header are supposed to be unique. If an operation is performed that would violate that rule, this error is signalled.

Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

invalid-value.

Direct Default Initargs
InitargValue
:format-controldetected name ~a duplication.
Condition: name-when-selecting-row
Package

vellum.selection.

Source

implementation.lisp.

Direct superclasses

invalid-value.

Condition: no-column

Description:
Error signalled when trying to reference non existing column in the current header.

Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

argument-value-not-in-allowed-set.

Direct Default Initargs
InitargValue
:format-controlno column ~a.
Condition: no-header

Description:
Error signalled when trying to reference current header, but it is not binded.

Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

operation-not-allowed.

Direct Default Initargs
InitargValue
:format-controlno active header.
Condition: no-transformation
Package

vellum.table.

Source

conditions.lisp.

Direct superclasses

operation-not-allowed.

Direct Default Initargs
InitargValue
:format-controlnot performing transformation right now.
Condition: row-cant-be-created
Package

vellum.

Source

conditions.lisp.

Direct superclasses

chainable-condition.

Direct subclasses

file-input-row-cant-be-created.

Condition: transformation-error
Package

vellum.table.

Source

conditions.lisp.

Direct superclasses

textual-error.

Direct Default Initargs
InitargValue
:format-controlerror during transformation.
Condition: unable-to-construct-row
Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

textual-error.

Direct Default Initargs
InitargValue
:format-controlcan't create row from data.
Direct slots
Slot: %header
Initargs

:header


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.7 Structures

Structure: column-signature

Description:
Stores informations regarding the the specific column: type, name, predicate

Package

vellum.header.

Source

types.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: type
Package

common-lisp.

Initform

t

Readers

column-signature-type.

Writers

(setf column-signature-type).

Slot: name
Type

(or symbol string)

Readers

column-signature-name.

Writers

(setf column-signature-name).

Structure: setfable-table-row
Package

vellum.table.

Source

types.lisp.

Direct superclasses

table-row.

Structure: standard-header

Description:
Default class of header. Supplies the default implementaiton of the header protocol.

Package

vellum.header.

Source

types.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: column-signatures
Readers

standard-header-column-signatures.

Writers

(setf standard-header-column-signatures).

Slot: column-names
Type

hash-table

Initform

(make-hash-table :test (quote equal))

Readers

standard-header-column-names.

Writers

(setf standard-header-column-names).


Previous: , Up: Public Interface   [Contents][Index]

6.1.8 Classes

Class: between
Package

vellum.selection.

Source

implementation.lisp.

Direct superclasses

content.

Direct methods
Direct Default Initargs
InitargValue
:fromnil
:tonil
Direct slots
Slot: %from
Initargs

:from

Readers

read-from.

Writers

This slot is read-only.

Slot: %to
Initargs

:to

Readers

read-to.

Writers

This slot is read-only.

Class: bind-row
Package

vellum.table.

Source

types.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: %optimized-closure
Initargs

:optimized-closure

Readers

optimized-closure.

Writers

This slot is read-only.

Class: content
Package

vellum.selection.

Source

implementation.lisp.

Direct subclasses

between.

Class: frame-range-mixin

Description:
Mixin class that can be inherited by various subclasses of CL-DS:FUNDAMENTAL-FORWARD-RANGE to provide partial support for the data-frames. This includes consume-front, peek-front, traverse, and accross methods. See vellum-csv system to see the example of the use case for this class.

Package

vellum.header.

Source

types.lisp.

Direct methods
Direct slots
Slot: %header
Initargs

:header

Readers

read-header.

Writers

This slot is read-only.

Class: fundamental-column
Package

vellum.column.

Source

types.lisp.

Direct superclasses

traversable.

Direct subclasses

sparse-material-column.

Class: fundamental-table
Package

vellum.table.

Source

types.lisp.

Direct superclasses

traversable.

Direct subclasses

standard-table.

Direct methods
Class: selector
Package

vellum.selection.

Source

implementation.lisp.

Direct methods
Direct slots
Slot: %callback
Initargs

:callback

Readers

read-callback.

Writers

This slot is read-only.

Class: sparse-material-column
Package

vellum.column.

Source

types.lisp.

Direct superclasses
Direct methods
Class: standard-table
Package

vellum.table.

Source

types.lisp.

Direct superclasses

fundamental-table.

Direct methods
Direct slots
Slot: %header
Initargs

:header

Readers

header.

Writers

This slot is read-only.

Slot: %columns
Type

vector

Initargs

:columns

Readers

read-columns.

Writers

write-columns.

Class: standard-table-range
Package

vellum.table.

Source

types.lisp.

Direct superclasses

fundamental-forward-range.

Direct methods
Direct slots
Slot: %table-row
Initargs

:table-row

Readers

read-table-row.

Writers

This slot is read-only.

Slot: %header
Initargs

:header

Readers
Writers

This slot is read-only.

Slot: %row-count
Type

fixnum

Initargs

:row-count

Readers

read-row-count.

Writers

This slot is read-only.


6.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.1 Special variables

Special Variable: *transform-control*
Package

vellum.table.

Source

variables.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.2 Symbol macros

Symbol Macro: mask-bytes
Package

vellum.column.

Source

internal.lisp.


6.2.3 Macros

Macro: with-concatenation-state ((state) &body body)
Package

vellum.column.

Source

internal.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.4 Ordinary functions

Function: access-index (iterator)
Package

vellum.column.

Source

types.lisp.

Function: (setf access-index) (iterator)
Package

vellum.column.

Source

types.lisp.

Function: build-new-mask (old-bitmask missing-mask)
Package

vellum.column.

Source

internal.lisp.

Function: calculate-depth (index)
Package

vellum.column.

Source

internal.lisp.

Function: cartesian-product (vector)
Package

vellum.

Source

functions.lisp.

Function: change-leaf ()
Package

vellum.column.

Source

internal.lisp.

Function: change-leafs (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: child-index (parent-index child-position)
Package

vellum.column.

Source

internal.lisp.

Function: children (nodes)
Package

vellum.column.

Source

internal.lisp.

Function: clear-buffers (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: clear-changed-parents-masks (state)
Package

vellum.column.

Source

internal.lisp.

Function: clear-changes (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: clear-masks (state)
Package

vellum.column.

Source

internal.lisp.

Function: collect-column-specs (frame-specs)
Package

vellum.

Source

functions.lisp.

Function: column-root (column)
Package

vellum.column.

Source

internal.lisp.

Reader: column-signature-name (instance)
Writer: (setf column-signature-name) (instance)
Package

vellum.header.

Source

types.lisp.

Target Slot

name.

Function: column-signature-p (object)
Package

vellum.header.

Source

types.lisp.

Reader: column-signature-type (instance)
Writer: (setf column-signature-type) (instance)
Package

vellum.header.

Source

types.lisp.

Target Slot

type.

Function: column-transformation-closure (in-place)
Package

vellum.table.

Source

internal.lisp.

Function: common-to-table (range key class header body)
Package

vellum.integration.

Source

cl-ds.lisp.

Function: concatenate-masks (state)
Package

vellum.column.

Source

internal.lisp.

Function: concatenate-trees (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: concatenation-state (iterator columns nodes parents)
Package

vellum.column.

Source

internal.lisp.

Reader: concatenation-state-changed-parents (instance)
Writer: (setf concatenation-state-changed-parents) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

changed-parents.

Reader: concatenation-state-columns (instance)
Writer: (setf concatenation-state-columns) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

columns.

Reader: concatenation-state-iterator (instance)
Writer: (setf concatenation-state-iterator) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

iterator.

Reader: concatenation-state-masks (instance)
Writer: (setf concatenation-state-masks) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

masks.

Function: concatenation-state-masks-logcount (state)
Package

vellum.column.

Source

internal.lisp.

Reader: concatenation-state-max-index (instance)
Writer: (setf concatenation-state-max-index) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

max-index.

Reader: concatenation-state-nodes (instance)
Writer: (setf concatenation-state-nodes) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

nodes.

Function: concatenation-state-nodes-logcount (state)
Package

vellum.column.

Source

internal.lisp.

Function: concatenation-state-p (object)
Package

vellum.column.

Source

internal.lisp.

Reader: concatenation-state-parents (instance)
Writer: (setf concatenation-state-parents) (instance)
Package

vellum.column.

Source

internal.lisp.

Target Slot

parents.

Function: copy-column-signature (instance)
Package

vellum.header.

Source

types.lisp.

Function: copy-concatenation-state (instance)
Package

vellum.column.

Source

internal.lisp.

Function: copy-on-write-node (iterator parent child position tag column)
Package

vellum.column.

Source

internal.lisp.

Function: copy-setfable-table-row (instance)
Package

vellum.table.

Source

types.lisp.

Function: copy-sparse-material-column-iterator (instance)
Package

vellum.column.

Source

types.lisp.

Function: copy-standard-header (instance)
Package

vellum.header.

Source

types.lisp.

Function: copy-standard-transformation (instance)
Package

vellum.table.

Source

types.lisp.

Function: copy-table-row (instance)
Package

vellum.table.

Source

types.lisp.

Function: distinct-missing (real-mask logior-mask)
Package

vellum.column.

Source

internal.lisp.

Function: ensure-replicas (columns new-columns &optional isolate)
Package

vellum.table.

Source

internal.lisp.

Function: extracting-signature (header)
Package

vellum.header.

Source

internal.lisp.

Function: fill-buffer (depth buffer stack)
Package

vellum.column.

Source

internal.lisp.

Function: fill-buffers (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: find-max-index (nodes)
Package

vellum.column.

Source

internal.lisp.

Function: free-space (state index)
Package

vellum.column.

Source

internal.lisp.

Function: gather-masks (nodes &optional result)
Package

vellum.column.

Source

internal.lisp.

Function: hash-join-implementation (frame-specs header class test function)
Package

vellum.

Source

functions.lisp.

Function: index-promoted ()
Package

vellum.column.

Source

internal.lisp.

Function: initialize-iterator-column (iterator index column stack buffer shift touched column-index)
Package

vellum.column.

Source

internal.lisp.

Function: initialize-iterator-columns (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: insert-tail (column)
Package

vellum.table.

Source

internal.lisp.

Function: into-vector-copy (element vector)
Package

vellum.column.

Source

implementation.lisp.

Function: logior-mask (state index mask)
Package

vellum.column.

Source

internal.lisp.

Function: make-bind-row (optimized-closure non-optimized-closure)

Description:
Conrstucts the BIND-ROW instance. This function is typically not called explicitly but instead part of the BIND-ROW macros macroexpansion.

Package

vellum.table.

Source

functions.lisp.

Function: make-column-signature (&key type name)
Package

vellum.header.

Source

types.lisp.

Function: make-concatenation-state (&key iterator changed-parents masks max-index nodes parents columns)
Package

vellum.column.

Source

internal.lisp.

Function: make-iterator (columns &key transformation)
Package

vellum.table.

Source

internal.lisp.

Function: make-leaf (iterator column old-node change buffer &optional new-size)
Package

vellum.column.

Source

internal.lisp.

Function: make-node (iterator column bitmask &key type length content tag)
Package

vellum.column.

Source

internal.lisp.

Function: make-signature (c)
Package

vellum.header.

Source

internal.lisp.

Function: make-sparse-material-column-iterator (&key initialization-status column-types transformation columns stacks depths index indexes initial-index touched buffers changes)
Package

vellum.column.

Source

types.lisp.

Function: make-sparse-material-column-range (column)
Package

vellum.column.

Source

implementation.lisp.

Function: make-standard-header (&key column-signatures column-names)
Package

vellum.header.

Source

types.lisp.

Function: make-standard-transformation (&key dropped marker-column table restarts-enabled in-place start row iterator columns column-count count bind-row-closure)
Package

vellum.table.

Source

types.lisp.

Function: mask (state index)
Package

vellum.column.

Source

internal.lisp.

Function: (setf mask) (state index)
Package

vellum.column.

Source

internal.lisp.

Function: max-index (nodes)
Package

vellum.column.

Source

internal.lisp.

Function: move-children (state from to)
Package

vellum.column.

Source

internal.lisp.

Function: move-children-in-column (state from to from-mask to-mask column-index)
Package

vellum.column.

Source

internal.lisp.

Function: move-children-in-columns (state from to from-mask to-mask)
Package

vellum.column.

Source

internal.lisp.

Function: move-column-to ()
Package

vellum.column.

Source

internal.lisp.

Function: move-stack (depth new-index stack)
Package

vellum.column.

Source

internal.lisp.

Function: move-to-existing-column (state from to from-mask to-mask column-index)
Package

vellum.column.

Source

internal.lisp.

Function: move/pad-stack (iterator index new-index depth new-depth stack column)
Package

vellum.column.

Source

internal.lisp.

Function: mutate-leaf (column old-node change buffer &optional new-size)
Package

vellum.column.

Source

internal.lisp.

Function: node (state column index)
Package

vellum.column.

Source

internal.lisp.

Function: (setf node) (state column index)
Package

vellum.column.

Source

internal.lisp.

Function: occupied-space (state index)
Package

vellum.column.

Source

internal.lisp.

Function: offset (index)
Package

vellum.column.

Source

internal.lisp.

Function: pad-stack (iterator depth index new-depth stack column)
Package

vellum.column.

Source

internal.lisp.

Function: parent-changed (state column parent-index)
Package

vellum.column.

Source

internal.lisp.

Function: (setf parent-changed) (state column parent-index)
Package

vellum.column.

Source

internal.lisp.

Function: parent-index (child-index)
Package

vellum.column.

Source

internal.lisp.

Function: range-iterator (range position)
Package

vellum.column.

Source

internal.lisp.

Function: read-buffers (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-changes (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-column-names (header)
Package

vellum.header.

Source

types.lisp.

Function: read-column-signatures (header)
Package

vellum.header.

Source

types.lisp.

Function: read-column-types (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-columns (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-depths (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-indexes (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-initial-index (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-initialization-status (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-stacks (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-touched (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-transformation (iterator)
Package

vellum.column.

Source

types.lisp.

Function: read-type (column-signature)
Package

vellum.header.

Source

types.lisp.

Function: reduce-stack (iterator index depth stack column)
Package

vellum.column.

Source

internal.lisp.

Function: reduce-stacks (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: remove-nulls-from-columns (columns &optional transform)
Package

vellum.table.

Source

internal.lisp.

Function: select-columns (frame selection)
Package

vellum.table.

Source

internal.lisp.

Function: select-rows (frame selection)
Package

vellum.table.

Source

internal.lisp.

Function: setfable-table-row-iterator (instance)
Package

vellum.table.

Source

types.lisp.

Function: (setf setfable-table-row-iterator) (instance)
Package

vellum.table.

Source

types.lisp.

Function: setfable-table-row-p (object)
Package

vellum.table.

Source

types.lisp.

Function: shift-content (state)
Package

vellum.column.

Source

internal.lisp.

Function: sparse-material-column-at (column index)
Package

vellum.column.

Source

internal.lisp.

Function: (setf sparse-material-column-at) (column index)
Package

vellum.column.

Source

internal.lisp.

Reader: sparse-material-column-iterator-buffers (instance)
Writer: (setf sparse-material-column-iterator-buffers) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

buffers.

Reader: sparse-material-column-iterator-changes (instance)
Writer: (setf sparse-material-column-iterator-changes) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

changes.

Reader: sparse-material-column-iterator-column-types (instance)
Writer: (setf sparse-material-column-iterator-column-types) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

column-types.

Reader: sparse-material-column-iterator-columns (instance)
Writer: (setf sparse-material-column-iterator-columns) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

columns.

Reader: sparse-material-column-iterator-depths (instance)
Writer: (setf sparse-material-column-iterator-depths) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

depths.

Reader: sparse-material-column-iterator-indexes (instance)
Writer: (setf sparse-material-column-iterator-indexes) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

indexes.

Reader: sparse-material-column-iterator-initial-index (instance)
Writer: (setf sparse-material-column-iterator-initial-index) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

initial-index.

Reader: sparse-material-column-iterator-initialization-status (instance)
Writer: (setf sparse-material-column-iterator-initialization-status) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

initialization-status.

Function: sparse-material-column-iterator-p (object)
Package

vellum.column.

Source

types.lisp.

Reader: sparse-material-column-iterator-stacks (instance)
Writer: (setf sparse-material-column-iterator-stacks) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

stacks.

Reader: sparse-material-column-iterator-touched (instance)
Writer: (setf sparse-material-column-iterator-touched) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

touched.

Reader: sparse-material-column-iterator-transformation (instance)
Writer: (setf sparse-material-column-iterator-transformation) (instance)
Package

vellum.column.

Source

types.lisp.

Target Slot

transformation.

Reader: standard-header-column-names (instance)
Writer: (setf standard-header-column-names) (instance)
Package

vellum.header.

Source

types.lisp.

Target Slot

column-names.

Reader: standard-header-column-signatures (instance)
Writer: (setf standard-header-column-signatures) (instance)
Package

vellum.header.

Source

types.lisp.

Target Slot

column-signatures.

Function: standard-header-p (object)
Package

vellum.header.

Source

types.lisp.

Reader: standard-transformation-bind-row-closure (instance)
Writer: (setf standard-transformation-bind-row-closure) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

bind-row-closure.

Reader: standard-transformation-column-count (instance)
Writer: (setf standard-transformation-column-count) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

column-count.

Reader: standard-transformation-columns (instance)
Writer: (setf standard-transformation-columns) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

columns.

Reader: standard-transformation-count (instance)
Writer: (setf standard-transformation-count) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

count.

Reader: standard-transformation-dropped (instance)
Writer: (setf standard-transformation-dropped) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

dropped.

Reader: standard-transformation-in-place (instance)
Writer: (setf standard-transformation-in-place) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

in-place.

Reader: standard-transformation-iterator (instance)
Writer: (setf standard-transformation-iterator) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

iterator.

Reader: standard-transformation-marker-column (instance)
Writer: (setf standard-transformation-marker-column) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

marker-column.

Function: standard-transformation-p (object)
Package

vellum.table.

Source

types.lisp.

Reader: standard-transformation-restarts-enabled (instance)
Writer: (setf standard-transformation-restarts-enabled) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

restarts-enabled.

Reader: standard-transformation-start (instance)
Writer: (setf standard-transformation-start) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

start.

Reader: standard-transformation-table (instance)
Writer: (setf standard-transformation-table) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

table.

Function: table-from-header (class header)
Package

vellum.table.

Source

internal.lisp.

Reader: table-row-iterator (instance)
Writer: (setf table-row-iterator) (instance)
Package

vellum.table.

Source

types.lisp.

Target Slot

iterator.

Function: table-row-p (object)
Package

vellum.table.

Source

types.lisp.

Function: transform-row-impl (transformation &optional function)
Package

vellum.table.

Source

internal.lisp.

Function: tree-index (index)
Package

vellum.column.

Source

internal.lisp.

Function: trim-depth (iterator)
Package

vellum.column.

Source

internal.lisp.

Function: trim-depth-in-column (column)
Package

vellum.column.

Source

internal.lisp.

Function: truncate-mask (mask)
Package

vellum.column.

Source

internal.lisp.

Function: unique-names (headers)
Package

vellum.header.

Source

internal.lisp.

Function: update-parents (state column)
Package

vellum.column.

Source

internal.lisp.

Function: validate-active-header ()

Description:
Signals NO-HEADER error when the *HEADER* is NIL.

Package

vellum.header.

Source

functions.lisp.

Function: validate-active-row ()
Package

vellum.header.

Source

functions.lisp.

Function: validate-row (row data)
Package

vellum.header.

Source

implementation.lisp.

Function: vs (&rest forms)
Package

vellum.table.

Source

functions.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.5 Generic functions

Generic Reader: access-iterator (object)
Package

vellum.column.

Methods
Reader Method: access-iterator ((sparse-material-column-range sparse-material-column-range))

automatically generated reader method

Source

internal.lisp.

Target Slot

%iterator.

Generic Writer: (setf access-iterator) (object)
Package

vellum.column.

Methods
Writer Method: (setf access-iterator) ((sparse-material-column-range sparse-material-column-range))

automatically generated writer method

Source

internal.lisp.

Target Slot

%iterator.

Generic Reader: access-position (object)
Package

vellum.column.

Methods
Reader Method: access-position ((sparse-material-column-range sparse-material-column-range))

automatically generated reader method

Source

internal.lisp.

Target Slot

%position.

Generic Writer: (setf access-position) (object)
Package

vellum.column.

Methods
Writer Method: (setf access-position) ((sparse-material-column-range sparse-material-column-range))

automatically generated writer method

Source

internal.lisp.

Target Slot

%position.

Generic Function: column-signature-spec (column-signature)
Package

vellum.header.

Source

protocol.lisp.

Methods
Method: column-signature-spec ((signature column-signature))
Source

implementation.lisp.

Generic Reader: column-type-error-column (condition)
Package

vellum.column.

Methods
Reader Method: column-type-error-column ((condition setting-to-null))
Source

conditions.lisp.

Target Slot

%column.

Reader Method: column-type-error-column ((condition column-type-error))
Source

conditions.lisp.

Target Slot

%column.

Generic Function: fill-columns-buffer-impl (range position buffer finish-callback key)
Package

vellum.integration.

Source

cl-ds.lisp.

Methods
Method: fill-columns-buffer-impl (range position buffer finish-callback key)
Method: fill-columns-buffer-impl ((range summary-result-range) position buffer finish-callback key)
Method: fill-columns-buffer-impl ((range group-by-result-range) position buffer finish-callback key)
Generic Function: gather-column-data (range definitions result)
Package

vellum.integration.

Source

cl-ds.lisp.

Methods
Method: gather-column-data (range definitions result)
Method: gather-column-data ((range summary-result-range) definitions result)
Method: gather-column-data ((range group-by-result-range) definitions result)
Generic Function: in-existing-content (iterator)
Package

vellum.column.

Methods
Method: in-existing-content ((iterator sparse-material-column-iterator))
Source

implementation.lisp.

Generic Reader: optimized-closure (object)
Package

vellum.table.

Methods
Reader Method: optimized-closure ((bind-row bind-row))

automatically generated reader method

Source

types.lisp.

Target Slot

%optimized-closure.

Generic Reader: read-callback (object)
Package

vellum.selection.

Methods
Reader Method: read-callback ((selector selector))

automatically generated reader method

Source

implementation.lisp.

Target Slot

%callback.

Generic Reader: read-column (object)
Package

vellum.column.

Methods
Reader Method: read-column ((sparse-material-column-range sparse-material-column-range))

automatically generated reader method

Source

internal.lisp.

Target Slot

%column.

Generic Reader: read-columns (object)
Package

vellum.table.

Methods
Reader Method: read-columns ((standard-table standard-table))

automatically generated reader method

Source

types.lisp.

Target Slot

%columns.

Generic Reader: read-from (object)
Package

vellum.selection.

Methods
Reader Method: read-from ((between between))

automatically generated reader method

Source

implementation.lisp.

Target Slot

%from.

Generic Reader: read-header (object)
Package

vellum.table.

Methods
Reader Method: read-header ((standard-table-range standard-table-range))

automatically generated reader method

Source

types.lisp.

Target Slot

%header.

Generic Reader: read-initial-position (object)
Package

vellum.column.

Methods
Reader Method: read-initial-position ((sparse-material-column-range sparse-material-column-range))

automatically generated reader method

Source

internal.lisp.

Target Slot

%initial-position.

Generic Function: read-iterator (object)
Package

vellum.table.

Source

generics.lisp.

Methods
Method: read-iterator ((range standard-table-range))
Source

implementation.lisp.

Generic Reader: read-row-count (object)
Package

vellum.table.

Methods
Reader Method: read-row-count ((standard-table-range standard-table-range))

automatically generated reader method

Source

types.lisp.

Target Slot

%row-count.

Generic Reader: read-table-row (object)
Package

vellum.table.

Methods
Reader Method: read-table-row ((standard-table-range standard-table-range))

automatically generated reader method

Source

types.lisp.

Target Slot

%table-row.

Generic Reader: read-to (object)
Package

vellum.selection.

Methods
Reader Method: read-to ((between between))

automatically generated reader method

Source

implementation.lisp.

Target Slot

%to.

Generic Function: row-erase (row)
Package

vellum.table.

Source

generics.lisp.

Generic Writer: write-columns (new-value object)
Package

vellum.table.

Methods
Writer Method: write-columns ((new-value standard-table) standard-table)

automatically generated writer method

Source

types.lisp.

Target Slot

%columns.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.6 Conditions

Condition: column-error
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses

program-error.

Direct subclasses
Condition: index-out-of-column-bounds
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses
Condition: iterator-error
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses

program-error.

Condition: no-row

Description:
Error signalled when trying to reference current row, but it is not binded.

Package

vellum.header.

Source

conditions.lisp.

Direct superclasses

operation-not-allowed.

Direct Default Initargs
InitargValue
:format-controlno active row.
Condition: no-such-column
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses
Condition: setting-to-null
Package

vellum.column.

Source

conditions.lisp.

Direct superclasses
Direct methods

column-type-error-column.

Direct slots
Slot: %column
Initargs

:column

Readers

column-type-error-column.

Writers

This slot is read-only.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.7 Structures

Structure: concatenation-state
Package

vellum.column.

Source

internal.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: iterator
Readers

concatenation-state-iterator.

Writers

(setf concatenation-state-iterator).

Slot: changed-parents
Type

vector

Initform

#()

Readers

concatenation-state-changed-parents.

Writers

(setf concatenation-state-changed-parents).

Slot: masks
Type

hash-table

Initform

(make-hash-table)

Readers

concatenation-state-masks.

Writers

(setf concatenation-state-masks).

Slot: max-index
Type

alexandria:non-negative-fixnum

Initform

0

Readers

concatenation-state-max-index.

Writers

(setf concatenation-state-max-index).

Slot: nodes
Type

vector

Initform

#()

Readers

concatenation-state-nodes.

Writers

(setf concatenation-state-nodes).

Slot: parents
Type

(or null vellum.column::concatenation-state)

Readers

concatenation-state-parents.

Writers

(setf concatenation-state-parents).

Slot: columns
Type

simple-vector

Initform

#()

Readers

concatenation-state-columns.

Writers

(setf concatenation-state-columns).

Structure: sparse-material-column-iterator
Package

vellum.column.

Source

types.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: initialization-status
Type

simple-vector

Initform

(make-array 0)

Readers

sparse-material-column-iterator-initialization-status.

Writers

(setf sparse-material-column-iterator-initialization-status).

Slot: column-types
Type

simple-vector

Initform

(make-array 0)

Readers

sparse-material-column-iterator-column-types.

Writers

(setf sparse-material-column-iterator-column-types).

Slot: transformation
Readers

sparse-material-column-iterator-transformation.

Writers

(setf sparse-material-column-iterator-transformation).

Slot: columns
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-columns.

Writers

(setf sparse-material-column-iterator-columns).

Slot: stacks
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-stacks.

Writers

(setf sparse-material-column-iterator-stacks).

Slot: depths
Type

(simple-array fixnum (*))

Initform

(make-array 0 :element-type (quote fixnum))

Readers

sparse-material-column-iterator-depths.

Writers

(setf sparse-material-column-iterator-depths).

Slot: index
Type

fixnum

Initform

0

Readers

sparse-material-column-iterator-index.

Writers

(setf sparse-material-column-iterator-index).

Slot: indexes
Type

(simple-array fixnum (*))

Initform

(make-array 0 :element-type (quote fixnum))

Readers

sparse-material-column-iterator-indexes.

Writers

(setf sparse-material-column-iterator-indexes).

Slot: initial-index
Type

fixnum

Initform

0

Readers

sparse-material-column-iterator-initial-index.

Writers

(setf sparse-material-column-iterator-initial-index).

Slot: touched
Type

simple-vector

Initform

(make-array 0)

Readers

sparse-material-column-iterator-touched.

Writers

(setf sparse-material-column-iterator-touched).

Slot: buffers
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-buffers.

Writers

(setf sparse-material-column-iterator-buffers).

Slot: changes
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-changes.

Writers

(setf sparse-material-column-iterator-changes).

Structure: standard-transformation
Package

vellum.table.

Source

types.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: dropped
Type

boolean

Readers

standard-transformation-dropped.

Writers

(setf standard-transformation-dropped).

Slot: marker-column
Readers

standard-transformation-marker-column.

Writers

(setf standard-transformation-marker-column).

Slot: table
Readers

standard-transformation-table.

Writers

(setf standard-transformation-table).

Slot: restarts-enabled
Type

boolean

Initform

t

Readers

standard-transformation-restarts-enabled.

Writers

(setf standard-transformation-restarts-enabled).

Slot: in-place
Type

boolean

Readers

standard-transformation-in-place.

Writers

(setf standard-transformation-in-place).

Slot: start
Type

integer

Initform

0

Readers

standard-transformation-start.

Writers

(setf standard-transformation-start).

Slot: row
Readers

standard-transformation-row.

Writers

(setf standard-transformation-row).

Slot: iterator
Readers

standard-transformation-iterator.

Writers

(setf standard-transformation-iterator).

Slot: columns
Type

simple-vector

Initform

#()

Readers

standard-transformation-columns.

Writers

(setf standard-transformation-columns).

Slot: column-count
Type

fixnum

Initform

0

Readers

standard-transformation-column-count.

Writers

(setf standard-transformation-column-count).

Slot: count
Package

common-lisp.

Type

fixnum

Initform

0

Readers

standard-transformation-count.

Writers

(setf standard-transformation-count).

Slot: bind-row-closure
Readers

standard-transformation-bind-row-closure.

Writers

(setf standard-transformation-bind-row-closure).

Structure: table-row
Package

vellum.table.

Source

types.lisp.

Direct superclasses

structure-object.

Direct subclasses

setfable-table-row.

Direct slots
Slot: iterator
Readers

table-row-iterator.

Writers

(setf table-row-iterator).


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.8 Classes

Class: sparse-material-column-range
Package

vellum.column.

Source

internal.lisp.

Direct superclasses

fundamental-forward-range.

Direct methods
Direct slots
Slot: %iterator
Initargs

:iterator

Readers

access-iterator.

Writers

(setf access-iterator).

Slot: %column
Initargs

:column

Readers

read-column.

Writers

This slot is read-only.

Slot: %position
Initargs

:position

Readers

access-position.

Writers

(setf access-position).

Slot: %initial-position
Initargs

:position

Readers

read-initial-position.

Writers

This slot is read-only.

Class: to-table-function
Package

vellum.table.

Source

to-table.lisp.

Direct superclasses

aggregation-function.

Direct methods

Previous: , Up: Internals   [Contents][Index]

6.2.9 Types

Type: iterator-buffer ()
Package

vellum.column.

Source

types.lisp.

Type: iterator-change ()
Package

vellum.column.

Source

types.lisp.

Type: iterator-stack ()
Package

vellum.column.

Source

types.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

%
%aggregate-columns: Public ordinary functions
%aggregate-rows: Public ordinary functions

(
(setf access-index): Private ordinary functions
(setf access-iterator): Private generic functions
(setf access-iterator): Private generic functions
(setf access-position): Private generic functions
(setf access-position): Private generic functions
(setf at): Public generic functions
(setf at): Public generic functions
(setf column-at): Public generic functions
(setf column-at): Public generic functions
(setf column-signature-name): Private ordinary functions
(setf column-signature-type): Private ordinary functions
(setf concatenation-state-changed-parents): Private ordinary functions
(setf concatenation-state-columns): Private ordinary functions
(setf concatenation-state-iterator): Private ordinary functions
(setf concatenation-state-masks): Private ordinary functions
(setf concatenation-state-max-index): Private ordinary functions
(setf concatenation-state-nodes): Private ordinary functions
(setf concatenation-state-parents): Private ordinary functions
(setf iterator-at): Public ordinary functions
(setf mask): Private ordinary functions
(setf node): Private ordinary functions
(setf parent-changed): Private ordinary functions
(setf row-at): Public ordinary functions
(setf rr): Public ordinary functions
(setf setfable-table-row-iterator): Private ordinary functions
(setf sparse-material-column-at): Private ordinary functions
(setf sparse-material-column-iterator-buffers): Private ordinary functions
(setf sparse-material-column-iterator-changes): Private ordinary functions
(setf sparse-material-column-iterator-column-types): Private ordinary functions
(setf sparse-material-column-iterator-columns): Private ordinary functions
(setf sparse-material-column-iterator-depths): Private ordinary functions
(setf sparse-material-column-iterator-index): Public ordinary functions
(setf sparse-material-column-iterator-indexes): Private ordinary functions
(setf sparse-material-column-iterator-initial-index): Private ordinary functions
(setf sparse-material-column-iterator-initialization-status): Private ordinary functions
(setf sparse-material-column-iterator-stacks): Private ordinary functions
(setf sparse-material-column-iterator-touched): Private ordinary functions
(setf sparse-material-column-iterator-transformation): Private ordinary functions
(setf standard-header-column-names): Private ordinary functions
(setf standard-header-column-signatures): Private ordinary functions
(setf standard-transformation-bind-row-closure): Private ordinary functions
(setf standard-transformation-column-count): Private ordinary functions
(setf standard-transformation-columns): Private ordinary functions
(setf standard-transformation-count): Private ordinary functions
(setf standard-transformation-dropped): Private ordinary functions
(setf standard-transformation-in-place): Private ordinary functions
(setf standard-transformation-iterator): Private ordinary functions
(setf standard-transformation-marker-column): Private ordinary functions
(setf standard-transformation-restarts-enabled): Private ordinary functions
(setf standard-transformation-row): Public ordinary functions
(setf standard-transformation-start): Private ordinary functions
(setf standard-transformation-table): Private ordinary functions
(setf table-row-iterator): Private ordinary functions

A
access-index: Private ordinary functions
access-iterator: Private generic functions
access-iterator: Private generic functions
access-position: Private generic functions
access-position: Private generic functions
across: Public standalone methods
across: Public standalone methods
across: Public standalone methods
add-columns: Public ordinary functions
address-range: Public generic functions
address-range: Public generic functions
address-range: Public generic functions
aggregate-columns: Public macros
aggregate-rows: Public macros
aggregator-constructor: Public standalone methods
aggregator-constructor: Public standalone methods
alter-columns: Public generic functions
alter-columns: Public generic functions
alter-columns: Public generic functions
alter-columns: Public generic functions
apply-range-function: Public standalone methods
apply-range-function: Public standalone methods
at: Public generic functions
at: Public generic functions
augment-iterator: Public generic functions
augment-iterator: Public generic functions

B
become-transactional: Public standalone methods
between: Public ordinary functions
bind-row: Public macros
bind-row-closure: Public generic functions
bind-row-closure: Public generic functions
bind-row-closure: Public generic functions
bind-row-closure: Public generic functions
brr: Public macros
build-new-mask: Private ordinary functions

C
calculate-depth: Private ordinary functions
cartesian-product: Private ordinary functions
change-leaf: Private ordinary functions
change-leafs: Private ordinary functions
check-column-signatures-compatibility: Public generic functions
check-column-signatures-compatibility: Public generic functions
child-index: Private ordinary functions
children: Private ordinary functions
clear-buffers: Private ordinary functions
clear-changed-parents-masks: Private ordinary functions
clear-changes: Private ordinary functions
clear-masks: Private ordinary functions
clone: Public standalone methods
clone: Public standalone methods
clone: Public standalone methods
cloning-information: Public standalone methods
cloning-information: Public standalone methods
cloning-information: Public standalone methods
cloning-information: Public standalone methods
cloning-information: Public standalone methods
collect-column-specs: Private ordinary functions
column-at: Public generic functions
column-at: Public generic functions
column-at: Public generic functions
column-at: Public generic functions
column-at: Public generic functions
column-count: Public generic functions
column-count: Public generic functions
column-count: Public generic functions
column-count: Public generic functions
column-name: Public generic functions
column-name: Public generic functions
column-names: Public ordinary functions
column-names: Public ordinary functions
column-root: Private ordinary functions
column-signature: Public ordinary functions
column-signature-name: Private ordinary functions
column-signature-p: Private ordinary functions
column-signature-spec: Private generic functions
column-signature-spec: Private generic functions
column-signature-type: Private ordinary functions
column-size: Public generic functions
column-size: Public generic functions
column-specs: Public generic functions
column-specs: Public generic functions
column-transformation-closure: Private ordinary functions
column-type: Public ordinary functions
column-type: Public generic functions
column-type: Public generic functions
column-type: Public generic functions
column-type: Public generic functions
column-type-error-column: Private generic functions
column-type-error-column: Private generic functions
column-type-error-column: Private generic functions
columns: Public ordinary functions
common-to-table: Private ordinary functions
concatenate-headers: Public generic functions
concatenate-headers: Public generic functions
concatenate-masks: Private ordinary functions
concatenate-trees: Private ordinary functions
concatenation-state: Private ordinary functions
concatenation-state-changed-parents: Private ordinary functions
concatenation-state-columns: Private ordinary functions
concatenation-state-iterator: Private ordinary functions
concatenation-state-masks: Private ordinary functions
concatenation-state-masks-logcount: Private ordinary functions
concatenation-state-max-index: Private ordinary functions
concatenation-state-nodes: Private ordinary functions
concatenation-state-nodes-logcount: Private ordinary functions
concatenation-state-p: Private ordinary functions
concatenation-state-parents: Private ordinary functions
consume-front: Public standalone methods
consume-front: Public standalone methods
consume-front: Public standalone methods
content: Public generic functions
content: Public generic functions
copy-column-signature: Private ordinary functions
copy-concatenation-state: Private ordinary functions
copy-from: Public generic functions
copy-from: Public generic functions
copy-on-write-node: Private ordinary functions
copy-setfable-table-row: Private ordinary functions
copy-sparse-material-column-iterator: Private ordinary functions
copy-standard-header: Private ordinary functions
copy-standard-transformation: Private ordinary functions
copy-table-row: Private ordinary functions
copy-to: Public generic functions
current-row-as-vector: Public ordinary functions

D
distinct-missing: Private ordinary functions
drop-front: Public standalone methods
drop-front: Public standalone methods
drop-row: Public ordinary functions
drop-row-when: Public macros

E
empty-column: Public ordinary functions
ensure-index: Public ordinary functions
ensure-replicas: Private ordinary functions
erase!: Public generic functions
erase!: Public generic functions
extracting-signature: Private ordinary functions

F
fill-buffer: Private ordinary functions
fill-buffers: Private ordinary functions
fill-columns-buffer-impl: Private generic functions
fill-columns-buffer-impl: Private generic functions
fill-columns-buffer-impl: Private generic functions
fill-columns-buffer-impl: Private generic functions
find-max-index: Private ordinary functions
finish-iterator: Public generic functions
finish-iterator: Public generic functions
finish-transformation: Public ordinary functions
free-space: Private ordinary functions
Function, %aggregate-columns: Public ordinary functions
Function, %aggregate-rows: Public ordinary functions
Function, (setf access-index): Private ordinary functions
Function, (setf column-signature-name): Private ordinary functions
Function, (setf column-signature-type): Private ordinary functions
Function, (setf concatenation-state-changed-parents): Private ordinary functions
Function, (setf concatenation-state-columns): Private ordinary functions
Function, (setf concatenation-state-iterator): Private ordinary functions
Function, (setf concatenation-state-masks): Private ordinary functions
Function, (setf concatenation-state-max-index): Private ordinary functions
Function, (setf concatenation-state-nodes): Private ordinary functions
Function, (setf concatenation-state-parents): Private ordinary functions
Function, (setf iterator-at): Public ordinary functions
Function, (setf mask): Private ordinary functions
Function, (setf node): Private ordinary functions
Function, (setf parent-changed): Private ordinary functions
Function, (setf row-at): Public ordinary functions
Function, (setf rr): Public ordinary functions
Function, (setf setfable-table-row-iterator): Private ordinary functions
Function, (setf sparse-material-column-at): Private ordinary functions
Function, (setf sparse-material-column-iterator-buffers): Private ordinary functions
Function, (setf sparse-material-column-iterator-changes): Private ordinary functions
Function, (setf sparse-material-column-iterator-column-types): Private ordinary functions
Function, (setf sparse-material-column-iterator-columns): Private ordinary functions
Function, (setf sparse-material-column-iterator-depths): Private ordinary functions
Function, (setf sparse-material-column-iterator-index): Public ordinary functions
Function, (setf sparse-material-column-iterator-indexes): Private ordinary functions
Function, (setf sparse-material-column-iterator-initial-index): Private ordinary functions
Function, (setf sparse-material-column-iterator-initialization-status): Private ordinary functions
Function, (setf sparse-material-column-iterator-stacks): Private ordinary functions
Function, (setf sparse-material-column-iterator-touched): Private ordinary functions
Function, (setf sparse-material-column-iterator-transformation): Private ordinary functions
Function, (setf standard-header-column-names): Private ordinary functions
Function, (setf standard-header-column-signatures): Private ordinary functions
Function, (setf standard-transformation-bind-row-closure): Private ordinary functions
Function, (setf standard-transformation-column-count): Private ordinary functions
Function, (setf standard-transformation-columns): Private ordinary functions
Function, (setf standard-transformation-count): Private ordinary functions
Function, (setf standard-transformation-dropped): Private ordinary functions
Function, (setf standard-transformation-in-place): Private ordinary functions
Function, (setf standard-transformation-iterator): Private ordinary functions
Function, (setf standard-transformation-marker-column): Private ordinary functions
Function, (setf standard-transformation-restarts-enabled): Private ordinary functions
Function, (setf standard-transformation-row): Public ordinary functions
Function, (setf standard-transformation-start): Private ordinary functions
Function, (setf standard-transformation-table): Private ordinary functions
Function, (setf table-row-iterator): Private ordinary functions
Function, access-index: Private ordinary functions
Function, add-columns: Public ordinary functions
Function, between: Public ordinary functions
Function, build-new-mask: Private ordinary functions
Function, calculate-depth: Private ordinary functions
Function, cartesian-product: Private ordinary functions
Function, change-leaf: Private ordinary functions
Function, change-leafs: Private ordinary functions
Function, child-index: Private ordinary functions
Function, children: Private ordinary functions
Function, clear-buffers: Private ordinary functions
Function, clear-changed-parents-masks: Private ordinary functions
Function, clear-changes: Private ordinary functions
Function, clear-masks: Private ordinary functions
Function, collect-column-specs: Private ordinary functions
Function, column-names: Public ordinary functions
Function, column-names: Public ordinary functions
Function, column-root: Private ordinary functions
Function, column-signature: Public ordinary functions
Function, column-signature-name: Private ordinary functions
Function, column-signature-p: Private ordinary functions
Function, column-signature-type: Private ordinary functions
Function, column-transformation-closure: Private ordinary functions
Function, column-type: Public ordinary functions
Function, columns: Public ordinary functions
Function, common-to-table: Private ordinary functions
Function, concatenate-masks: Private ordinary functions
Function, concatenate-trees: Private ordinary functions
Function, concatenation-state: Private ordinary functions
Function, concatenation-state-changed-parents: Private ordinary functions
Function, concatenation-state-columns: Private ordinary functions
Function, concatenation-state-iterator: Private ordinary functions
Function, concatenation-state-masks: Private ordinary functions
Function, concatenation-state-masks-logcount: Private ordinary functions
Function, concatenation-state-max-index: Private ordinary functions
Function, concatenation-state-nodes: Private ordinary functions
Function, concatenation-state-nodes-logcount: Private ordinary functions
Function, concatenation-state-p: Private ordinary functions
Function, concatenation-state-parents: Private ordinary functions
Function, copy-column-signature: Private ordinary functions
Function, copy-concatenation-state: Private ordinary functions
Function, copy-on-write-node: Private ordinary functions
Function, copy-setfable-table-row: Private ordinary functions
Function, copy-sparse-material-column-iterator: Private ordinary functions
Function, copy-standard-header: Private ordinary functions
Function, copy-standard-transformation: Private ordinary functions
Function, copy-table-row: Private ordinary functions
Function, current-row-as-vector: Public ordinary functions
Function, distinct-missing: Private ordinary functions
Function, drop-row: Public ordinary functions
Function, empty-column: Public ordinary functions
Function, ensure-index: Public ordinary functions
Function, ensure-replicas: Private ordinary functions
Function, extracting-signature: Private ordinary functions
Function, fill-buffer: Private ordinary functions
Function, fill-buffers: Private ordinary functions
Function, find-max-index: Private ordinary functions
Function, finish-transformation: Public ordinary functions
Function, free-space: Private ordinary functions
Function, gather-masks: Private ordinary functions
Function, hash-join-implementation: Private ordinary functions
Function, header: Public ordinary functions
Function, hstack: Public ordinary functions
Function, index: Public ordinary functions
Function, index-promoted: Private ordinary functions
Function, index-to-name: Public ordinary functions
Function, initialize-iterator-column: Private ordinary functions
Function, initialize-iterator-columns: Private ordinary functions
Function, insert-tail: Private ordinary functions
Function, into-vector-copy: Private ordinary functions
Function, iterator-at: Public ordinary functions
Function, logior-mask: Private ordinary functions
Function, make-bind-row: Private ordinary functions
Function, make-column-signature: Private ordinary functions
Function, make-concatenation-state: Private ordinary functions
Function, make-header: Public ordinary functions
Function, make-iterator: Private ordinary functions
Function, make-leaf: Private ordinary functions
Function, make-node: Private ordinary functions
Function, make-setfable-table-row: Public ordinary functions
Function, make-signature: Private ordinary functions
Function, make-sparse-material-column: Public ordinary functions
Function, make-sparse-material-column-iterator: Private ordinary functions
Function, make-sparse-material-column-range: Private ordinary functions
Function, make-standard-header: Private ordinary functions
Function, make-standard-transformation: Private ordinary functions
Function, make-table: Public ordinary functions
Function, make-table-row: Public ordinary functions
Function, mask: Private ordinary functions
Function, max-index: Private ordinary functions
Function, move-children: Private ordinary functions
Function, move-children-in-column: Private ordinary functions
Function, move-children-in-columns: Private ordinary functions
Function, move-column-to: Private ordinary functions
Function, move-iterator: Public ordinary functions
Function, move-iterator-to: Public ordinary functions
Function, move-stack: Private ordinary functions
Function, move-to-existing-column: Private ordinary functions
Function, move/pad-stack: Private ordinary functions
Function, mutate-leaf: Private ordinary functions
Function, name-to-index: Public ordinary functions
Function, node: Private ordinary functions
Function, nullify: Public ordinary functions
Function, occupied-space: Private ordinary functions
Function, offset: Private ordinary functions
Function, order-by: Public ordinary functions
Function, pad-stack: Private ordinary functions
Function, parent-changed: Private ordinary functions
Function, parent-index: Private ordinary functions
Function, range-iterator: Private ordinary functions
Function, read-buffers: Private ordinary functions
Function, read-changes: Private ordinary functions
Function, read-column-names: Private ordinary functions
Function, read-column-signatures: Private ordinary functions
Function, read-column-types: Private ordinary functions
Function, read-columns: Private ordinary functions
Function, read-depths: Private ordinary functions
Function, read-indexes: Private ordinary functions
Function, read-initial-index: Private ordinary functions
Function, read-initialization-status: Private ordinary functions
Function, read-name: Public ordinary functions
Function, read-new-value: Public ordinary functions
Function, read-stacks: Private ordinary functions
Function, read-touched: Private ordinary functions
Function, read-transformation: Private ordinary functions
Function, read-type: Private ordinary functions
Function, reduce-stack: Private ordinary functions
Function, reduce-stacks: Private ordinary functions
Function, remove-nulls-from-columns: Private ordinary functions
Function, rename-columns: Public ordinary functions
Function, row: Public ordinary functions
Function, row-at: Public ordinary functions
Function, row-to-list: Public ordinary functions
Function, row-to-vector: Public ordinary functions
Function, rr: Public ordinary functions
Function, rs: Public ordinary functions
Function, s: Public ordinary functions
Function, s-list: Public ordinary functions
Function, s-list: Public ordinary functions
Function, select-columns: Private ordinary functions
Function, select-rows: Private ordinary functions
Function, set-row: Public ordinary functions
Function, setfable-table-row-iterator: Private ordinary functions
Function, setfable-table-row-p: Private ordinary functions
Function, shift-content: Private ordinary functions
Function, sparse-material-column-at: Private ordinary functions
Function, sparse-material-column-iterator-buffers: Private ordinary functions
Function, sparse-material-column-iterator-changes: Private ordinary functions
Function, sparse-material-column-iterator-column-types: Private ordinary functions
Function, sparse-material-column-iterator-columns: Private ordinary functions
Function, sparse-material-column-iterator-depths: Private ordinary functions
Function, sparse-material-column-iterator-index: Public ordinary functions
Function, sparse-material-column-iterator-indexes: Private ordinary functions
Function, sparse-material-column-iterator-initial-index: Private ordinary functions
Function, sparse-material-column-iterator-initialization-status: Private ordinary functions
Function, sparse-material-column-iterator-p: Private ordinary functions
Function, sparse-material-column-iterator-stacks: Private ordinary functions
Function, sparse-material-column-iterator-touched: Private ordinary functions
Function, sparse-material-column-iterator-transformation: Private ordinary functions
Function, standard-header-column-names: Private ordinary functions
Function, standard-header-column-signatures: Private ordinary functions
Function, standard-header-p: Private ordinary functions
Function, standard-transformation-bind-row-closure: Private ordinary functions
Function, standard-transformation-column-count: Private ordinary functions
Function, standard-transformation-columns: Private ordinary functions
Function, standard-transformation-count: Private ordinary functions
Function, standard-transformation-dropped: Private ordinary functions
Function, standard-transformation-in-place: Private ordinary functions
Function, standard-transformation-iterator: Private ordinary functions
Function, standard-transformation-marker-column: Private ordinary functions
Function, standard-transformation-p: Private ordinary functions
Function, standard-transformation-restarts-enabled: Private ordinary functions
Function, standard-transformation-row: Public ordinary functions
Function, standard-transformation-start: Private ordinary functions
Function, standard-transformation-table: Private ordinary functions
Function, table-from-header: Private ordinary functions
Function, table-row-iterator: Private ordinary functions
Function, table-row-p: Private ordinary functions
Function, to-matrix: Public ordinary functions
Function, transform-row-impl: Private ordinary functions
Function, tree-index: Private ordinary functions
Function, trim-depth: Private ordinary functions
Function, trim-depth-in-column: Private ordinary functions
Function, truncate-mask: Private ordinary functions
Function, unique-names: Private ordinary functions
Function, untouch: Public ordinary functions
Function, update-parents: Private ordinary functions
Function, validate-active-header: Private ordinary functions
Function, validate-active-row: Private ordinary functions
Function, validate-row: Private ordinary functions
Function, vs: Private ordinary functions
Function, vstack: Public ordinary functions

G
gather-column-data: Private generic functions
gather-column-data: Private generic functions
gather-column-data: Private generic functions
gather-column-data: Private generic functions
gather-masks: Private ordinary functions
Generic Function, (setf access-iterator): Private generic functions
Generic Function, (setf access-position): Private generic functions
Generic Function, (setf at): Public generic functions
Generic Function, (setf column-at): Public generic functions
Generic Function, access-iterator: Private generic functions
Generic Function, access-position: Private generic functions
Generic Function, address-range: Public generic functions
Generic Function, alter-columns: Public generic functions
Generic Function, alter-columns: Public generic functions
Generic Function, at: Public generic functions
Generic Function, augment-iterator: Public generic functions
Generic Function, bind-row-closure: Public generic functions
Generic Function, check-column-signatures-compatibility: Public generic functions
Generic Function, column-at: Public generic functions
Generic Function, column-at: Public generic functions
Generic Function, column-count: Public generic functions
Generic Function, column-count: Public generic functions
Generic Function, column-name: Public generic functions
Generic Function, column-signature-spec: Private generic functions
Generic Function, column-size: Public generic functions
Generic Function, column-specs: Public generic functions
Generic Function, column-type: Public generic functions
Generic Function, column-type: Public generic functions
Generic Function, column-type-error-column: Private generic functions
Generic Function, concatenate-headers: Public generic functions
Generic Function, content: Public generic functions
Generic Function, copy-from: Public generic functions
Generic Function, copy-to: Public generic functions
Generic Function, erase!: Public generic functions
Generic Function, fill-columns-buffer-impl: Private generic functions
Generic Function, finish-iterator: Public generic functions
Generic Function, gather-column-data: Private generic functions
Generic Function, header: Public generic functions
Generic Function, hstack*: Public generic functions
Generic Function, in-existing-content: Private generic functions
Generic Function, iterator: Public generic functions
Generic Function, join: Public generic functions
Generic Function, make-iterator: Public generic functions
Generic Function, make-row: Public generic functions
Generic Function, make-table*: Public generic functions
Generic Function, optimized-closure: Private generic functions
Generic Function, read-callback: Private generic functions
Generic Function, read-column: Private generic functions
Generic Function, read-columns: Private generic functions
Generic Function, read-from: Private generic functions
Generic Function, read-header: Public generic functions
Generic Function, read-header: Private generic functions
Generic Function, read-initial-position: Private generic functions
Generic Function, read-iterator: Private generic functions
Generic Function, read-row-count: Private generic functions
Generic Function, read-table-row: Private generic functions
Generic Function, read-to: Private generic functions
Generic Function, remove-nulls: Public generic functions
Generic Function, remove-nulls: Public generic functions
Generic Function, row-count: Public generic functions
Generic Function, row-erase: Private generic functions
Generic Function, select: Public generic functions
Generic Function, select-columns: Public generic functions
Generic Function, show: Public generic functions
Generic Function, to-table: Public generic functions
Generic Function, transform: Public generic functions
Generic Function, transform-row: Public generic functions
Generic Function, transformation: Public generic functions
Generic Function, transformation-result: Public generic functions
Generic Function, truncate-to-length: Public generic functions
Generic Function, visualize: Public generic functions
Generic Function, vmask: Public generic functions
Generic Function, vstack*: Public generic functions
Generic Function, write-columns: Private generic functions

H
hash-join-implementation: Private ordinary functions
header: Public ordinary functions
header: Public generic functions
header: Public generic functions
header: Public generic functions
hstack: Public ordinary functions
hstack*: Public generic functions
hstack*: Public generic functions

I
in-existing-content: Private generic functions
in-existing-content: Private generic functions
index: Public ordinary functions
index-promoted: Private ordinary functions
index-to-name: Public ordinary functions
initialize-iterator-column: Private ordinary functions
initialize-iterator-columns: Private ordinary functions
insert-tail: Private ordinary functions
into-vector-copy: Private ordinary functions
iterator: Public generic functions
iterator: Public generic functions
iterator-at: Public ordinary functions

J
join: Public generic functions
join: Public generic functions
join: Public generic functions
join: Public generic functions

L
logior-mask: Private ordinary functions

M
Macro, aggregate-columns: Public macros
Macro, aggregate-rows: Public macros
Macro, bind-row: Public macros
Macro, brr: Public macros
Macro, drop-row-when: Public macros
Macro, pipeline: Public macros
Macro, with-concatenation-state: Private macros
Macro, with-header: Public macros
Macro, with-standard-header: Public macros
Macro, with-table: Public macros
make-bind-row: Private ordinary functions
make-column-signature: Private ordinary functions
make-concatenation-state: Private ordinary functions
make-header: Public ordinary functions
make-iterator: Public generic functions
make-iterator: Public generic functions
make-iterator: Private ordinary functions
make-leaf: Private ordinary functions
make-node: Private ordinary functions
make-row: Public generic functions
make-row: Public generic functions
make-row: Public generic functions
make-row: Public generic functions
make-setfable-table-row: Public ordinary functions
make-signature: Private ordinary functions
make-sparse-material-column: Public ordinary functions
make-sparse-material-column-iterator: Private ordinary functions
make-sparse-material-column-range: Private ordinary functions
make-standard-header: Private ordinary functions
make-standard-transformation: Private ordinary functions
make-table: Public ordinary functions
make-table*: Public generic functions
make-table*: Public generic functions
make-table-row: Public ordinary functions
mask: Private ordinary functions
max-index: Private ordinary functions
Method, (setf access-iterator): Private generic functions
Method, (setf access-position): Private generic functions
Method, (setf at): Public generic functions
Method, (setf column-at): Public generic functions
Method, access-iterator: Private generic functions
Method, access-position: Private generic functions
Method, across: Public standalone methods
Method, across: Public standalone methods
Method, across: Public standalone methods
Method, address-range: Public generic functions
Method, address-range: Public generic functions
Method, aggregator-constructor: Public standalone methods
Method, aggregator-constructor: Public standalone methods
Method, alter-columns: Public generic functions
Method, alter-columns: Public generic functions
Method, apply-range-function: Public standalone methods
Method, apply-range-function: Public standalone methods
Method, at: Public generic functions
Method, augment-iterator: Public generic functions
Method, become-transactional: Public standalone methods
Method, bind-row-closure: Public generic functions
Method, bind-row-closure: Public generic functions
Method, bind-row-closure: Public generic functions
Method, check-column-signatures-compatibility: Public generic functions
Method, clone: Public standalone methods
Method, clone: Public standalone methods
Method, clone: Public standalone methods
Method, cloning-information: Public standalone methods
Method, cloning-information: Public standalone methods
Method, cloning-information: Public standalone methods
Method, cloning-information: Public standalone methods
Method, cloning-information: Public standalone methods
Method, column-at: Public generic functions
Method, column-at: Public generic functions
Method, column-at: Public generic functions
Method, column-count: Public generic functions
Method, column-count: Public generic functions
Method, column-name: Public generic functions
Method, column-signature-spec: Private generic functions
Method, column-size: Public generic functions
Method, column-specs: Public generic functions
Method, column-type: Public generic functions
Method, column-type: Public generic functions
Method, column-type-error-column: Private generic functions
Method, column-type-error-column: Private generic functions
Method, concatenate-headers: Public generic functions
Method, consume-front: Public standalone methods
Method, consume-front: Public standalone methods
Method, consume-front: Public standalone methods
Method, content: Public generic functions
Method, copy-from: Public generic functions
Method, drop-front: Public standalone methods
Method, drop-front: Public standalone methods
Method, erase!: Public generic functions
Method, fill-columns-buffer-impl: Private generic functions
Method, fill-columns-buffer-impl: Private generic functions
Method, fill-columns-buffer-impl: Private generic functions
Method, finish-iterator: Public generic functions
Method, gather-column-data: Private generic functions
Method, gather-column-data: Private generic functions
Method, gather-column-data: Private generic functions
Method, header: Public generic functions
Method, header: Public generic functions
Method, hstack*: Public generic functions
Method, in-existing-content: Private generic functions
Method, iterator: Public generic functions
Method, join: Public generic functions
Method, join: Public generic functions
Method, join: Public generic functions
Method, make-iterator: Public generic functions
Method, make-row: Public generic functions
Method, make-row: Public generic functions
Method, make-row: Public generic functions
Method, make-table*: Public generic functions
Method, optimized-closure: Private generic functions
Method, peek-front: Public standalone methods
Method, peek-front: Public standalone methods
Method, peek-front: Public standalone methods
Method, position-modification: Public standalone methods
Method, position-modification: Public standalone methods
Method, print-object: Public standalone methods
Method, read-callback: Private generic functions
Method, read-column: Private generic functions
Method, read-columns: Private generic functions
Method, read-from: Private generic functions
Method, read-header: Public generic functions
Method, read-header: Private generic functions
Method, read-initial-position: Private generic functions
Method, read-iterator: Private generic functions
Method, read-row-count: Private generic functions
Method, read-table-row: Private generic functions
Method, read-to: Private generic functions
Method, remove-nulls: Public generic functions
Method, remove-nulls: Public generic functions
Method, replica: Public standalone methods
Method, reset!: Public standalone methods
Method, reset!: Public standalone methods
Method, reset!: Public standalone methods
Method, row-count: Public generic functions
Method, select: Public generic functions
Method, select-columns: Public generic functions
Method, show: Public generic functions
Method, to-table: Public generic functions
Method, to-table: Public generic functions
Method, to-table: Public generic functions
Method, to-table: Public generic functions
Method, to-table: Public generic functions
Method, to-table: Public generic functions
Method, transform: Public generic functions
Method, transform-row: Public generic functions
Method, transformation: Public generic functions
Method, transformation-result: Public generic functions
Method, traverse: Public standalone methods
Method, traverse: Public standalone methods
Method, traverse: Public standalone methods
Method, traverse: Public standalone methods
Method, truncate-to-length: Public generic functions
Method, vmask: Public generic functions
Method, vstack*: Public generic functions
Method, whole-range: Public standalone methods
Method, whole-range: Public standalone methods
Method, write-columns: Private generic functions
move-children: Private ordinary functions
move-children-in-column: Private ordinary functions
move-children-in-columns: Private ordinary functions
move-column-to: Private ordinary functions
move-iterator: Public ordinary functions
move-iterator-to: Public ordinary functions
move-stack: Private ordinary functions
move-to-existing-column: Private ordinary functions
move/pad-stack: Private ordinary functions
mutate-leaf: Private ordinary functions

N
name-to-index: Public ordinary functions
node: Private ordinary functions
nullify: Public ordinary functions

O
occupied-space: Private ordinary functions
offset: Private ordinary functions
optimized-closure: Private generic functions
optimized-closure: Private generic functions
order-by: Public ordinary functions

P
pad-stack: Private ordinary functions
parent-changed: Private ordinary functions
parent-index: Private ordinary functions
peek-front: Public standalone methods
peek-front: Public standalone methods
peek-front: Public standalone methods
pipeline: Public macros
position-modification: Public standalone methods
position-modification: Public standalone methods
print-object: Public standalone methods

R
range-iterator: Private ordinary functions
read-buffers: Private ordinary functions
read-callback: Private generic functions
read-callback: Private generic functions
read-changes: Private ordinary functions
read-column: Private generic functions
read-column: Private generic functions
read-column-names: Private ordinary functions
read-column-signatures: Private ordinary functions
read-column-types: Private ordinary functions
read-columns: Private ordinary functions
read-columns: Private generic functions
read-columns: Private generic functions
read-depths: Private ordinary functions
read-from: Private generic functions
read-from: Private generic functions
read-header: Public generic functions
read-header: Public generic functions
read-header: Private generic functions
read-header: Private generic functions
read-indexes: Private ordinary functions
read-initial-index: Private ordinary functions
read-initial-position: Private generic functions
read-initial-position: Private generic functions
read-initialization-status: Private ordinary functions
read-iterator: Private generic functions
read-iterator: Private generic functions
read-name: Public ordinary functions
read-new-value: Public ordinary functions
read-row-count: Private generic functions
read-row-count: Private generic functions
read-stacks: Private ordinary functions
read-table-row: Private generic functions
read-table-row: Private generic functions
read-to: Private generic functions
read-to: Private generic functions
read-touched: Private ordinary functions
read-transformation: Private ordinary functions
read-type: Private ordinary functions
reduce-stack: Private ordinary functions
reduce-stacks: Private ordinary functions
remove-nulls: Public generic functions
remove-nulls: Public generic functions
remove-nulls: Public generic functions
remove-nulls: Public generic functions
remove-nulls-from-columns: Private ordinary functions
rename-columns: Public ordinary functions
replica: Public standalone methods
reset!: Public standalone methods
reset!: Public standalone methods
reset!: Public standalone methods
row: Public ordinary functions
row-at: Public ordinary functions
row-count: Public generic functions
row-count: Public generic functions
row-erase: Private generic functions
row-to-list: Public ordinary functions
row-to-vector: Public ordinary functions
rr: Public ordinary functions
rs: Public ordinary functions

S
s: Public ordinary functions
s-list: Public ordinary functions
s-list: Public ordinary functions
select: Public generic functions
select: Public generic functions
select-columns: Public generic functions
select-columns: Public generic functions
select-columns: Private ordinary functions
select-rows: Private ordinary functions
set-row: Public ordinary functions
setfable-table-row-iterator: Private ordinary functions
setfable-table-row-p: Private ordinary functions
shift-content: Private ordinary functions
show: Public generic functions
show: Public generic functions
sparse-material-column-at: Private ordinary functions
sparse-material-column-iterator-buffers: Private ordinary functions
sparse-material-column-iterator-changes: Private ordinary functions
sparse-material-column-iterator-column-types: Private ordinary functions
sparse-material-column-iterator-columns: Private ordinary functions
sparse-material-column-iterator-depths: Private ordinary functions
sparse-material-column-iterator-index: Public ordinary functions
sparse-material-column-iterator-indexes: Private ordinary functions
sparse-material-column-iterator-initial-index: Private ordinary functions
sparse-material-column-iterator-initialization-status: Private ordinary functions
sparse-material-column-iterator-p: Private ordinary functions
sparse-material-column-iterator-stacks: Private ordinary functions
sparse-material-column-iterator-touched: Private ordinary functions
sparse-material-column-iterator-transformation: Private ordinary functions
standard-header-column-names: Private ordinary functions
standard-header-column-signatures: Private ordinary functions
standard-header-p: Private ordinary functions
standard-transformation-bind-row-closure: Private ordinary functions
standard-transformation-column-count: Private ordinary functions
standard-transformation-columns: Private ordinary functions
standard-transformation-count: Private ordinary functions
standard-transformation-dropped: Private ordinary functions
standard-transformation-in-place: Private ordinary functions
standard-transformation-iterator: Private ordinary functions
standard-transformation-marker-column: Private ordinary functions
standard-transformation-p: Private ordinary functions
standard-transformation-restarts-enabled: Private ordinary functions
standard-transformation-row: Public ordinary functions
standard-transformation-start: Private ordinary functions
standard-transformation-table: Private ordinary functions

T
table-from-header: Private ordinary functions
table-row-iterator: Private ordinary functions
table-row-p: Private ordinary functions
to-matrix: Public ordinary functions
to-table: Public generic functions
to-table: Public generic functions
to-table: Public generic functions
to-table: Public generic functions
to-table: Public generic functions
to-table: Public generic functions
to-table: Public generic functions
transform: Public generic functions
transform: Public generic functions
transform-row: Public generic functions
transform-row: Public generic functions
transform-row-impl: Private ordinary functions
transformation: Public generic functions
transformation: Public generic functions
transformation-result: Public generic functions
transformation-result: Public generic functions
traverse: Public standalone methods
traverse: Public standalone methods
traverse: Public standalone methods
traverse: Public standalone methods
tree-index: Private ordinary functions
trim-depth: Private ordinary functions
trim-depth-in-column: Private ordinary functions
truncate-mask: Private ordinary functions
truncate-to-length: Public generic functions
truncate-to-length: Public generic functions

U
unique-names: Private ordinary functions
untouch: Public ordinary functions
update-parents: Private ordinary functions

V
validate-active-header: Private ordinary functions
validate-active-row: Private ordinary functions
validate-row: Private ordinary functions
visualize: Public generic functions
vmask: Public generic functions
vmask: Public generic functions
vs: Private ordinary functions
vstack: Public ordinary functions
vstack*: Public generic functions
vstack*: Public generic functions

W
whole-range: Public standalone methods
whole-range: Public standalone methods
with-concatenation-state: Private macros
with-header: Public macros
with-standard-header: Public macros
with-table: Public macros
write-columns: Private generic functions
write-columns: Private generic functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   %   *  
B   C   D   I   M   N   P   R   S   T  
Index Entry  Section

%
%callback: Public classes
%column: Public conditions
%column: Private conditions
%column: Private classes
%columns: Public classes
%from: Public classes
%header: Public conditions
%header: Public classes
%header: Public classes
%header: Public classes
%headers: Public conditions
%initial-position: Private classes
%iterator: Private classes
%optimized-closure: Public classes
%position: Private classes
%row-count: Public classes
%table-row: Public classes
%to: Public classes

*
*current-row*: Public special variables
*header*: Public special variables
*row*: Public special variables
*table*: Public special variables
*transform-control*: Private special variables
*transform-in-place*: Public special variables

B
bind-row-closure: Private structures
buffers: Private structures

C
changed-parents: Private structures
changes: Private structures
column-count: Private structures
column-names: Public structures
column-signatures: Public structures
column-types: Private structures
columns: Private structures
columns: Private structures
columns: Private structures
count: Private structures

D
depths: Private structures
dropped: Private structures

I
in-place: Private structures
index: Private structures
indexes: Private structures
initial-index: Private structures
initialization-status: Private structures
iterator: Private structures
iterator: Private structures
iterator: Private structures

M
marker-column: Private structures
mask-bytes: Private symbol macros
masks: Private structures
max-index: Private structures

N
name: Public structures
nodes: Private structures

P
parents: Private structures

R
restarts-enabled: Private structures
row: Private structures

S
Slot, %callback: Public classes
Slot, %column: Public conditions
Slot, %column: Private conditions
Slot, %column: Private classes
Slot, %columns: Public classes
Slot, %from: Public classes
Slot, %header: Public conditions
Slot, %header: Public classes
Slot, %header: Public classes
Slot, %header: Public classes
Slot, %headers: Public conditions
Slot, %initial-position: Private classes
Slot, %iterator: Private classes
Slot, %optimized-closure: Public classes
Slot, %position: Private classes
Slot, %row-count: Public classes
Slot, %table-row: Public classes
Slot, %to: Public classes
Slot, bind-row-closure: Private structures
Slot, buffers: Private structures
Slot, changed-parents: Private structures
Slot, changes: Private structures
Slot, column-count: Private structures
Slot, column-names: Public structures
Slot, column-signatures: Public structures
Slot, column-types: Private structures
Slot, columns: Private structures
Slot, columns: Private structures
Slot, columns: Private structures
Slot, count: Private structures
Slot, depths: Private structures
Slot, dropped: Private structures
Slot, in-place: Private structures
Slot, index: Private structures
Slot, indexes: Private structures
Slot, initial-index: Private structures
Slot, initialization-status: Private structures
Slot, iterator: Private structures
Slot, iterator: Private structures
Slot, iterator: Private structures
Slot, marker-column: Private structures
Slot, masks: Private structures
Slot, max-index: Private structures
Slot, name: Public structures
Slot, nodes: Private structures
Slot, parents: Private structures
Slot, restarts-enabled: Private structures
Slot, row: Private structures
Slot, stacks: Private structures
Slot, start: Private structures
Slot, table: Private structures
Slot, touched: Private structures
Slot, transformation: Private structures
Slot, type: Public structures
Special Variable, *current-row*: Public special variables
Special Variable, *header*: Public special variables
Special Variable, *row*: Public special variables
Special Variable, *table*: Public special variables
Special Variable, *transform-control*: Private special variables
Special Variable, *transform-in-place*: Public special variables
stacks: Private structures
start: Private structures
Symbol Macro, mask-bytes: Private symbol macros

T
table: Private structures
touched: Private structures
transformation: Private structures
type: Public structures

Jump to:   %   *  
B   C   D   I   M   N   P   R   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   D   F   G   H   I   M   N   P   R   S   T   U   V  
Index Entry  Section

A
api: The vellum/api module
aux-package.lisp: The vellum/aux-package․lisp file

B
between: Public classes
bind-row: Public classes

C
cl-ds.lisp: The vellum/integration/cl-ds․lisp file
Class, between: Public classes
Class, bind-row: Public classes
Class, content: Public classes
Class, frame-range-mixin: Public classes
Class, fundamental-column: Public classes
Class, fundamental-table: Public classes
Class, selector: Public classes
Class, sparse-material-column: Public classes
Class, sparse-material-column-range: Private classes
Class, standard-table: Public classes
Class, standard-table-range: Public classes
Class, to-table-function: Private classes
column: The vellum/column module
column-error: Private conditions
column-signature: Public structures
column-type-error: Public conditions
concatenation-state: Private structures
Condition, column-error: Private conditions
Condition, column-type-error: Public conditions
Condition, file-input-row-cant-be-created: Public conditions
Condition, headers-incompatible: Public conditions
Condition, index-out-of-column-bounds: Private conditions
Condition, invalid-input-for-row: Public conditions
Condition, invalid-name: Public conditions
Condition, iterator-error: Private conditions
Condition, name-duplicated: Public conditions
Condition, name-when-selecting-row: Public conditions
Condition, no-column: Public conditions
Condition, no-header: Public conditions
Condition, no-row: Private conditions
Condition, no-such-column: Private conditions
Condition, no-transformation: Public conditions
Condition, row-cant-be-created: Public conditions
Condition, setting-to-null: Private conditions
Condition, transformation-error: Public conditions
Condition, unable-to-construct-row: Public conditions
conditions.lisp: The vellum/column/conditions․lisp file
conditions.lisp: The vellum/header/conditions․lisp file
conditions.lisp: The vellum/table/conditions․lisp file
conditions.lisp: The vellum/api/conditions․lisp file
content: Public classes

D
docstring.lisp: The vellum/column/docstring․lisp file
documentation.lisp: The vellum/header/documentation․lisp file
documentation.lisp: The vellum/table/documentation․lisp file

F
File, aux-package.lisp: The vellum/aux-package․lisp file
File, cl-ds.lisp: The vellum/integration/cl-ds․lisp file
File, conditions.lisp: The vellum/column/conditions․lisp file
File, conditions.lisp: The vellum/header/conditions․lisp file
File, conditions.lisp: The vellum/table/conditions․lisp file
File, conditions.lisp: The vellum/api/conditions․lisp file
File, docstring.lisp: The vellum/column/docstring․lisp file
File, documentation.lisp: The vellum/header/documentation․lisp file
File, documentation.lisp: The vellum/table/documentation․lisp file
File, functions.lisp: The vellum/header/functions․lisp file
File, functions.lisp: The vellum/table/functions․lisp file
File, functions.lisp: The vellum/api/functions․lisp file
File, generics.lisp: The vellum/table/generics․lisp file
File, generics.lisp: The vellum/api/generics․lisp file
File, implementation.lisp: The vellum/column/implementation․lisp file
File, implementation.lisp: The vellum/header/implementation․lisp file
File, implementation.lisp: The vellum/selection/implementation․lisp file
File, implementation.lisp: The vellum/table/implementation․lisp file
File, internal.lisp: The vellum/column/internal․lisp file
File, internal.lisp: The vellum/header/internal․lisp file
File, internal.lisp: The vellum/table/internal․lisp file
File, macros.lisp: The vellum/header/macros․lisp file
File, macros.lisp: The vellum/table/macros․lisp file
File, macros.lisp: The vellum/api/macros․lisp file
File, package.lisp: The vellum/column/package․lisp file
File, package.lisp: The vellum/header/package․lisp file
File, package.lisp: The vellum/selection/package․lisp file
File, package.lisp: The vellum/table/package․lisp file
File, package.lisp: The vellum/api/package․lisp file
File, package.lisp: The vellum/integration/package․lisp file
File, protocol.lisp: The vellum/column/protocol․lisp file
File, protocol.lisp: The vellum/header/protocol․lisp file
File, to-table.lisp: The vellum/table/to-table․lisp file
File, types.lisp: The vellum/column/types․lisp file
File, types.lisp: The vellum/header/types․lisp file
File, types.lisp: The vellum/table/types․lisp file
File, utils.lisp: The vellum/header/utils․lisp file
File, variables.lisp: The vellum/header/variables․lisp file
File, variables.lisp: The vellum/table/variables․lisp file
File, vellum.asd: The vellum/vellum․asd file
file-input-row-cant-be-created: Public conditions
frame-range-mixin: Public classes
functions.lisp: The vellum/header/functions․lisp file
functions.lisp: The vellum/table/functions․lisp file
functions.lisp: The vellum/api/functions․lisp file
fundamental-column: Public classes
fundamental-table: Public classes

G
generics.lisp: The vellum/table/generics․lisp file
generics.lisp: The vellum/api/generics․lisp file

H
header: The vellum/header module
headers-incompatible: Public conditions

I
implementation.lisp: The vellum/column/implementation․lisp file
implementation.lisp: The vellum/header/implementation․lisp file
implementation.lisp: The vellum/selection/implementation․lisp file
implementation.lisp: The vellum/table/implementation․lisp file
index-out-of-column-bounds: Private conditions
integration: The vellum/integration module
internal.lisp: The vellum/column/internal․lisp file
internal.lisp: The vellum/header/internal․lisp file
internal.lisp: The vellum/table/internal․lisp file
invalid-input-for-row: Public conditions
invalid-name: Public conditions
iterator-buffer: Private types
iterator-change: Private types
iterator-error: Private conditions
iterator-stack: Private types

M
macros.lisp: The vellum/header/macros․lisp file
macros.lisp: The vellum/table/macros․lisp file
macros.lisp: The vellum/api/macros․lisp file
Module, api: The vellum/api module
Module, column: The vellum/column module
Module, header: The vellum/header module
Module, integration: The vellum/integration module
Module, selection: The vellum/selection module
Module, table: The vellum/table module

N
name-duplicated: Public conditions
name-when-selecting-row: Public conditions
no-column: Public conditions
no-header: Public conditions
no-row: Private conditions
no-such-column: Private conditions
no-transformation: Public conditions

P
Package, vellum: The vellum package
Package, vellum.aux-package: The vellum․aux-package package
Package, vellum.column: The vellum․column package
Package, vellum.header: The vellum․header package
Package, vellum.integration: The vellum․integration package
Package, vellum.selection: The vellum․selection package
Package, vellum.table: The vellum․table package
package.lisp: The vellum/column/package․lisp file
package.lisp: The vellum/header/package․lisp file
package.lisp: The vellum/selection/package․lisp file
package.lisp: The vellum/table/package․lisp file
package.lisp: The vellum/api/package․lisp file
package.lisp: The vellum/integration/package․lisp file
protocol.lisp: The vellum/column/protocol․lisp file
protocol.lisp: The vellum/header/protocol․lisp file

R
row-cant-be-created: Public conditions

S
selection: The vellum/selection module
selector: Public classes
setfable-table-row: Public structures
setting-to-null: Private conditions
sparse-material-column: Public classes
sparse-material-column-iterator: Private structures
sparse-material-column-range: Private classes
standard-header: Public structures
standard-table: Public classes
standard-table-range: Public classes
standard-transformation: Private structures
Structure, column-signature: Public structures
Structure, concatenation-state: Private structures
Structure, setfable-table-row: Public structures
Structure, sparse-material-column-iterator: Private structures
Structure, standard-header: Public structures
Structure, standard-transformation: Private structures
Structure, table-row: Private structures
System, vellum: The vellum system

T
table: The vellum/table module
table-row: Private structures
to-table-function: Private classes
to-table.lisp: The vellum/table/to-table․lisp file
transformation-error: Public conditions
Type, iterator-buffer: Private types
Type, iterator-change: Private types
Type, iterator-stack: Private types
types.lisp: The vellum/column/types․lisp file
types.lisp: The vellum/header/types․lisp file
types.lisp: The vellum/table/types․lisp file

U
unable-to-construct-row: Public conditions
utils.lisp: The vellum/header/utils․lisp file

V
variables.lisp: The vellum/header/variables․lisp file
variables.lisp: The vellum/table/variables․lisp file
vellum: The vellum system
vellum: The vellum package
vellum.asd: The vellum/vellum․asd file
vellum.aux-package: The vellum․aux-package package
vellum.column: The vellum․column package
vellum.header: The vellum․header package
vellum.integration: The vellum․integration package
vellum.selection: The vellum․selection package
vellum.table: The vellum․table package

Jump to:   A   B   C   D   F   G   H   I   M   N   P   R   S   T   U   V