The vellum Reference Manual

Table of Contents

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

The vellum Reference Manual

This is the vellum Reference Manual, version 0.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Oct 13 12:58:05 2021 GMT+0.


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

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, column types, and predicates 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 'vellum.header:standard-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.

** 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.


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

2 Systems

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


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

2.1 vellum

Author

Marek Kochanowicz

License

BSD simplified

Description

Data Frames for Common Lisp

Version

0.0.0

Dependencies
Source

vellum.asd (file)

Components

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

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)

Parent

vellum (system)

Location

column/

Components

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

3.2 vellum/header

Dependency

column (module)

Parent

vellum (system)

Location

header/

Components

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

3.3 vellum/selection

Dependency

header (module)

Parent

vellum (system)

Location

selection/

Components

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

3.4 vellum/table

Dependency

selection (module)

Parent

vellum (system)

Location

table/

Components

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

3.5 vellum/api

Dependency

table (module)

Parent

vellum (system)

Location

api/

Components

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

3.6 vellum/integration

Dependency

api (module)

Parent

vellum (system)

Location

integration/

Components

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

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 files   [Contents][Index]

4.1.1 vellum.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/vellum-20210807-git/vellum.asd

Systems

vellum (system)


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

4.1.2 vellum/aux-package.lisp

Parent

vellum (system)

Location

aux-package.lisp

Packages

vellum.aux-package


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

4.1.3 vellum/column/package.lisp

Parent

column (module)

Location

column/package.lisp

Packages

vellum.column


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

4.1.4 vellum/column/protocol.lisp

Parent

column (module)

Location

column/protocol.lisp

Exported Definitions

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

4.1.5 vellum/column/types.lisp

Parent

column (module)

Location

column/types.lisp

Exported Definitions
Internal Definitions

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

4.1.6 vellum/column/conditions.lisp

Parent

column (module)

Location

column/conditions.lisp

Exported Definitions

column-type-error (condition)

Internal Definitions

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

4.1.7 vellum/column/docstring.lisp

Parent

column (module)

Location

column/docstring.lisp


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

4.1.8 vellum/column/internal.lisp

Parent

column (module)

Location

column/internal.lisp

Internal Definitions

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

4.1.9 vellum/column/implementation.lisp

Parent

column (module)

Location

column/implementation.lisp

Exported Definitions
Internal Definitions

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

4.1.10 vellum/header/package.lisp

Parent

header (module)

Location

header/package.lisp

Packages

vellum.header


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

4.1.11 vellum/header/variables.lisp

Parent

header (module)

Location

header/variables.lisp

Exported Definitions

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

4.1.12 vellum/header/macros.lisp

Parent

header (module)

Location

header/macros.lisp

Exported Definitions

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

4.1.13 vellum/header/protocol.lisp

Parent

header (module)

Location

header/protocol.lisp

Exported Definitions
Internal Definitions

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

4.1.14 vellum/header/utils.lisp

Parent

header (module)

Location

header/utils.lisp


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

4.1.15 vellum/header/functions.lisp

Parent

header (module)

Location

header/functions.lisp

Exported Definitions
Internal Definitions

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

4.1.16 vellum/header/types.lisp

Parent

header (module)

Location

header/types.lisp

Exported Definitions
Internal Definitions

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

4.1.17 vellum/header/conditions.lisp

Parent

header (module)

Location

header/conditions.lisp

Exported Definitions
Internal Definitions

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

4.1.18 vellum/header/internal.lisp

Parent

header (module)

Location

header/internal.lisp

Internal Definitions

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

4.1.19 vellum/header/implementation.lisp

Parent

header (module)

Location

header/implementation.lisp

Exported Definitions
Internal Definitions

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

4.1.20 vellum/header/documentation.lisp

Parent

header (module)

Location

header/documentation.lisp


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

4.1.21 vellum/selection/package.lisp

Parent

selection (module)

Location

selection/package.lisp

Packages

vellum.selection


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

4.1.22 vellum/selection/implementation.lisp

Parent

selection (module)

Location

selection/implementation.lisp

Exported Definitions
Internal Definitions

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

4.1.23 vellum/table/package.lisp

Parent

table (module)

Location

table/package.lisp

Packages

vellum.table


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

4.1.24 vellum/table/variables.lisp

Parent

table (module)

Location

table/variables.lisp

Exported Definitions
Internal Definitions

*transform-control* (special variable)


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

4.1.25 vellum/table/macros.lisp

Parent

table (module)

Location

table/macros.lisp

Exported Definitions

with-table (macro)


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

4.1.26 vellum/table/generics.lisp

Parent

table (module)

Location

table/generics.lisp

Exported Definitions
Internal Definitions

row-erase (generic function)


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

4.1.27 vellum/table/types.lisp

Parent

table (module)

Location

table/types.lisp

Exported Definitions
Internal Definitions

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

4.1.28 vellum/table/conditions.lisp

Parent

table (module)

Location

table/conditions.lisp

Exported Definitions

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

4.1.29 vellum/table/functions.lisp

Parent

table (module)

Location

table/functions.lisp

Exported Definitions

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

4.1.30 vellum/table/documentation.lisp

Parent

table (module)

Location

table/documentation.lisp


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

4.1.31 vellum/table/to-table.lisp

Parent

table (module)

Location

table/to-table.lisp

Exported Definitions
Internal Definitions

to-table-function (class)


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

4.1.32 vellum/table/internal.lisp

Parent

table (module)

Location

table/internal.lisp

Internal Definitions

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

4.1.33 vellum/table/implementation.lisp

Parent

table (module)

Location

table/implementation.lisp

Exported Definitions
Internal Definitions

read-iterator (method)


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

4.1.34 vellum/api/package.lisp

Parent

api (module)

Location

api/package.lisp

Packages

vellum


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

4.1.35 vellum/api/conditions.lisp

Parent

api (module)

Location

api/conditions.lisp

Exported Definitions

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

4.1.36 vellum/api/generics.lisp

Parent

api (module)

Location

api/generics.lisp

Exported Definitions

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

4.1.37 vellum/api/functions.lisp

Parent

api (module)

Location

api/functions.lisp

Exported Definitions
Internal Definitions

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

4.1.38 vellum/api/macros.lisp

Parent

api (module)

Location

api/macros.lisp

Exported Definitions

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

4.1.39 vellum/integration/package.lisp

Parent

integration (module)

Location

integration/package.lisp

Packages

vellum.integration


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

4.1.40 vellum/integration/cl-ds.lisp

Parent

integration (module)

Location

integration/cl-ds.lisp

Exported Definitions
Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 vellum.aux-package

Source

aux-package.lisp (file)

Used By List

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

5.2 vellum.column

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.3 vellum.header

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.4 vellum.selection

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.5 vellum.table

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.6 vellum

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.7 vellum.integration

Source

package.lisp (file)

Nickname

vellum.int

Use List
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *current-row*
Package

vellum.table

Source

variables.lisp (file)

Special Variable: *header*
Package

vellum.header

Source

variables.lisp (file)

Special Variable: *row*
Package

vellum.header

Source

variables.lisp (file)

Special Variable: *table*
Package

vellum.table

Source

variables.lisp (file)

Special Variable: *transform-in-place*
Package

vellum.table

Source

variables.lisp (file)

Special Variable: *validate-predicates*
Package

vellum.header

Source

variables.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: aggregate-columns TABLE EXPRESSION &key NAME SKIP-NULLS TYPE PREDICATE
Package

vellum

Source

macros.lisp (file)

Macro: aggregate-rows TABLE COLUMN PARAMS &rest MORE
Package

vellum

Source

macros.lisp (file)

Macro: bind-row SELECTED-COLUMNS &body BODY
Package

vellum.header

Source

macros.lisp (file)

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.header

Source

macros.lisp (file)

Macro: pipeline (TABLE) &body BODY
Package

vellum

Source

macros.lisp (file)

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 (file)

Macro: with-standard-header COLUMNS &body BODY
Package

vellum

Source

macros.lisp (file)

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

vellum.table

Source

macros.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: %aggregate-columns TABLE AGGREGATOR-CONSTRUCTOR &key SKIP-NULLS TYPE NAME PREDICATE
Package

vellum

Source

functions.lisp (file)

Function: %aggregate-rows TABLE &rest PARAMS
Package

vellum

Source

functions.lisp (file)

Function: add-columns FRAME &rest COLUMN-SPECS
Package

vellum

Source

functions.lisp (file)

Function: between &key FROM TO
Package

vellum.selection

Source

implementation.lisp (file)

Function: column-names HEADER
Package

vellum.header

Source

functions.lisp (file)

Function: column-names TABLE
Package

vellum.table

Source

functions.lisp (file)

Function: columns ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: constantly-t &rest IGNORED
Package

vellum.header

Source

types.lisp (file)

Function: current-row-as-vector &optional HEADER ROW
Package

vellum.header

Source

functions.lisp (file)

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 (file)

Function: empty-column HEADER-CLASS &rest ROW-PARAMETERS
Package

vellum

Source

functions.lisp (file)

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 (file)

Function: finish-transformation ()
Package

vellum.table

Source

functions.lisp (file)

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 (file)

Function: hstack FRAMES &key ISOLATE
Package

vellum.table

Source

functions.lisp (file)

Function: index ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: iterator-at ITERATOR COLUMN
Function: (setf iterator-at) NEW-VALUE ITERATOR COLUMN
Package

vellum.column

Source

implementation.lisp (file)

Function: make-sparse-material-column &key ELEMENT-TYPE
Package

vellum.column

Source

types.lisp (file)

Function: make-table &key CLASS COLUMNS HEADER
Package

vellum.table

Source

functions.lisp (file)

Function: move-iterator ITERATOR TIMES

Description:
Shifts ITERATOR forward on all columns.

Exceptional situations:
Should signal condition if this operation would move beyond column bounds.

Package

vellum.column

Source

implementation.lisp (file)

Function: move-iterator-to ITERATOR NEW-INDEX
Package

vellum.column

Source

implementation.lisp (file)

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 (file)

Function: order-by TABLE COLUMN COMPARATOR &rest COLUMNS-COMPARATORS
Package

vellum

Source

functions.lisp (file)

Function: read-new-value ()

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

Package

vellum.header

Source

functions.lisp (file)

Function: row ()
Package

vellum.header

Source

functions.lisp (file)

Function: row-to-list &rest FORMS
Package

vellum.table

Source

functions.lisp (file)

Function: row-to-vector &rest FORMS
Package

vellum.table

Source

functions.lisp (file)

Function: rr INDEX &optional ROW

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.header

Source

functions.lisp (file)

Writer

(setf rr) (function)

Function: (setf rr) NEW-VALUE INDEX &optional ROW
Package

vellum.header

Source

functions.lisp (file)

Reader

rr (function)

Function: rs &rest FORMS
Package

vellum.selection

Source

implementation.lisp (file)

Function: s &rest FORMS
Package

vellum.selection

Source

implementation.lisp (file)

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 (file)

Function: sparse-material-column-iterator-index INSTANCE
Function: (setf sparse-material-column-iterator-index) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: standard-transformation-row INSTANCE
Function: (setf standard-transformation-row) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: to-matrix FRAME &key ELEMENT-TYPE KEY
Package

vellum

Source

functions.lisp (file)

Function: untouch ITERATOR
Package

vellum.column

Source

implementation.lisp (file)

Function: vs &rest FORMS
Package

vellum.selection

Source

implementation.lisp (file)

Function: vstack FRAMES
Package

vellum.table

Source

functions.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: address-range SELECTOR/SEQUENCE TRANSLATE LIMIT
Package

vellum.selection

Source

implementation.lisp (file)

Methods
Method: address-range (SELECTOR/SEQUENCE sequence) TRANSLATE LIMIT
Method: address-range (SELECTOR/SEQUENCE selector) TRANSLATE LIMIT
Generic Function: alter-columns HEADER COLUMNS
Package

vellum.header

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: alter-columns TABLE &rest COLUMNS
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Generic Function: at FRAME ROW COLUMN
Generic Function: (setf at) NEW-VALUE FRAME ROW COLUMN
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: at (FRAME standard-table) (ROW integer) COLUMN
Method: (setf at) NEW-VALUE (FRAME standard-table) (ROW integer) COLUMN
Source

implementation.lisp (file)

Generic Function: augment-iterator ITERATOR COLUMN
Package

vellum.column

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: bind-row-closure BIND-ROW-OBJECT &key HEADER

Description:
Prepares passed function/nil/bind-row instance to be used. It will return functions unaltered, header optimized closure from the bind-row instance and constantly nil closure when nil is passed.

Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: bind-row-closure FN &key HEADER
Source

implementation.lisp (file)

Method: bind-row-closure (BIND-ROW (eql nil)) &key HEADER
Source

implementation.lisp (file)

Method: bind-row-closure (BIND-ROW bind-row) &key HEADER
Source

implementation.lisp (file)

Generic Function: check-column-signatures-compatibility OLD-SIGNATURE NEW-SIGNATURE
Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: check-column-signatures-compatibility (FIRST-SIGNATURE column-signature) (SECOND-SIGNATURE column-signature)
Source

implementation.lisp (file)

Generic Function: check-predicate HEADER COLUMN VALUE

Description:
Calls the column predicate on the value

Exceptional situations:
Signals NO-COLUMN when the COLUMN is not present in the current HEADER. Signals PREDICAT-FAILED when the predicate function returns nil.

Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: check-predicate (HEADER fundamental-header) COLUMN VALUE
Source

implementation.lisp (file)

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 (file)

Writer

(setf column-at) (generic function)

Methods
Method: column-at (COLUMN sparse-material-column) INDEX
Source

implementation.lisp (file)

Generic Function: (setf column-at) NEW-VALUE 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 (file)

Reader

column-at (generic function)

Methods
Method: (setf column-at) NEW-VALUE (COLUMN sparse-material-column) INDEX
Source

implementation.lisp (file)

Generic Function: column-at FRAME COLUMN
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Method: column-at (FRAME standard-table) COLUMN
Source

implementation.lisp (file)

Generic Function: column-count HEADER

Description:
How many columns header specifies?

Package

vellum.header

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: column-count FRAME
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Generic Function: column-name FRAME COLUMN
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Generic Function: column-predicate HEADER COLUMN

Description:
What is the predicate That must be fullfilled by the values stored in the COLUMN?

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

Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: column-predicate (HEADER standard-header) COLUMN
Source

implementation.lisp (file)

Generic Function: column-signature HEADER COLUMN

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

protocol.lisp (file)

Methods
Method: column-signature (HEADER standard-header) (INDEX integer)
Source

implementation.lisp (file)

Method: column-signature (HEADER standard-header) (NAME symbol)
Source

implementation.lisp (file)

Generic Function: column-size COLUMN

Description:
The total size of the COLUMN.

Package

vellum.column

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: column-specs HEADER
Package

vellum.header

Source

protocol.lisp (file)

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

implementation.lisp (file)

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 (file)

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

implementation.lisp (file)

Generic 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

protocol.lisp (file)

Methods
Method: column-type (HEADER standard-header) COLUMN
Source

implementation.lisp (file)

Generic Function: column-type FRAME COLUMN
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: column-type (FRAME standard-table) COLUMN
Source

implementation.lisp (file)

Generic Function: concatenate-headers HEADER &rest MORE-HEADERS
Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: concatenate-headers (HEADER standard-header) &rest MORE-HEADERS
Source

implementation.lisp (file)

Generic Function: content SELECTION TRANSLATE CURRENT-POSITION LIMIT
Package

vellum.selection

Source

implementation.lisp (file)

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 (file)

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 (file)

Generic Function: erase! FRAME ROW COLUMN
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: erase! (FRAME standard-table) (ROW integer) COLUMN
Source

implementation.lisp (file)

Generic Function: finish-iterator ITERATOR
Package

vellum.column

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: header FRAME
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: header (STANDARD-TABLE-RANGE standard-table-range)

automatically generated reader method

Source

types.lisp (file)

Method: header (STANDARD-TABLE standard-table)

automatically generated reader method

Source

types.lisp (file)

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 (file)

Methods
Method: hstack* (FRAME standard-table) MORE-FRAMES &key ISOLATE
Source

implementation.lisp (file)

Generic 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

protocol.lisp (file)

Methods
Method: index-to-name (HEADER standard-header) (INDEX integer)
Source

implementation.lisp (file)

Generic Function: iterator FRAME IN-PLACE
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: iterator (FRAME standard-table) IN-PLACE
Source

implementation.lisp (file)

Generic Function: join ALGORITHM METHOD FRAME-SPECS &key HEADER CLASS HEADER-CLASS COLUMNS TEST &allow-other-keys
Package

vellum

Source

generics.lisp (file)

Methods
Method: join (ALGORITHM (eql hash)) (METHOD (eql left)) (FRAME-SPECS list) &key CLASS HEADER-CLASS COLUMNS HEADER TEST
Source

functions.lisp (file)

Method: join (ALGORITHM (eql hash)) (METHOD (eql inner)) (FRAME-SPECS list) &key CLASS HEADER-CLASS COLUMNS HEADER TEST
Source

functions.lisp (file)

Method: join ALGORITHM METHOD (FRAME-SPECS list) &key &allow-other-keys before
Generic Function: make-header CLASS &rest COLUMNS

Description:
Construct the header instance of CLASS.

Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: make-header CLASS &rest COLUMNS
Source

implementation.lisp (file)

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 (file)

Methods
Method: make-iterator COLUMNS &key TRANSFORMATION
Source

implementation.lisp (file)

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 (file)

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

implementation.lisp (file)

Method: make-row RANGE DATA around
Source

implementation.lisp (file)

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

implementation.lisp (file)

Generic Function: make-table* CLASS &optional HEADER
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: make-table* (CLASS (eql standard-table)) &optional HEADER
Source

implementation.lisp (file)

Generic 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

protocol.lisp (file)

Methods
Method: name-to-index (HEADER standard-header) (NAME symbol)
Source

implementation.lisp (file)

Method: name-to-index (HEADER standard-header) (NAME string)
Source

implementation.lisp (file)

Generic Function: read-header OBJECT
Package

vellum.header

Methods
Method: read-header (FRAME-RANGE-MIXIN frame-range-mixin)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-name OBJECT
Package

vellum.header

Methods
Method: read-name (COLUMN-SIGNATURE column-signature)

automatically generated reader method

Source

types.lisp (file)

Generic Function: remove-nulls ITERATOR
Package

vellum.column

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: remove-nulls FRAME &key IN-PLACE
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: remove-nulls (FRAME standard-table) &key IN-PLACE
Source

implementation.lisp (file)

Generic Function: row-at HEADER ROW POSITION
Generic Function: (setf row-at) NEW-VALUE HEADER ROW POSITION
Package

vellum.header

Source

protocol.lisp (file)

Methods
Method: row-at (HEADER standard-header) (ROW table-row) (POSITION integer)
Source

implementation.lisp (file)

Method: row-at (HEADER standard-header) (ROW table-row) POSITION
Source

implementation.lisp (file)

Method: row-at (HEADER standard-header) (ROW table-row) (POSITION string)
Source

implementation.lisp (file)

Method: row-at (HEADER standard-header) (ROW sequence) (COLUMN string)
Method: (setf row-at) NEW-VALUE (HEADER standard-header) (ROW sequence) (COLUMN string)
Source

implementation.lisp (file)

Method: row-at (HEADER standard-header) (ROW sequence) (COLUMN symbol)
Method: (setf row-at) NEW-VALUE (HEADER standard-header) (ROW sequence) (COLUMN symbol)
Source

implementation.lisp (file)

Method: row-at (HEADER standard-header) (ROW sequence) (COLUMN integer)
Method: (setf row-at) NEW-VALUE (HEADER standard-header) (ROW sequence) (COLUMN integer)
Source

implementation.lisp (file)

Method: (setf row-at) NEW-VALUE (HEADER standard-header) (ROW setfable-table-row) (POSITION integer)
Source

implementation.lisp (file)

Method: (setf row-at) NEW-VALUE (HEADER standard-header) (ROW setfable-table-row) POSITION
Source

implementation.lisp (file)

Method: (setf row-at) NEW-VALUE (HEADER standard-header) ROW COLUMN around
Source

implementation.lisp (file)

Generic Function: row-count FRAME
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Generic Function: select FRAME &key COLUMNS ROWS

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

Package

vellum.table

Source

generics.lisp (file)

Methods
Method: select (FRAME standard-table) &key ROWS COLUMNS
Source

implementation.lisp (file)

Generic Function: select-columns HEADER COLUMNS
Package

vellum.header

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: show AS TABLE &key OUTPUT START END &allow-other-keys
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: show (AS (eql text)) (TABLE fundamental-table) &key OUTPUT START END
Source

implementation.lisp (file)

Generic Function: to-table RANGE &key BODY KEY CLASS HEADER-CLASS COLUMNS HEADER &allow-other-keys
Package

vellum.table

Source

to-table.lisp (file)

Methods
Method: to-table (RANGE summary-result-range) &key KEY HEADER-CLASS CLASS COLUMNS BODY HEADER
Source

cl-ds.lisp (file)

Method: to-table (RANGE group-by-result-range) &key KEY HEADER-CLASS CLASS COLUMNS BODY HEADER
Source

cl-ds.lisp (file)

Method: to-table (INPUT array) &key CLASS KEY HEADER-CLASS COLUMNS BODY HEADER
Method: to-table (INPUT sequence) &key KEY CLASS HEADER-CLASS COLUMNS BODY HEADER
Method: to-table (RANGE frame-range-mixin) &key CLASS BODY &allow-other-keys
Method: to-table RANGE &key KEY BODY CLASS HEADER-CLASS COLUMNS HEADER
Generic Function: transform FRAME FUNCTION &key IN-PLACE START END RESTARTS-ENABLED
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: transform (FRAME standard-table) BIND-ROW &key RESTARTS-ENABLED IN-PLACE START END
Source

implementation.lisp (file)

Generic Function: transform-row TRANSFORMATION &optional BIND-ROW-CLOSURE
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: transform-row (OBJECT standard-transformation) &optional BIND-ROW-CLOSURE
Source

implementation.lisp (file)

Generic Function: transformation FRAME BIND-ROW &key IN-PLACE START RESTARTS-ENABLED
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: transformation (FRAME standard-table) BIND-ROW &key IN-PLACE RESTARTS-ENABLED START
Source

implementation.lisp (file)

Generic Function: transformation-result TRANSFORMATION
Package

vellum.table

Source

generics.lisp (file)

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

implementation.lisp (file)

Generic Function: truncate-to-length COLUMN LENGTH
Package

vellum.column

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: visualize FORMAT DATA DESTINATION
Package

vellum

Source

generics.lisp (file)

Generic Function: vmask FRAME MASK &key IN-PLACE
Package

vellum.table

Source

generics.lisp (file)

Methods
Method: vmask (FRAME standard-table) MASK &key IN-PLACE
Source

implementation.lisp (file)

Generic Function: vstack* FRAME MORE-FRAMES

Description:
Concatenates multiple frames column-wise.

Package

vellum.table

Source

generics.lisp (file)

Methods
Method: vstack* (FRAME standard-table) MORE-FRAMES
Source

implementation.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Conditions

Condition: column-type-error ()
Package

vellum.column

Source

conditions.lisp (file)

Direct superclasses

type-error (condition)

Direct methods

column-type-error-column (method)

Direct slots
Slot: %column
Initargs

:column

Readers

column-type-error-column (generic function)

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

vellum

Source

conditions.lisp (file)

Direct superclasses
Condition: headers-incompatible ()
Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

operation-not-allowed (condition)

Direct slots
Slot: %headers
Initargs

:headers

Direct Default Initargs
InitargValue
:format-control"headers are incompatible."
Condition: invalid-input-for-row ()
Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

invalid-value (condition)

Condition: invalid-name ()
Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

invalid-value (condition)

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 (file)

Direct superclasses

invalid-value (condition)

Direct Default Initargs
InitargValue
:format-control"detected name ~a duplication."
Condition: name-when-selecting-row ()
Package

vellum.selection

Source

implementation.lisp (file)

Direct superclasses

invalid-value (condition)

Condition: no-column ()

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

Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

argument-value-not-in-allowed-set (condition)

Direct Default Initargs
InitargValue
:format-control"no 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 (file)

Direct superclasses

operation-not-allowed (condition)

Direct Default Initargs
InitargValue
:format-control"no active header."
Condition: no-transformation ()
Package

vellum.table

Source

conditions.lisp (file)

Direct superclasses

operation-not-allowed (condition)

Direct Default Initargs
InitargValue
:format-control"not performing transformation right now."
Condition: predicate-failed ()

Description:
Error signalled when trying to set the column value in row to somethining rejected by the predicate.

Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

invalid-value (condition)

Direct methods

column-number (method)

Direct slots
Slot: %column-number
Initargs

:column-number

Readers

column-number (generic function)

Direct Default Initargs
InitargValue
:format-control"predicate for ~a in the column ~a returned nil."
Condition: row-cant-be-created ()
Package

vellum

Source

conditions.lisp (file)

Direct superclasses

chainable-condition (condition)

Direct subclasses

file-input-row-cant-be-created (condition)

Condition: transformation-error ()
Package

vellum.table

Source

conditions.lisp (file)

Direct superclasses

textual-error (condition)

Direct Default Initargs
InitargValue
:format-control"error during transformation."
Condition: unable-to-construct-row ()
Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

textual-error (condition)

Direct slots
Slot: %header
Initargs

:header

Direct Default Initargs
InitargValue
:format-control"can't create row from data."

Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Classes

Class: between ()
Package

vellum.selection

Source

implementation.lisp (file)

Direct superclasses

content (class)

Direct methods
Direct slots
Slot: %from
Initargs

:from

Readers

read-from (generic function)

Slot: %to
Initargs

:to

Readers

read-to (generic function)

Direct Default Initargs
InitargValue
:fromnil
:tonil
Class: bind-row ()
Package

vellum.header

Source

types.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct methods
Direct slots
Slot: %optimized-closure
Initargs

:optimized-closure

Readers

optimized-closure (generic function)

Class: column-signature ()

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

Package

vellum.header

Source

types.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: %type
Initargs

:type

Readers

read-type (generic function)

Slot: %predicate
Initargs

:predicate

Readers

read-predicate (generic function)

Slot: %name
Initargs

:name

Readers

read-name (generic function)

Direct Default Initargs
InitargValue
:typet
:namenil
:predicate(quote vellum.header:constantly-t)
Class: content ()
Package

vellum.selection

Source

implementation.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

between (class)

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 (file)

Direct superclasses

standard-object (class)

Direct methods
  • to-table (method)
  • make-row (method)
  • make-row (method)
  • across (method)
  • traverse (method)
  • peek-front (method)
  • consume-front (method)
  • cloning-information (method)
  • read-header (method)
Direct slots
Slot: %header
Initargs

:header

Readers

read-header (generic function)

Class: fundamental-column ()
Package

vellum.column

Source

types.lisp (file)

Direct superclasses

traversable (class)

Direct subclasses

sparse-material-column (class)

Class: fundamental-header ()

Description:
Fundamental super-class of all headers.

Package

vellum.header

Source

types.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

standard-header (class)

Direct methods

check-predicate (method)

Class: fundamental-table ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

traversable (class)

Direct subclasses

standard-table (class)

Direct methods
  • show (method)
  • apply-range-function (method)
  • apply-range-function (method)
Class: setfable-table-row ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

table-row (class)

Direct methods
Class: sparse-material-column ()
Package

vellum.column

Source

types.lisp (file)

Direct superclasses
Direct methods
Class: standard-header ()

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

Package

vellum.header

Source

types.lisp (file)

Direct superclasses

fundamental-header (class)

Direct methods
Direct slots
Slot: %column-signature-class
Initargs

:column-signature-class

Initform

(quote vellum.header:column-signature)

Readers

read-column-signature-class (generic function)

Slot: %column-signatures
Initargs

:column-signatures

Readers

read-column-signatures (generic function)

Slot: %column-names
Type

hash-table

Initargs

:column-names

Readers

read-column-names (generic function)

Class: standard-table ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

fundamental-table (class)

Direct methods
Direct slots
Slot: %header
Initargs

:header

Readers

header (generic function)

Slot: %columns
Type

vector

Initargs

:columns

Readers

read-columns (generic function)

Writers

write-columns (generic function)

Class: standard-table-range ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

fundamental-forward-range (class)

Direct methods
Direct slots
Slot: %table-row
Initargs

:table-row

Readers

read-table-row (generic function)

Slot: %header
Initargs

:header

Readers
Slot: %row-count
Type

fixnum

Initargs

:row-count

Readers

read-row-count (generic function)


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

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *transform-control*
Package

vellum.table

Source

variables.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Symbol macros

Symbol Macro: mask-bytes
Package

vellum.column

Source

internal.lisp (file)

Expansion

(byte cl-data-structures.common.rrb:+maximum-children-count+ 0)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Macros

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

vellum.column

Source

internal.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Functions

Function: access-index ITERATOR
Function: (setf access-index) NEW-VALUE ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: build-new-mask OLD-BITMASK MISSING-MASK
Package

vellum.column

Source

internal.lisp (file)

Function: calculate-depth INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: cartesian-product VECTOR
Package

vellum

Source

functions.lisp (file)

Function: change-leaf ITERATOR DEPTH STACK COLUMN CHANGE BUFFER
Package

vellum.column

Source

internal.lisp (file)

Function: change-leafs ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: child-index PARENT-INDEX CHILD-POSITION
Package

vellum.column

Source

internal.lisp (file)

Function: children NODES
Package

vellum.column

Source

internal.lisp (file)

Function: clear-buffers ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: clear-changed-parents-masks STATE
Package

vellum.column

Source

internal.lisp (file)

Function: clear-changes ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: clear-masks STATE
Package

vellum.column

Source

internal.lisp (file)

Function: collect-column-specs FRAME-SPECS
Package

vellum

Source

functions.lisp (file)

Function: column-root COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: column-transformation-closure IN-PLACE
Package

vellum.table

Source

internal.lisp (file)

Function: common-to-table RANGE KEY CLASS HEADER BODY
Package

vellum.integration

Source

cl-ds.lisp (file)

Function: concatenate-masks STATE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenate-trees ITERATOR &aux COLUMNS
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state ITERATOR COLUMNS NODES PARENTS
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-changed-parents INSTANCE
Function: (setf concatenation-state-changed-parents) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-columns INSTANCE
Function: (setf concatenation-state-columns) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-iterator INSTANCE
Function: (setf concatenation-state-iterator) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-masks INSTANCE
Function: (setf concatenation-state-masks) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-masks-logcount STATE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-max-index INSTANCE
Function: (setf concatenation-state-max-index) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-nodes INSTANCE
Function: (setf concatenation-state-nodes) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-nodes-logcount STATE
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-p OBJECT
Package

vellum.column

Source

internal.lisp (file)

Function: concatenation-state-parents INSTANCE
Function: (setf concatenation-state-parents) VALUE INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: copy-concatenation-state INSTANCE
Package

vellum.column

Source

internal.lisp (file)

Function: copy-on-write-node ITERATOR PARENT CHILD POSITION TAG COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: copy-sparse-material-column-iterator INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: copy-standard-transformation INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: distinct-missing REAL-MASK LOGIOR-MASK
Package

vellum.column

Source

internal.lisp (file)

Function: ensure-column-initialization ITERATOR COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: ensure-replicas COLUMNS NEW-COLUMNS &optional ISOLATE
Package

vellum.table

Source

internal.lisp (file)

Function: extracting-signature HEADER
Package

vellum.header

Source

internal.lisp (file)

Function: fill-buffer DEPTH BUFFER STACK
Package

vellum.column

Source

internal.lisp (file)

Function: fill-buffers ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: find-max-index NODES
Package

vellum.column

Source

internal.lisp (file)

Function: free-space STATE INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: gather-masks NODES &optional RESULT
Package

vellum.column

Source

internal.lisp (file)

Function: hash-join-implementation FRAME-SPECS HEADER CLASS TEST FUNCTION
Package

vellum

Source

functions.lisp (file)

Function: index-promoted OLD-INDEX NEW-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: initialize-iterator-column ITERATOR INDEX COLUMN STACK BUFFER SHIFT TOUCHED COLUMN-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: initialize-iterator-columns ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: insert-tail COLUMN
Package

vellum.table

Source

internal.lisp (file)

Function: into-vector-copy ELEMENT VECTOR
Package

vellum.column

Source

implementation.lisp (file)

Function: logior-mask STATE INDEX MASK
Package

vellum.column

Source

internal.lisp (file)

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.header

Source

functions.lisp (file)

Function: make-concatenation-state &key (ITERATOR ITERATOR) (CHANGED-PARENTS CHANGED-PARENTS) (MASKS MASKS) (MAX-INDEX MAX-INDEX) (NODES NODES) (PARENTS PARENTS) (COLUMNS COLUMNS)
Package

vellum.column

Source

internal.lisp (file)

Function: make-iterator COLUMNS &key TRANSFORMATION
Package

vellum.table

Source

internal.lisp (file)

Function: make-leaf ITERATOR COLUMN OLD-NODE CHANGE BUFFER
Package

vellum.column

Source

internal.lisp (file)

Function: make-node ITERATOR COLUMN BITMASK &key TYPE LENGTH CONTENT TAG
Package

vellum.column

Source

internal.lisp (file)

Function: make-signature SIGNATURE-CLASS C
Package

vellum.header

Source

internal.lisp (file)

Function: make-sparse-material-column-iterator &key (INITIALIZATION-STATUS INITIALIZATION-STATUS) (TRANSFORMATION TRANSFORMATION) (COLUMNS COLUMNS) (STACKS STACKS) (DEPTHS DEPTHS) (INDEX INDEX) (INDEXES INDEXES) (INITIAL-INDEX INITIAL-INDEX) (TOUCHED TOUCHED) (BUFFERS BUFFERS) (CHANGES CHANGES)
Package

vellum.column

Source

types.lisp (file)

Function: make-sparse-material-column-range COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: make-standard-transformation &key (DROPPED DROPPED) (MARKER-COLUMN MARKER-COLUMN) (TABLE TABLE) (RESTARTS-ENABLED RESTARTS-ENABLED) (IN-PLACE IN-PLACE) (START START) (ROW ROW) (ITERATOR ITERATOR) (COLUMNS COLUMNS) (COLUMN-COUNT COLUMN-COUNT) (COUNT COUNT) (BIND-ROW-CLOSURE BIND-ROW-CLOSURE)
Package

vellum.table

Source

types.lisp (file)

Function: mask STATE INDEX
Function: (setf mask) MASK STATE INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: max-index NODES
Package

vellum.column

Source

internal.lisp (file)

Function: move-children STATE FROM TO
Package

vellum.column

Source

internal.lisp (file)

Function: move-children-in-column STATE FROM TO FROM-MASK TO-MASK COLUMN-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: move-children-in-columns STATE FROM TO FROM-MASK TO-MASK
Package

vellum.column

Source

internal.lisp (file)

Function: move-column-to ITERATOR NEW-INDEX COLUMN-INDEX &key FORCE-INITIALIZATION DEPTH
Package

vellum.column

Source

internal.lisp (file)

Function: move-stack DEPTH NEW-INDEX STACK &aux NODE
Package

vellum.column

Source

internal.lisp (file)

Function: move-to-existing-column STATE FROM TO FROM-MASK TO-MASK COLUMN-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: move/pad-stack ITERATOR INDEX NEW-INDEX DEPTH NEW-DEPTH STACK COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: mutate-leaf COLUMN OLD-NODE CHANGE BUFFER
Package

vellum.column

Source

internal.lisp (file)

Function: node STATE COLUMN INDEX
Function: (setf node) NEW-VALUE STATE COLUMN INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: occupied-space STATE INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: offset INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: pad-stack ITERATOR DEPTH INDEX NEW-DEPTH STACK COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: parent-changed STATE COLUMN PARENT-INDEX
Function: (setf parent-changed) NEW-VALUE STATE COLUMN PARENT-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: parent-index CHILD-INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: range-iterator RANGE POSITION
Package

vellum.column

Source

internal.lisp (file)

Function: read-buffers ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-changes ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-columns ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-depths ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-indexes ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-initial-index ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-initialization-status ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-stacks ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-touched ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: read-transformation ITERATOR
Package

vellum.column

Source

types.lisp (file)

Function: reduce-stack ITERATOR INDEX DEPTH STACK COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: reduce-stacks ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: remove-nulls-from-columns COLUMNS &optional TRANSFORM
Package

vellum.table

Source

internal.lisp (file)

Function: select-columns FRAME SELECTION
Package

vellum.table

Source

internal.lisp (file)

Function: select-rows FRAME SELECTION
Package

vellum.table

Source

internal.lisp (file)

Function: shift-content STATE
Package

vellum.column

Source

internal.lisp (file)

Function: sparse-material-column-at COLUMN INDEX
Function: (setf sparse-material-column-at) NEW-VALUE COLUMN INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: sparse-material-column-iterator-buffers INSTANCE
Function: (setf sparse-material-column-iterator-buffers) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-changes INSTANCE
Function: (setf sparse-material-column-iterator-changes) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-columns INSTANCE
Function: (setf sparse-material-column-iterator-columns) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-depths INSTANCE
Function: (setf sparse-material-column-iterator-depths) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-indexes INSTANCE
Function: (setf sparse-material-column-iterator-indexes) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-initial-index INSTANCE
Function: (setf sparse-material-column-iterator-initial-index) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-initialization-status INSTANCE
Function: (setf sparse-material-column-iterator-initialization-status) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-p OBJECT
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-stacks INSTANCE
Function: (setf sparse-material-column-iterator-stacks) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-touched INSTANCE
Function: (setf sparse-material-column-iterator-touched) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: sparse-material-column-iterator-transformation INSTANCE
Function: (setf sparse-material-column-iterator-transformation) VALUE INSTANCE
Package

vellum.column

Source

types.lisp (file)

Function: standard-transformation-bind-row-closure INSTANCE
Function: (setf standard-transformation-bind-row-closure) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-column-count INSTANCE
Function: (setf standard-transformation-column-count) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-columns INSTANCE
Function: (setf standard-transformation-columns) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-count INSTANCE
Function: (setf standard-transformation-count) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-dropped INSTANCE
Function: (setf standard-transformation-dropped) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-in-place INSTANCE
Function: (setf standard-transformation-in-place) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-iterator INSTANCE
Function: (setf standard-transformation-iterator) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-marker-column INSTANCE
Function: (setf standard-transformation-marker-column) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-p OBJECT
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-restarts-enabled INSTANCE
Function: (setf standard-transformation-restarts-enabled) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-start INSTANCE
Function: (setf standard-transformation-start) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: standard-transformation-table INSTANCE
Function: (setf standard-transformation-table) VALUE INSTANCE
Package

vellum.table

Source

types.lisp (file)

Function: table-from-header CLASS HEADER
Package

vellum.table

Source

internal.lisp (file)

Function: transform-row-impl TRANSFORMATION &optional FUNCTION
Package

vellum.table

Source

internal.lisp (file)

Function: tree-index INDEX
Package

vellum.column

Source

internal.lisp (file)

Function: trim-depth ITERATOR
Package

vellum.column

Source

internal.lisp (file)

Function: trim-depth-in-column COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: truncate-mask MASK
Package

vellum.column

Source

internal.lisp (file)

Function: unique-names HEADERS
Package

vellum.header

Source

internal.lisp (file)

Function: update-parents STATE COLUMN
Package

vellum.column

Source

internal.lisp (file)

Function: validate-active-header ()

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

Package

vellum.header

Source

functions.lisp (file)

Function: validate-active-row ()
Package

vellum.header

Source

functions.lisp (file)

Function: validate-row ROW DATA
Package

vellum.header

Source

implementation.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Generic functions

Generic Function: access-iterator OBJECT
Generic Function: (setf access-iterator) NEW-VALUE OBJECT
Package

vellum.column

Methods
Method: access-iterator (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated reader method

Source

internal.lisp (file)

Method: (setf access-iterator) NEW-VALUE (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated writer method

Source

internal.lisp (file)

Generic Function: access-position OBJECT
Generic Function: (setf access-position) NEW-VALUE OBJECT
Package

vellum.column

Methods
Method: access-position (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated reader method

Source

internal.lisp (file)

Method: (setf access-position) NEW-VALUE (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated writer method

Source

internal.lisp (file)

Generic Function: column-number CONDITION
Package

vellum.header

Methods
Method: column-number (CONDITION predicate-failed)
Source

conditions.lisp (file)

Generic Function: column-signature-spec COLUMN-SIGNATURE
Package

vellum.header

Source

protocol.lisp (file)

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

implementation.lisp (file)

Generic Function: column-type-error-column CONDITION
Package

vellum.column

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

conditions.lisp (file)

Method: column-type-error-column (CONDITION column-type-error)
Source

conditions.lisp (file)

Generic Function: fill-columns-buffer-impl RANGE POSITION BUFFER FINISH-CALLBACK KEY
Package

vellum.integration

Source

cl-ds.lisp (file)

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 (file)

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 (file)

Generic Function: make-value HEADER SOURCE INDEX
Package

vellum.header

Source

protocol.lisp (file)

Generic Function: optimized-closure OBJECT
Package

vellum.header

Methods
Method: optimized-closure (BIND-ROW bind-row)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-callback OBJECT
Package

vellum.selection

Methods
Method: read-callback (SELECTOR selector)

automatically generated reader method

Source

implementation.lisp (file)

Generic Function: read-column OBJECT
Package

vellum.column

Methods
Method: read-column (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated reader method

Source

internal.lisp (file)

Generic Function: read-column-names OBJECT
Package

vellum.header

Methods
Method: read-column-names (STANDARD-HEADER standard-header)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-column-signature-class OBJECT
Package

vellum.header

Methods
Method: read-column-signature-class (STANDARD-HEADER standard-header)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-column-signatures OBJECT
Package

vellum.header

Methods
Method: read-column-signatures (STANDARD-HEADER standard-header)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-columns OBJECT
Package

vellum.table

Methods
Method: read-columns (STANDARD-TABLE standard-table)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-from OBJECT
Package

vellum.selection

Methods
Method: read-from (BETWEEN between)

automatically generated reader method

Source

implementation.lisp (file)

Generic Function: read-header OBJECT
Package

vellum.table

Methods
Method: read-header (STANDARD-TABLE-RANGE standard-table-range)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-initial-position OBJECT
Package

vellum.column

Methods
Method: read-initial-position (SPARSE-MATERIAL-COLUMN-RANGE sparse-material-column-range)

automatically generated reader method

Source

internal.lisp (file)

Generic Function: read-iterator OBJECT
Package

vellum.table

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

implementation.lisp (file)

Method: read-iterator (TABLE-ROW table-row)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-predicate OBJECT
Package

vellum.header

Methods
Method: read-predicate (COLUMN-SIGNATURE column-signature)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-row-count OBJECT
Package

vellum.table

Methods
Method: read-row-count (STANDARD-TABLE-RANGE standard-table-range)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-table-row OBJECT
Package

vellum.table

Methods
Method: read-table-row (STANDARD-TABLE-RANGE standard-table-range)

automatically generated reader method

Source

types.lisp (file)

Generic Function: read-to OBJECT
Package

vellum.selection

Methods
Method: read-to (BETWEEN between)

automatically generated reader method

Source

implementation.lisp (file)

Generic Function: read-type OBJECT
Package

vellum.header

Methods
Method: read-type (COLUMN-SIGNATURE column-signature)

automatically generated reader method

Source

types.lisp (file)

Generic Function: row-erase ROW
Package

vellum.table

Source

generics.lisp (file)

Generic Function: write-columns NEW-VALUE OBJECT
Package

vellum.table

Methods
Method: write-columns NEW-VALUE (STANDARD-TABLE standard-table)

automatically generated writer method

Source

types.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Conditions

Condition: column-error ()
Package

vellum.column

Source

conditions.lisp (file)

Direct superclasses

program-error (condition)

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

vellum.column

Source

conditions.lisp (file)

Direct superclasses
  • argument-value-out-of-bounds (condition)
  • column-error (condition)
Condition: iterator-error ()
Package

vellum.column

Source

conditions.lisp (file)

Direct superclasses

program-error (condition)

Condition: no-row ()

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

Package

vellum.header

Source

conditions.lisp (file)

Direct superclasses

operation-not-allowed (condition)

Direct Default Initargs
InitargValue
:format-control"no active row."
Condition: no-such-column ()
Package

vellum.column

Source

conditions.lisp (file)

Direct superclasses
  • argument-value-out-of-bounds (condition)
  • column-error (condition)
Condition: setting-to-null ()
Package

vellum.column

Source

conditions.lisp (file)

Direct superclasses
Direct methods

column-type-error-column (method)

Direct slots
Slot: %column
Initargs

:column

Readers

column-type-error-column (generic function)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.7 Structures

Structure: concatenation-state ()
Package

vellum.column

Source

internal.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: iterator
Readers

concatenation-state-iterator (function)

Writers

(setf concatenation-state-iterator) (function)

Slot: changed-parents
Type

vector

Initform

#()

Readers

concatenation-state-changed-parents (function)

Writers

(setf concatenation-state-changed-parents) (function)

Slot: masks
Type

hash-table

Initform

(make-hash-table)

Readers

concatenation-state-masks (function)

Writers

(setf concatenation-state-masks) (function)

Slot: max-index
Type

alexandria:non-negative-fixnum

Initform

0

Readers

concatenation-state-max-index (function)

Writers

(setf concatenation-state-max-index) (function)

Slot: nodes
Type

vector

Initform

#()

Readers

concatenation-state-nodes (function)

Writers

(setf concatenation-state-nodes) (function)

Slot: parents
Type

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

Readers

concatenation-state-parents (function)

Writers

(setf concatenation-state-parents) (function)

Slot: columns
Type

simple-vector

Initform

#()

Readers

concatenation-state-columns (function)

Writers

(setf concatenation-state-columns) (function)

Structure: sparse-material-column-iterator ()
Package

vellum.column

Source

types.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: initialization-status
Type

(simple-array boolean (*))

Initform

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

Readers

sparse-material-column-iterator-initialization-status (function)

Writers

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

Slot: transformation
Readers

sparse-material-column-iterator-transformation (function)

Writers

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

Slot: columns
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-columns (function)

Writers

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

Slot: stacks
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-stacks (function)

Writers

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

Slot: depths
Type

(simple-array fixnum (*))

Initform

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

Readers

sparse-material-column-iterator-depths (function)

Writers

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

Slot: index
Type

fixnum

Initform

0

Readers

sparse-material-column-iterator-index (function)

Writers

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

Slot: indexes
Type

(simple-array fixnum (*))

Initform

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

Readers

sparse-material-column-iterator-indexes (function)

Writers

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

Slot: initial-index
Type

fixnum

Initform

0

Readers

sparse-material-column-iterator-initial-index (function)

Writers

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

Slot: touched
Type

(simple-array boolean (*))

Initform

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

Readers

sparse-material-column-iterator-touched (function)

Writers

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

Slot: buffers
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-buffers (function)

Writers

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

Slot: changes
Type

simple-vector

Initform

#()

Readers

sparse-material-column-iterator-changes (function)

Writers

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

Structure: standard-transformation ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: dropped
Type

boolean

Readers

standard-transformation-dropped (function)

Writers

(setf standard-transformation-dropped) (function)

Slot: marker-column
Readers

standard-transformation-marker-column (function)

Writers

(setf standard-transformation-marker-column) (function)

Slot: table
Readers

standard-transformation-table (function)

Writers

(setf standard-transformation-table) (function)

Slot: restarts-enabled
Type

boolean

Initform

t

Readers

standard-transformation-restarts-enabled (function)

Writers

(setf standard-transformation-restarts-enabled) (function)

Slot: in-place
Type

boolean

Readers

standard-transformation-in-place (function)

Writers

(setf standard-transformation-in-place) (function)

Slot: start
Type

integer

Initform

0

Readers

standard-transformation-start (function)

Writers

(setf standard-transformation-start) (function)

Slot: row
Readers

standard-transformation-row (function)

Writers

(setf standard-transformation-row) (function)

Slot: iterator
Readers

standard-transformation-iterator (function)

Writers

(setf standard-transformation-iterator) (function)

Slot: columns
Type

simple-vector

Initform

#()

Readers

standard-transformation-columns (function)

Writers

(setf standard-transformation-columns) (function)

Slot: column-count
Type

fixnum

Initform

0

Readers

standard-transformation-column-count (function)

Writers

(setf standard-transformation-column-count) (function)

Slot: count
Type

fixnum

Initform

0

Readers

standard-transformation-count (function)

Writers

(setf standard-transformation-count) (function)

Slot: bind-row-closure
Readers

standard-transformation-bind-row-closure (function)

Writers

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


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.8 Classes

Class: selector ()
Package

vellum.selection

Source

implementation.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: %callback
Initargs

:callback

Readers

read-callback (generic function)

Class: sparse-material-column-range ()
Package

vellum.column

Source

internal.lisp (file)

Direct superclasses

fundamental-forward-range (class)

Direct methods
Direct slots
Slot: %iterator
Initargs

:iterator

Readers

access-iterator (generic function)

Writers

(setf access-iterator) (generic function)

Slot: %column
Initargs

:column

Readers

read-column (generic function)

Slot: %position
Initargs

:position

Readers

access-position (generic function)

Writers

(setf access-position) (generic function)

Slot: %initial-position
Initargs

:position

Readers

read-initial-position (generic function)

Class: table-row ()
Package

vellum.table

Source

types.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

setfable-table-row (class)

Direct methods
Direct slots
Slot: %iterator
Initargs

:iterator

Readers

read-iterator (generic function)

Class: to-table-function ()
Package

vellum.table

Source

to-table.lisp (file)

Direct superclasses

aggregation-function (class)

Direct methods
  • aggregator-constructor (method)
  • aggregator-constructor (method)

Previous: , Up: Internal definitions   [Contents][Index]

6.2.9 Types

Type: iterator-buffer ()
Package

vellum.column

Source

types.lisp (file)

Type: iterator-change ()
Package

vellum.column

Source

types.lisp (file)

Type: iterator-stack ()
Package

vellum.column

Source

types.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M   V  
Index Entry  Section

F
File, Lisp, vellum.asd: The vellum․asd file
File, Lisp, vellum/api/conditions.lisp: The vellum/api/conditions․lisp file
File, Lisp, vellum/api/functions.lisp: The vellum/api/functions․lisp file
File, Lisp, vellum/api/generics.lisp: The vellum/api/generics․lisp file
File, Lisp, vellum/api/macros.lisp: The vellum/api/macros․lisp file
File, Lisp, vellum/api/package.lisp: The vellum/api/package․lisp file
File, Lisp, vellum/aux-package.lisp: The vellum/aux-package․lisp file
File, Lisp, vellum/column/conditions.lisp: The vellum/column/conditions․lisp file
File, Lisp, vellum/column/docstring.lisp: The vellum/column/docstring․lisp file
File, Lisp, vellum/column/implementation.lisp: The vellum/column/implementation․lisp file
File, Lisp, vellum/column/internal.lisp: The vellum/column/internal․lisp file
File, Lisp, vellum/column/package.lisp: The vellum/column/package․lisp file
File, Lisp, vellum/column/protocol.lisp: The vellum/column/protocol․lisp file
File, Lisp, vellum/column/types.lisp: The vellum/column/types․lisp file
File, Lisp, vellum/header/conditions.lisp: The vellum/header/conditions․lisp file
File, Lisp, vellum/header/documentation.lisp: The vellum/header/documentation․lisp file
File, Lisp, vellum/header/functions.lisp: The vellum/header/functions․lisp file
File, Lisp, vellum/header/implementation.lisp: The vellum/header/implementation․lisp file
File, Lisp, vellum/header/internal.lisp: The vellum/header/internal․lisp file
File, Lisp, vellum/header/macros.lisp: The vellum/header/macros․lisp file
File, Lisp, vellum/header/package.lisp: The vellum/header/package․lisp file
File, Lisp, vellum/header/protocol.lisp: The vellum/header/protocol․lisp file
File, Lisp, vellum/header/types.lisp: The vellum/header/types․lisp file
File, Lisp, vellum/header/utils.lisp: The vellum/header/utils․lisp file
File, Lisp, vellum/header/variables.lisp: The vellum/header/variables․lisp file
File, Lisp, vellum/integration/cl-ds.lisp: The vellum/integration/cl-ds․lisp file
File, Lisp, vellum/integration/package.lisp: The vellum/integration/package․lisp file
File, Lisp, vellum/selection/implementation.lisp: The vellum/selection/implementation․lisp file
File, Lisp, vellum/selection/package.lisp: The vellum/selection/package․lisp file
File, Lisp, vellum/table/conditions.lisp: The vellum/table/conditions․lisp file
File, Lisp, vellum/table/documentation.lisp: The vellum/table/documentation․lisp file
File, Lisp, vellum/table/functions.lisp: The vellum/table/functions․lisp file
File, Lisp, vellum/table/generics.lisp: The vellum/table/generics․lisp file
File, Lisp, vellum/table/implementation.lisp: The vellum/table/implementation․lisp file
File, Lisp, vellum/table/internal.lisp: The vellum/table/internal․lisp file
File, Lisp, vellum/table/macros.lisp: The vellum/table/macros․lisp file
File, Lisp, vellum/table/package.lisp: The vellum/table/package․lisp file
File, Lisp, vellum/table/to-table.lisp: The vellum/table/to-table․lisp file
File, Lisp, vellum/table/types.lisp: The vellum/table/types․lisp file
File, Lisp, vellum/table/variables.lisp: The vellum/table/variables․lisp file

L
Lisp File, vellum.asd: The vellum․asd file
Lisp File, vellum/api/conditions.lisp: The vellum/api/conditions․lisp file
Lisp File, vellum/api/functions.lisp: The vellum/api/functions․lisp file
Lisp File, vellum/api/generics.lisp: The vellum/api/generics․lisp file
Lisp File, vellum/api/macros.lisp: The vellum/api/macros․lisp file
Lisp File, vellum/api/package.lisp: The vellum/api/package․lisp file
Lisp File, vellum/aux-package.lisp: The vellum/aux-package․lisp file
Lisp File, vellum/column/conditions.lisp: The vellum/column/conditions․lisp file
Lisp File, vellum/column/docstring.lisp: The vellum/column/docstring․lisp file
Lisp File, vellum/column/implementation.lisp: The vellum/column/implementation․lisp file
Lisp File, vellum/column/internal.lisp: The vellum/column/internal․lisp file
Lisp File, vellum/column/package.lisp: The vellum/column/package․lisp file
Lisp File, vellum/column/protocol.lisp: The vellum/column/protocol․lisp file
Lisp File, vellum/column/types.lisp: The vellum/column/types․lisp file
Lisp File, vellum/header/conditions.lisp: The vellum/header/conditions․lisp file
Lisp File, vellum/header/documentation.lisp: The vellum/header/documentation․lisp file
Lisp File, vellum/header/functions.lisp: The vellum/header/functions․lisp file
Lisp File, vellum/header/implementation.lisp: The vellum/header/implementation․lisp file
Lisp File, vellum/header/internal.lisp: The vellum/header/internal․lisp file
Lisp File, vellum/header/macros.lisp: The vellum/header/macros․lisp file
Lisp File, vellum/header/package.lisp: The vellum/header/package․lisp file
Lisp File, vellum/header/protocol.lisp: The vellum/header/protocol․lisp file
Lisp File, vellum/header/types.lisp: The vellum/header/types․lisp file
Lisp File, vellum/header/utils.lisp: The vellum/header/utils․lisp file
Lisp File, vellum/header/variables.lisp: The vellum/header/variables․lisp file
Lisp File, vellum/integration/cl-ds.lisp: The vellum/integration/cl-ds․lisp file
Lisp File, vellum/integration/package.lisp: The vellum/integration/package․lisp file
Lisp File, vellum/selection/implementation.lisp: The vellum/selection/implementation․lisp file
Lisp File, vellum/selection/package.lisp: The vellum/selection/package․lisp file
Lisp File, vellum/table/conditions.lisp: The vellum/table/conditions․lisp file
Lisp File, vellum/table/documentation.lisp: The vellum/table/documentation․lisp file
Lisp File, vellum/table/functions.lisp: The vellum/table/functions․lisp file
Lisp File, vellum/table/generics.lisp: The vellum/table/generics․lisp file
Lisp File, vellum/table/implementation.lisp: The vellum/table/implementation․lisp file
Lisp File, vellum/table/internal.lisp: The vellum/table/internal․lisp file
Lisp File, vellum/table/macros.lisp: The vellum/table/macros․lisp file
Lisp File, vellum/table/package.lisp: The vellum/table/package․lisp file
Lisp File, vellum/table/to-table.lisp: The vellum/table/to-table․lisp file
Lisp File, vellum/table/types.lisp: The vellum/table/types․lisp file
Lisp File, vellum/table/variables.lisp: The vellum/table/variables․lisp file

M
Module, vellum/api: The vellum/api module
Module, vellum/column: The vellum/column module
Module, vellum/header: The vellum/header module
Module, vellum/integration: The vellum/integration module
Module, vellum/selection: The vellum/selection module
Module, vellum/table: The vellum/table module

V
vellum.asd: The vellum․asd file
vellum/api: The vellum/api module
vellum/api/conditions.lisp: The vellum/api/conditions․lisp file
vellum/api/functions.lisp: The vellum/api/functions․lisp file
vellum/api/generics.lisp: The vellum/api/generics․lisp file
vellum/api/macros.lisp: The vellum/api/macros․lisp file
vellum/api/package.lisp: The vellum/api/package․lisp file
vellum/aux-package.lisp: The vellum/aux-package․lisp file
vellum/column: The vellum/column module
vellum/column/conditions.lisp: The vellum/column/conditions․lisp file
vellum/column/docstring.lisp: The vellum/column/docstring․lisp file
vellum/column/implementation.lisp: The vellum/column/implementation․lisp file
vellum/column/internal.lisp: The vellum/column/internal․lisp file
vellum/column/package.lisp: The vellum/column/package․lisp file
vellum/column/protocol.lisp: The vellum/column/protocol․lisp file
vellum/column/types.lisp: The vellum/column/types․lisp file
vellum/header: The vellum/header module
vellum/header/conditions.lisp: The vellum/header/conditions․lisp file
vellum/header/documentation.lisp: The vellum/header/documentation․lisp file
vellum/header/functions.lisp: The vellum/header/functions․lisp file
vellum/header/implementation.lisp: The vellum/header/implementation․lisp file
vellum/header/internal.lisp: The vellum/header/internal․lisp file
vellum/header/macros.lisp: The vellum/header/macros․lisp file
vellum/header/package.lisp: The vellum/header/package․lisp file
vellum/header/protocol.lisp: The vellum/header/protocol․lisp file
vellum/header/types.lisp: The vellum/header/types․lisp file
vellum/header/utils.lisp: The vellum/header/utils․lisp file
vellum/header/variables.lisp: The vellum/header/variables․lisp file
vellum/integration: The vellum/integration module
vellum/integration/cl-ds.lisp: The vellum/integration/cl-ds․lisp file
vellum/integration/package.lisp: The vellum/integration/package․lisp file
vellum/selection: The vellum/selection module
vellum/selection/implementation.lisp: The vellum/selection/implementation․lisp file
vellum/selection/package.lisp: The vellum/selection/package․lisp file
vellum/table: The vellum/table module
vellum/table/conditions.lisp: The vellum/table/conditions․lisp file
vellum/table/documentation.lisp: The vellum/table/documentation․lisp file
vellum/table/functions.lisp: The vellum/table/functions․lisp file
vellum/table/generics.lisp: The vellum/table/generics․lisp file
vellum/table/implementation.lisp: The vellum/table/implementation․lisp file
vellum/table/internal.lisp: The vellum/table/internal․lisp file
vellum/table/macros.lisp: The vellum/table/macros․lisp file
vellum/table/package.lisp: The vellum/table/package․lisp file
vellum/table/to-table.lisp: The vellum/table/to-table․lisp file
vellum/table/types.lisp: The vellum/table/types․lisp file
vellum/table/variables.lisp: The vellum/table/variables․lisp file

Jump to:   F   L   M   V  

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: Exported functions
%aggregate-rows: Exported functions

(
(setf access-index): Internal functions
(setf access-iterator): Internal generic functions
(setf access-iterator): Internal generic functions
(setf access-position): Internal generic functions
(setf access-position): Internal generic functions
(setf at): Exported generic functions
(setf at): Exported generic functions
(setf column-at): Exported generic functions
(setf column-at): Exported generic functions
(setf concatenation-state-changed-parents): Internal functions
(setf concatenation-state-columns): Internal functions
(setf concatenation-state-iterator): Internal functions
(setf concatenation-state-masks): Internal functions
(setf concatenation-state-max-index): Internal functions
(setf concatenation-state-nodes): Internal functions
(setf concatenation-state-parents): Internal functions
(setf iterator-at): Exported functions
(setf mask): Internal functions
(setf node): Internal functions
(setf parent-changed): Internal functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf row-at): Exported generic functions
(setf rr): Exported functions
(setf sparse-material-column-at): Internal functions
(setf sparse-material-column-iterator-buffers): Internal functions
(setf sparse-material-column-iterator-changes): Internal functions
(setf sparse-material-column-iterator-columns): Internal functions
(setf sparse-material-column-iterator-depths): Internal functions
(setf sparse-material-column-iterator-index): Exported functions
(setf sparse-material-column-iterator-indexes): Internal functions
(setf sparse-material-column-iterator-initial-index): Internal functions
(setf sparse-material-column-iterator-initialization-status): Internal functions
(setf sparse-material-column-iterator-stacks): Internal functions
(setf sparse-material-column-iterator-touched): Internal functions
(setf sparse-material-column-iterator-transformation): Internal functions
(setf standard-transformation-bind-row-closure): Internal functions
(setf standard-transformation-column-count): Internal functions
(setf standard-transformation-columns): Internal functions
(setf standard-transformation-count): Internal functions
(setf standard-transformation-dropped): Internal functions
(setf standard-transformation-in-place): Internal functions
(setf standard-transformation-iterator): Internal functions
(setf standard-transformation-marker-column): Internal functions
(setf standard-transformation-restarts-enabled): Internal functions
(setf standard-transformation-row): Exported functions
(setf standard-transformation-start): Internal functions
(setf standard-transformation-table): Internal functions

A
access-index: Internal functions
access-iterator: Internal generic functions
access-iterator: Internal generic functions
access-position: Internal generic functions
access-position: Internal generic functions
add-columns: Exported functions
address-range: Exported generic functions
address-range: Exported generic functions
address-range: Exported generic functions
aggregate-columns: Exported macros
aggregate-rows: Exported macros
alter-columns: Exported generic functions
alter-columns: Exported generic functions
alter-columns: Exported generic functions
alter-columns: Exported generic functions
at: Exported generic functions
at: Exported generic functions
augment-iterator: Exported generic functions
augment-iterator: Exported generic functions

B
between: Exported functions
bind-row: Exported macros
bind-row-closure: Exported generic functions
bind-row-closure: Exported generic functions
bind-row-closure: Exported generic functions
bind-row-closure: Exported generic functions
brr: Exported macros
build-new-mask: Internal functions

C
calculate-depth: Internal functions
cartesian-product: Internal functions
change-leaf: Internal functions
change-leafs: Internal functions
check-column-signatures-compatibility: Exported generic functions
check-column-signatures-compatibility: Exported generic functions
check-predicate: Exported generic functions
check-predicate: Exported generic functions
child-index: Internal functions
children: Internal functions
clear-buffers: Internal functions
clear-changed-parents-masks: Internal functions
clear-changes: Internal functions
clear-masks: Internal functions
collect-column-specs: Internal functions
column-at: Exported generic functions
column-at: Exported generic functions
column-at: Exported generic functions
column-at: Exported generic functions
column-at: Exported generic functions
column-count: Exported generic functions
column-count: Exported generic functions
column-count: Exported generic functions
column-count: Exported generic functions
column-name: Exported generic functions
column-name: Exported generic functions
column-names: Exported functions
column-names: Exported functions
column-number: Internal generic functions
column-number: Internal generic functions
column-predicate: Exported generic functions
column-predicate: Exported generic functions
column-root: Internal functions
column-signature: Exported generic functions
column-signature: Exported generic functions
column-signature: Exported generic functions
column-signature-spec: Internal generic functions
column-signature-spec: Internal generic functions
column-size: Exported generic functions
column-size: Exported generic functions
column-specs: Exported generic functions
column-specs: Exported generic functions
column-transformation-closure: Internal functions
column-type: Exported generic functions
column-type: Exported generic functions
column-type: Exported generic functions
column-type: Exported generic functions
column-type: Exported generic functions
column-type: Exported generic functions
column-type-error-column: Internal generic functions
column-type-error-column: Internal generic functions
column-type-error-column: Internal generic functions
columns: Exported functions
common-to-table: Internal functions
concatenate-headers: Exported generic functions
concatenate-headers: Exported generic functions
concatenate-masks: Internal functions
concatenate-trees: Internal functions
concatenation-state: Internal functions
concatenation-state-changed-parents: Internal functions
concatenation-state-columns: Internal functions
concatenation-state-iterator: Internal functions
concatenation-state-masks: Internal functions
concatenation-state-masks-logcount: Internal functions
concatenation-state-max-index: Internal functions
concatenation-state-nodes: Internal functions
concatenation-state-nodes-logcount: Internal functions
concatenation-state-p: Internal functions
concatenation-state-parents: Internal functions
constantly-t: Exported functions
content: Exported generic functions
content: Exported generic functions
copy-concatenation-state: Internal functions
copy-from: Exported generic functions
copy-from: Exported generic functions
copy-on-write-node: Internal functions
copy-sparse-material-column-iterator: Internal functions
copy-standard-transformation: Internal functions
copy-to: Exported generic functions
current-row-as-vector: Exported functions

D
distinct-missing: Internal functions
drop-row: Exported functions

E
empty-column: Exported functions
ensure-column-initialization: Internal functions
ensure-index: Exported functions
ensure-replicas: Internal functions
erase!: Exported generic functions
erase!: Exported generic functions
extracting-signature: Internal functions

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

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

H
hash-join-implementation: Internal functions
header: Exported functions
header: Exported generic functions
header: Exported generic functions
header: Exported generic functions
hstack: Exported functions
hstack*: Exported generic functions
hstack*: Exported generic functions

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

J
join: Exported generic functions
join: Exported generic functions
join: Exported generic functions
join: Exported generic functions

L
logior-mask: Internal functions

M
Macro, aggregate-columns: Exported macros
Macro, aggregate-rows: Exported macros
Macro, bind-row: Exported macros
Macro, brr: Exported macros
Macro, pipeline: Exported macros
Macro, with-concatenation-state: Internal macros
Macro, with-header: Exported macros
Macro, with-standard-header: Exported macros
Macro, with-table: Exported macros
make-bind-row: Internal functions
make-concatenation-state: Internal functions
make-header: Exported generic functions
make-header: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Internal functions
make-leaf: Internal functions
make-node: Internal functions
make-row: Exported generic functions
make-row: Exported generic functions
make-row: Exported generic functions
make-row: Exported generic functions
make-signature: Internal functions
make-sparse-material-column: Exported functions
make-sparse-material-column-iterator: Internal functions
make-sparse-material-column-range: Internal functions
make-standard-transformation: Internal functions
make-table: Exported functions
make-table*: Exported generic functions
make-table*: Exported generic functions
make-value: Internal generic functions
mask: Internal functions
max-index: Internal functions
Method, (setf access-iterator): Internal generic functions
Method, (setf access-position): Internal generic functions
Method, (setf at): Exported generic functions
Method, (setf column-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, (setf row-at): Exported generic functions
Method, access-iterator: Internal generic functions
Method, access-position: Internal generic functions
Method, address-range: Exported generic functions
Method, address-range: Exported generic functions
Method, alter-columns: Exported generic functions
Method, alter-columns: Exported generic functions
Method, at: Exported generic functions
Method, augment-iterator: Exported generic functions
Method, bind-row-closure: Exported generic functions
Method, bind-row-closure: Exported generic functions
Method, bind-row-closure: Exported generic functions
Method, check-column-signatures-compatibility: Exported generic functions
Method, check-predicate: Exported generic functions
Method, column-at: Exported generic functions
Method, column-at: Exported generic functions
Method, column-at: Exported generic functions
Method, column-count: Exported generic functions
Method, column-count: Exported generic functions
Method, column-name: Exported generic functions
Method, column-number: Internal generic functions
Method, column-predicate: Exported generic functions
Method, column-signature: Exported generic functions
Method, column-signature: Exported generic functions
Method, column-signature-spec: Internal generic functions
Method, column-size: Exported generic functions
Method, column-specs: Exported generic functions
Method, column-type: Exported generic functions
Method, column-type: Exported generic functions
Method, column-type: Exported generic functions
Method, column-type-error-column: Internal generic functions
Method, column-type-error-column: Internal generic functions
Method, concatenate-headers: Exported generic functions
Method, content: Exported generic functions
Method, copy-from: Exported generic functions
Method, erase!: Exported generic functions
Method, fill-columns-buffer-impl: Internal generic functions
Method, fill-columns-buffer-impl: Internal generic functions
Method, fill-columns-buffer-impl: Internal generic functions
Method, finish-iterator: Exported generic functions
Method, gather-column-data: Internal generic functions
Method, gather-column-data: Internal generic functions
Method, gather-column-data: Internal generic functions
Method, header: Exported generic functions
Method, header: Exported generic functions
Method, hstack*: Exported generic functions
Method, in-existing-content: Internal generic functions
Method, index-to-name: Exported generic functions
Method, iterator: Exported generic functions
Method, join: Exported generic functions
Method, join: Exported generic functions
Method, join: Exported generic functions
Method, make-header: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-row: Exported generic functions
Method, make-row: Exported generic functions
Method, make-row: Exported generic functions
Method, make-table*: Exported generic functions
Method, name-to-index: Exported generic functions
Method, name-to-index: Exported generic functions
Method, optimized-closure: Internal generic functions
Method, read-callback: Internal generic functions
Method, read-column: Internal generic functions
Method, read-column-names: Internal generic functions
Method, read-column-signature-class: Internal generic functions
Method, read-column-signatures: Internal generic functions
Method, read-columns: Internal generic functions
Method, read-from: Internal generic functions
Method, read-header: Exported generic functions
Method, read-header: Internal generic functions
Method, read-initial-position: Internal generic functions
Method, read-iterator: Internal generic functions
Method, read-iterator: Internal generic functions
Method, read-name: Exported generic functions
Method, read-predicate: Internal generic functions
Method, read-row-count: Internal generic functions
Method, read-table-row: Internal generic functions
Method, read-to: Internal generic functions
Method, read-type: Internal generic functions
Method, remove-nulls: Exported generic functions
Method, remove-nulls: Exported generic functions
Method, row-at: Exported generic functions
Method, row-at: Exported generic functions
Method, row-at: Exported generic functions
Method, row-at: Exported generic functions
Method, row-at: Exported generic functions
Method, row-at: Exported generic functions
Method, row-count: Exported generic functions
Method, select: Exported generic functions
Method, select-columns: Exported generic functions
Method, show: Exported generic functions
Method, to-table: Exported generic functions
Method, to-table: Exported generic functions
Method, to-table: Exported generic functions
Method, to-table: Exported generic functions
Method, to-table: Exported generic functions
Method, to-table: Exported generic functions
Method, transform: Exported generic functions
Method, transform-row: Exported generic functions
Method, transformation: Exported generic functions
Method, transformation-result: Exported generic functions
Method, truncate-to-length: Exported generic functions
Method, vmask: Exported generic functions
Method, vstack*: Exported generic functions
Method, write-columns: Internal generic functions
move-children: Internal functions
move-children-in-column: Internal functions
move-children-in-columns: Internal functions
move-column-to: Internal functions
move-iterator: Exported functions
move-iterator-to: Exported functions
move-stack: Internal functions
move-to-existing-column: Internal functions
move/pad-stack: Internal functions
mutate-leaf: Internal functions

N
name-to-index: Exported generic functions
name-to-index: Exported generic functions
name-to-index: Exported generic functions
node: Internal functions
nullify: Exported functions

O
occupied-space: Internal functions
offset: Internal functions
optimized-closure: Internal generic functions
optimized-closure: Internal generic functions
order-by: Exported functions

P
pad-stack: Internal functions
parent-changed: Internal functions
parent-index: Internal functions
pipeline: Exported macros

R
range-iterator: Internal functions
read-buffers: Internal functions
read-callback: Internal generic functions
read-callback: Internal generic functions
read-changes: Internal functions
read-column: Internal generic functions
read-column: Internal generic functions
read-column-names: Internal generic functions
read-column-names: Internal generic functions
read-column-signature-class: Internal generic functions
read-column-signature-class: Internal generic functions
read-column-signatures: Internal generic functions
read-column-signatures: Internal generic functions
read-columns: Internal functions
read-columns: Internal generic functions
read-columns: Internal generic functions
read-depths: Internal functions
read-from: Internal generic functions
read-from: Internal generic functions
read-header: Exported generic functions
read-header: Exported generic functions
read-header: Internal generic functions
read-header: Internal generic functions
read-indexes: Internal functions
read-initial-index: Internal functions
read-initial-position: Internal generic functions
read-initial-position: Internal generic functions
read-initialization-status: Internal functions
read-iterator: Internal generic functions
read-iterator: Internal generic functions
read-iterator: Internal generic functions
read-name: Exported generic functions
read-name: Exported generic functions
read-new-value: Exported functions
read-predicate: Internal generic functions
read-predicate: Internal generic functions
read-row-count: Internal generic functions
read-row-count: Internal generic functions
read-stacks: Internal functions
read-table-row: Internal generic functions
read-table-row: Internal generic functions
read-to: Internal generic functions
read-to: Internal generic functions
read-touched: Internal functions
read-transformation: Internal functions
read-type: Internal generic functions
read-type: Internal generic functions
reduce-stack: Internal functions
reduce-stacks: Internal functions
remove-nulls: Exported generic functions
remove-nulls: Exported generic functions
remove-nulls: Exported generic functions
remove-nulls: Exported generic functions
remove-nulls-from-columns: Internal functions
row: Exported functions
row-at: Exported generic functions
row-at: Exported generic functions
row-at: Exported generic functions
row-at: Exported generic functions
row-at: Exported generic functions
row-at: Exported generic functions
row-at: Exported generic functions
row-count: Exported generic functions
row-count: Exported generic functions
row-erase: Internal generic functions
row-to-list: Exported functions
row-to-vector: Exported functions
rr: Exported functions
rs: Exported functions

S
s: Exported functions
select: Exported generic functions
select: Exported generic functions
select-columns: Exported generic functions
select-columns: Exported generic functions
select-columns: Internal functions
select-rows: Internal functions
set-row: Exported functions
shift-content: Internal functions
show: Exported generic functions
show: Exported generic functions
sparse-material-column-at: Internal functions
sparse-material-column-iterator-buffers: Internal functions
sparse-material-column-iterator-changes: Internal functions
sparse-material-column-iterator-columns: Internal functions
sparse-material-column-iterator-depths: Internal functions
sparse-material-column-iterator-index: Exported functions
sparse-material-column-iterator-indexes: Internal functions
sparse-material-column-iterator-initial-index: Internal functions
sparse-material-column-iterator-initialization-status: Internal functions
sparse-material-column-iterator-p: Internal functions
sparse-material-column-iterator-stacks: Internal functions
sparse-material-column-iterator-touched: Internal functions
sparse-material-column-iterator-transformation: Internal functions
standard-transformation-bind-row-closure: Internal functions
standard-transformation-column-count: Internal functions
standard-transformation-columns: Internal functions
standard-transformation-count: Internal functions
standard-transformation-dropped: Internal functions
standard-transformation-in-place: Internal functions
standard-transformation-iterator: Internal functions
standard-transformation-marker-column: Internal functions
standard-transformation-p: Internal functions
standard-transformation-restarts-enabled: Internal functions
standard-transformation-row: Exported functions
standard-transformation-start: Internal functions
standard-transformation-table: Internal functions

T
table-from-header: Internal functions
to-matrix: Exported functions
to-table: Exported generic functions
to-table: Exported generic functions
to-table: Exported generic functions
to-table: Exported generic functions
to-table: Exported generic functions
to-table: Exported generic functions
to-table: Exported generic functions
transform: Exported generic functions
transform: Exported generic functions
transform-row: Exported generic functions
transform-row: Exported generic functions
transform-row-impl: Internal functions
transformation: Exported generic functions
transformation: Exported generic functions
transformation-result: Exported generic functions
transformation-result: Exported generic functions
tree-index: Internal functions
trim-depth: Internal functions
trim-depth-in-column: Internal functions
truncate-mask: Internal functions
truncate-to-length: Exported generic functions
truncate-to-length: Exported generic functions

U
unique-names: Internal functions
untouch: Exported functions
update-parents: Internal functions

V
validate-active-header: Internal functions
validate-active-row: Internal functions
validate-row: Internal functions
visualize: Exported generic functions
vmask: Exported generic functions
vmask: Exported generic functions
vs: Exported functions
vstack: Exported functions
vstack*: Exported generic functions
vstack*: Exported generic functions

W
with-concatenation-state: Internal macros
with-header: Exported macros
with-standard-header: Exported macros
with-table: Exported macros
write-columns: Internal generic functions
write-columns: Internal 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: Internal classes
%column: Exported conditions
%column: Internal conditions
%column: Internal classes
%column-names: Exported classes
%column-number: Exported conditions
%column-signature-class: Exported classes
%column-signatures: Exported classes
%columns: Exported classes
%from: Exported classes
%header: Exported conditions
%header: Exported classes
%header: Exported classes
%header: Exported classes
%headers: Exported conditions
%initial-position: Internal classes
%iterator: Internal classes
%iterator: Internal classes
%name: Exported classes
%optimized-closure: Exported classes
%position: Internal classes
%predicate: Exported classes
%row-count: Exported classes
%table-row: Exported classes
%to: Exported classes
%type: Exported classes

*
*current-row*: Exported special variables
*header*: Exported special variables
*row*: Exported special variables
*table*: Exported special variables
*transform-control*: Internal special variables
*transform-in-place*: Exported special variables
*validate-predicates*: Exported special variables

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

C
changed-parents: Internal structures
changes: Internal structures
column-count: Internal structures
columns: Internal structures
columns: Internal structures
columns: Internal structures
count: Internal structures

D
depths: Internal structures
dropped: Internal structures

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

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

N
nodes: Internal structures

P
parents: Internal structures

R
restarts-enabled: Internal structures
row: Internal structures

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

T
table: Internal structures
touched: Internal structures
transformation: Internal structures

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

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

A.4 Data types

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

B
between: Exported classes
bind-row: Exported classes

C
Class, between: Exported classes
Class, bind-row: Exported classes
Class, column-signature: Exported classes
Class, content: Exported classes
Class, frame-range-mixin: Exported classes
Class, fundamental-column: Exported classes
Class, fundamental-header: Exported classes
Class, fundamental-table: Exported classes
Class, selector: Internal classes
Class, setfable-table-row: Exported classes
Class, sparse-material-column: Exported classes
Class, sparse-material-column-range: Internal classes
Class, standard-header: Exported classes
Class, standard-table: Exported classes
Class, standard-table-range: Exported classes
Class, table-row: Internal classes
Class, to-table-function: Internal classes
column-error: Internal conditions
column-signature: Exported classes
column-type-error: Exported conditions
concatenation-state: Internal structures
Condition, column-error: Internal conditions
Condition, column-type-error: Exported conditions
Condition, file-input-row-cant-be-created: Exported conditions
Condition, headers-incompatible: Exported conditions
Condition, index-out-of-column-bounds: Internal conditions
Condition, invalid-input-for-row: Exported conditions
Condition, invalid-name: Exported conditions
Condition, iterator-error: Internal conditions
Condition, name-duplicated: Exported conditions
Condition, name-when-selecting-row: Exported conditions
Condition, no-column: Exported conditions
Condition, no-header: Exported conditions
Condition, no-row: Internal conditions
Condition, no-such-column: Internal conditions
Condition, no-transformation: Exported conditions
Condition, predicate-failed: Exported conditions
Condition, row-cant-be-created: Exported conditions
Condition, setting-to-null: Internal conditions
Condition, transformation-error: Exported conditions
Condition, unable-to-construct-row: Exported conditions
content: Exported classes

F
file-input-row-cant-be-created: Exported conditions
frame-range-mixin: Exported classes
fundamental-column: Exported classes
fundamental-header: Exported classes
fundamental-table: Exported classes

H
headers-incompatible: Exported conditions

I
index-out-of-column-bounds: Internal conditions
invalid-input-for-row: Exported conditions
invalid-name: Exported conditions
iterator-buffer: Internal types
iterator-change: Internal types
iterator-error: Internal conditions
iterator-stack: Internal types

N
name-duplicated: Exported conditions
name-when-selecting-row: Exported conditions
no-column: Exported conditions
no-header: Exported conditions
no-row: Internal conditions
no-such-column: Internal conditions
no-transformation: Exported 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
predicate-failed: Exported conditions

R
row-cant-be-created: Exported conditions

S
selector: Internal classes
setfable-table-row: Exported classes
setting-to-null: Internal conditions
sparse-material-column: Exported classes
sparse-material-column-iterator: Internal structures
sparse-material-column-range: Internal classes
standard-header: Exported classes
standard-table: Exported classes
standard-table-range: Exported classes
standard-transformation: Internal structures
Structure, concatenation-state: Internal structures
Structure, sparse-material-column-iterator: Internal structures
Structure, standard-transformation: Internal structures
System, vellum: The vellum system

T
table-row: Internal classes
to-table-function: Internal classes
transformation-error: Exported conditions
Type, iterator-buffer: Internal types
Type, iterator-change: Internal types
Type, iterator-stack: Internal types

U
unable-to-construct-row: Exported conditions

V
vellum: The vellum system
vellum: The vellum package
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:   B   C   F   H   I   N   P   R   S   T   U   V