The roan Reference Manual

Table of Contents

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

The roan Reference Manual

This is the roan Reference Manual, version 8.0.7, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:18:13 2018 GMT+0.


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

1 Introduction

Roan

Roan is a libary of Common Lisp code for writing applications related to change ringing It is roughly comparable to the Ringing Class Library although that is for the C++ programming language, and the two libraries differ in many other ways.

Roan provides

Roan is distributed under an MIT open source license, which mostly means that you can just use Roan for nearly anything you like. See the file LICENSE for details.

Installing Roan

While Quicklisp is not required to run Roan, it is recommended. With Quicklisp installed and configured, you can download and install Roan by simply executing in Lisp (ql:quickload :roan).

Quicklisp's quickload function, above, will also pull in all the other libraries upon which Roan depends; if you don't use Quicklisp you will have to ensure that those libraries are available and loaded. If you don't want to use Quicklisp, and prefer to load Roan by hand, the repository for Roan itself is at https://bitbucket.org/dfmorrison/roan, and both current and previous versions can be downloaded from the tags pane of the Downloads page, https://bitbucket.org/dfmorrison/roan/downloads/?tab=tags.

Roan has been tested with

but it should also work in other, modern Common Lisp implementations that support the libraries on which Roan depends.

Documentation

The Roan manual is available online. It can also be downloaded in four different formats:

Reporting Bugs

The best way to report bugs is to submit them with Roan's Bitbucket issue tracker If that doesn't work for you you can also send mail to Don Morrison dfm@ringing.org.


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

2 Systems

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


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

2.1 roan

Author

Don Morrison <dfm@ringing.org>

License

MIT

Description

A library to support change ringing applications, including methods library support

Version

8.0.7

Dependencies
Source

roan.asd (file)

Component

method-lookup.lisp (file)


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

2.2 roan-base

Author

Don Morrison <dfm@ringing.org>

License

MIT

Description

A library to support change ringing applications, sans the method library support

Version

8.0.7

Dependencies
Source

roan-base.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 roan.asd

Location

roan.asd

Systems

roan (system)


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

3.1.2 roan-base.asd

Location

roan-base.asd

Systems

roan-base (system)


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

3.1.3 roan/method-lookup.lisp

Parent

roan (system)

Location

method-lookup.lisp

Internal Definitions

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

3.1.4 roan-base/package.lisp

Parent

roan-base (system)

Location

package.lisp

Packages

roan


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

3.1.5 roan-base/util.lisp

Dependency

package.lisp (file)

Parent

roan-base (system)

Location

util.lisp

Exported Definitions
Internal Definitions

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

3.1.6 roan-base/roan.lisp

Dependencies
Parent

roan-base (system)

Location

roan.lisp

Exported Definitions
Internal Definitions

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

3.1.7 roan-base/pattern.lisp

Dependencies
Parent

roan-base (system)

Location

pattern.lisp

Exported Definitions
Internal Definitions

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

3.1.8 roan-base/method.lisp

Dependencies
Parent

roan-base (system)

Location

method.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 roan

===summary===
@cindex @code{roan} package
@cindex packages
All the symbols used by Roan to name functions, variables and so on are in the @code{roan} package. When using them from another package, such as @code{cl-user}, they should be prefixed with an explicit @code{roan:}.
@example
@group
CL-USER> *package*
#<Package "COMMON-LISP-USER">
CL-USER> roan:+maximum-stage+
24
@end group
@end example

Alternatively all the external symbols of the @code{roan} package can be imported into a package with @code{use-package}, or the @code{:use} option to @code{defpackage}. There is the slight complication, however, that the @code{roan} package shadows the symbols @code{method} and @code{method-name} from the @code{common-lisp} package. This is done because methods are an important concept in change ringing, albeit one unrelated to CLOS methods. Typically @code{method} and @code{method-name} should be shadowed in other packages that use the @code{roan} package. This can be done with @code{shadowing-import}, or the @code{:shadowing-import} option to @code{defpackage}.
@example
@group
MY-PACKAGE> *package*
#<Package "MY-PACKAGE">
MY-PACKAGE> (package-use-list *)
(#<Package "COMMON-LISP">)
MY-PACKAGE> (shadowing-import ’(roan:method roan:method-name))
T
MY-PACKAGE> (use-package :roan)
T
MY-PACKAGE> +maximum-stage+
24
@end group
@end example
===endsummary===
Contains the symbols used by Roan. The @code{roan} package shadows two symbols from the @code{common-lisp} package: @code{method} and @code{method-name}. The functions and so on attached to these symbols in the @code{common-lisp} package are usually only needed when doing introspection, and the shadowing should rarely cause difficulties.

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Constants

Constant: +maximum-stage+

The largest number of bells supported, 24.

Package

roan

Source

roan.lisp (file)

Constant: +minimum-stage+

The smallest number of bells supported, 2.

Package

roan

Source

roan.lisp (file)


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

5.1.2 Special variables

Special Variable: *cross-character*

The character used by default as “cross” when writing place notation. Must be a character designator for one of @code{#\x}, @code{#\X} or @code{#\-}. Its initial default value is a lower case @samp{x}, @code{#\x}.

Package

roan

Source

roan.lisp (file)

Special Variable: *default-stage*

An integer, the default value for optional or keyword arguments to many functions that must have a stage specified. @xref{write-row,,@code{write-row}}, @ref{row-string,,@code{row-string}}, @ref{write-place-notation,,@code{write-place-notation}} and @ref{place-notation-string,,@code{place-notation-string}}.

Package

roan

Source

roan.lisp (file)

Special Variable: *print-bells-upper-case*

When printing bell names that are letters, whether or not to use upper case letters by default. It is a generalized boolean, with an initial default value of @code{t}.

Package

roan

Source

roan.lisp (file)


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

5.1.3 Macros

Macro: do-hash-set (VAR SET &optional RESULT-FORM) &body BODY

===lambda: ((var set &optional result-form) &body body)
Evaluates the @var{body}, an implicit @code{progn}, repeatedly with the symbol @code{var} bound to the elements of the @code{hash-set} @var{set}. Returns the result of evaluating @var{result-form}, which defaults to @code{nil}, after the last iteration. A value may be returned by using @code{return} or @code{return-from nil}, in which case @var{result-form} is not evaluated. The order in which the elements of @var{set} are bound to @code{var} for evaluating @var{body} is undefined. With one exception the behavior is undefined if @var{body} attempts to modify the contents of @var{set}: @var{function} may call @code{hash-set-delete} to delete the current element, but no other. A @code{type-error} is signaled if @var{set} is not a @code{hash-set}.
@example
@group
(let ((r nil))
(do-hash-set (e (hash-set !135246 !123456 !531246) r)
(push (list e (in-course-p e) r))))
@result{} ((!531246 nil) (!123456 t) (!135246 nil))
@end group
@end example

Package

roan

Source

util.lisp (file)

Macro: hash-set-deletef PLACE &rest ELEMENTS

===lambda: (set &rest elements)
Deletes from @var{set}, which should be a location suitable as a first argument to @code{setf} contains a @code{hash-set}, all its elements @code{equalp} to any of the @var{elements}. Returns @var{set}. Signals a @code{type-error} if the @var{set} does not contain a @code{hash-set}.
@example
@group
(let ((s (hash-set !3524 !5432 !4253 !2345)))
(hash-set-deletef s !2345 !5432)
(hash-set-elements s))
@result{} (!4253 !3524)
@end group
@end example

Package

roan

Source

util.lisp (file)

Macro: hash-set-nadjoinf PLACE &rest ELEMENTS

===lambda: (set &rest elements)
Adds @var{elements} to @var{set}, which should be a location suitable as a first argument to @code{setf} containing a @code{hash-set}, which is modified. As usual duplicate elements are not added, though exactly which of any potential duplicates are retained is undefined. Returns @var{set} Signals a @code{type-error} if @var{set} does not contain a @code{hash-set}.
@example
@group
(let ((s (hash-set !1324 !3412 !4321)))
(adjoinf s !1234 !3412 !4231)
(hash-set-elements s))
@result{} (!3412 !4231 !1234 !3412 !4321 !1324)
@end group
@end example

Package

roan

Source

util.lisp (file)

Macro: permutef PLACE &rest CHANGES

===lambda: (row &rest changes)
Permutes @var{row}, which should be a location suitable as the first argument to @code{setf} containing a @code{row}, by @var{changes}, updating @var{row} to contain the result, and returns it. Signals a @code{type-error} if the value @var{row} contains is not a @code{row} or if any of the @var{changes} are not @code{row}s.

Package

roan

Source

roan.lisp (file)

Macro: with-methods-database (VAR &key DATABASE BUSY-TIMEOUT) &body BODY

For more complex uses of Roan’s methods database than the various @code{lookup-methods-} facilitate SQL queries can be made against the database directly using the @url{https://common-lisp.net/project/cl-sqlite/,CL-SQLITE API}. The @code{with-methods-database} macro binds @var{var} to a database handle to Roan’s methods database and executes @var{body}, returning the result; returns @code{nil} if @var{body} is empty. The database handle is closed on exit.

If @var{database} is supplied it should be a pathname designator to a database with the Schema of Roan’s methods database. If @code{nil}, the default, the standard location for the database is used.

If @var{busy-timeout} is supplied it should be a non-negative integer, the number of milliseconds to wait when attempting to operate on a busy database. If @code{nil}, the default, operations on a busy database fail immediately.

Signals a @code{type-error} if @var{database} is neither @code{nil} nor a pathname designator, or if @var{busy-timeout} is neither @code{nil} nor a non-negative integer. A variety of SQLite or file system errors may be signaled if there is difficulty opening the database file.
@example
@group
(with-methods-database (conn)
(iter (for (stage) :in-sqlite-query
"select stage from methods
where name = ’Cambridge Surprise’"
:on-database conn)
(collect stage)))
@result{} (6 8 10 12 14 16)
@end group
@end example

The Roan methods database has the following schema:
@example
@group
CREATE TABLE methods (stage int not null,
name text not null,
notation text not null,
canonicalRotation text,
firstTower text,
firstHand text);
CREATE TABLE version (updated text non null, etag text);
CREATE UNIQUE INDEX key on methods (stage, name);
CREATE INDEX notationIndex on methods (notation);
CREATE INDEX rotationIndex on methods (canonicalRotation);
@end group
@end example
The actual methods data is stored in the @code{methods} table. The @code{version} table should contain only a single row, and records information used by @code{update-methods-database} to determine whether or not the database needs updating. Neither the indices nor the contents of the canonicalRotation column exist in the copy of the database on the server, and are instead created by @code{update-methods-database} after it is downloaded to reduce the size of the file transferred over the network.

The @code{stage} and @code{name} columns of the @code{methods} table are the stage and name of the method described by that row of the table (polysemy alert: a table row is unrelated to a change ringing row), and together form a primary key for that table; that is, there can be no two rows that have the same @code{stage} and @code{name}.

The @code{notation} column is the corresponding place notation, in a canonical form with internal places elided as by @code{:elide :lead-end} in @code{write-place-notation}, capital letters used for place eleven or above, a lower case @samp{x} used for cross, and palindromic methods with an even lead length unfolded as by @code{:comma t}.

The @code{canonicalRotation} is the place notation corresponding to a unique rotation of of changes of the method. That is, if two methods have the same changes, up to rotation, they will have the same @code{canonicalRotation}. Note that this rotation is in no way a preferred one, and is in most cases one few bands would ever care to ring; it is just a way of comparing two methods to see if they are the same up to rotation. The place notation for @code{canonicalRotation} is in the same canonical form as @code{notation}.

The @code{firstTower} and @code{firstHand} columns are succinct, textual representations of when, and possibly where, the first peal in the methods occurred in tower or hand, respectively, if that information is available in the database. Sometimes it is not available, or no such peal has occured, in which the column is @code{null}. @xref{canonicalize-method-place-notation}
@xref{write-place-notation}

Package

roan

Source

method.lisp (file)


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

5.1.4 Functions

Function: add-pattern COUNTER LABEL PATTERN &optional DOUBLE-ROW-P

Adds one or more patterns to those matched by the @code{match-counter} @var{count}.
A single pattern, @var{pattern}, is added, with label @var{label}, by @code{add-pattern}. If the generalized boolean @var{double-row-p} is true two rows (which typically should be consecutive) will be matched against @var{pattern}, and others one row; if not supplied @var{double-row-p} is @code{nil}. Multiple patterns may be added together with @code{add-patterns}: @var{lists} should be a list of lists, where the sublists are of the form @code{(@var{label} @var{pattern} &optional @var{double-row-p})}, and the patterns are added in the order given. In either case the @var{pattern} may be either a string or list structure that is a parsed pattern, such as returned by @code{parse-pattern}. If @var{label} is @code{equalp} to the label of a pattern already added to @var{counter} that pattern will be replaced, and its corresponding counts reset to zero. Either function reeturns @var{counter}. Either signals a @code{type-error} if @var{counter} is not a @code{match-counter}. Signals an error if any of the @var{pattern}s are not an appropriate pattern for the stage of @var{counter}.

Package

roan

Source

pattern.lisp (file)

Function: add-patterns COUNTER LISTS

===merge: add-pattern

Package

roan

Source

pattern.lisp (file)

Function: alter-stage ROW &optional NEW-STAGE

If there is a @code{row}, @var{r}, of stage @var{new-stage} such that
@code{(equalp (permute (rounds @var{new-stage}) @var{r}) @var{row})} then returns @var{r}, and otherwise @code{nil}. That is, it returns a row of the @var{new-stage} such that the first bells are as in @var{row}, and any new or omitted bells are in rounds order. If not supplied @var{new-stage} defaults to the current value of @code{*default-stage*}. Signals a @code{type-err} if @var{row} is not a @code{row} or @var{new-stage} is not a @code{stage}.
@example
@group
(alter-stage !54321 10) @result{} !5432167890
(alter-stage !5432167890 6) @result{} !543216
(alter-stage !54321 4) @result{} nil
(alter-stage !5432167890 4) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: bell-at-position ROW POSITION

The @code{bell-at-position} function returns the @code{bell} (that is, a small integer) at the given @var{position} in the @var{row}. The @code{position-of-bell} function returns position of @var{bell} in @var{row}, or @code{nil} if @var{bell} does not appear in @var{row}. The indexing into @var{row} is zero-based; so, for example, the leading bell is at position 0, not 1. Signals an error if @var{row} is not a @code{row}, or if @var{position} is not a non-negative integer or is too large for the stage of @var{row} @example
@group
(bell-at-position !13572468 3) @result{} 6
(bell-name (bell-at-position !13572468 3)
@result{} #\7
(position-of-bell 6 !13572468) @result{} 3
(position-of-bell (bell-from-name #7) !13572468)
@result{} 3
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: bell-from-name CHAR

Returns the @code{bell} denoted by the character designator @var{char}, or @code{nil} if it is not a character designator denoting a bell. The determination is case-insensitive. @example
@group
(bell-from-name "8") @result{} 7
(bell-from-name "E") @result{} 10
(map ’list #’bell-from-name "135246") @result{} (0 2 4 1 3 5)
(bell-from-name "%") @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: bell-name BELL &optional UPPER-CASE

Returns a character denoting this @var{bell}, or @code{nil} if @var{bell} is not a @code{bell}. If the character is alphabetic, an upper case letter is return if the generalized boolean @var{upper-case} is true, and otherwise a lower case letter. If @var{upper-case} is not supplied it defaults to the current value of @code{*print-bells-upper-case*}.
@example
@group
(bell-name 0) @result{} #\1
(map ’string #’bell-name
(loop for i from 0 below +maximum-stage+
collect i))
@result{} "1234567890ETABCDFGHJKLMN"
(bell-name -1) @result{} nil
(bell-name +maximum-stage+) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: bells-list ROW

The @code{bells-list} function returns a fresh list of @code{bell}s (small, non-negative integers, zero-based), the bells of @var{row}, in the same order that they appear in @var{row}. The @code{bells-vector} function returns a vector of @code{bell}s (small, non-negative integers, zero-based), the bells of @var{row}, in the same order that they appear in @var{row}. If @var{vector} is not supplied or is @code{nil} a freshly created, simple general vector is returned.
@example
@group
(bells-list !13572468) @result{} (0 2 4 6 1 3 5 7)
(bells-vector !142536) @result{} #(0 3 1 4 2 5)
@end group
@end example

If a non-nil @var{vector} is supplied the @code{bell}s are copied into it and it is returned. If @var{vector} is longer than the stage of @var{row} only the first elements of @var{vector}, as many as the stage of @var{row}, are over-written; the rest are unchanged. If @var{vector} is shorter than the stage of @var{row}, then, if it is adjustable, it is adjusted to be exactly as long as the stage of @var{row}, and otherwise an error is signaled without any modifications made to the contents of @var{vector} or its fill-pointer, if any. If @var{vector} has a fill-pointer and is long enough to hold all the bells of @var{row}, possibly after adjustment, its fill-pointer is set to the stage of @var{row}.

A @code{type-error} is signaled if @var{row} is not a @code{row}. An error is signled if @var{vector} is neither @code{nil} nor a @code{vector} with an element type that is a supertype of @code{bell}, and of sufficient length or adjustable.

Package

roan

Source

roan.lisp (file)

Function: bells-vector ROW &optional VECTOR

===merge: bells-list

Package

roan

Source

roan.lisp (file)

Function: canonicalize-method-place-notation METHOD &rest KEYS &key COMMA &allow-other-keys

===lambda: (method &key comma elide cross upper-case allow-jump-changes)
Replaces @var{method}’s place-notation by an equivalent string in canonical form, and returns that canonical notation as a string. Unless overriden by keyword arguments this is a compact version with leading and lying changes elided according to @code{:lead-end} format as for @code{write-place-notation}, partitioned with a comma, if possible, with upper case letters for high number bells and a lower case @samp{x} for cross. The behavior can be changed by passing keyword arguments as for @code{write-place-notation}. If @var{method} has no place-notation or no stage, this function does nothing, and returns @code{nil}; in particular, if there is place-notation but no stage, the place-notation will be unchanged.

Signals a @code{type-error} if @var{method} is not a @code{method}, and signals an error if any of the keyword arguments do not have suitable values for passing to @code{write-place-notation}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage. @xref{canonicalize-place-notation} and @ref{write-place-notation}.
@example
@group
(let ((m (method :stage 6
:place-notation "-16.X.14-6X16"))) (canonicalize-method-place-notation m)
(method-place-notation m))
@result{} "x1x4,6"
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: canonicalize-place-notation STRING-OR-CHANGES &rest KEYS &key STAGE COMMA &allow-other-keys

===lambda: (string-or-changes &key stage comma elide cross upper-case allow-jump-changes) Returns a string representing the place notation in a canonical form. If @var{string-or-changes} is a string it should be parseable as place notation at @var{stage}, which defaults to the current value of @code{*default-stage*}, and otherwise it should be a list of @code{row}s, all of the same stage. Unless overridden by the other keyword arguments, which have the same effects as for @code{write-place-notation}, the canonical form is a compact one usin lower case @samp{x} for cross, upper case letters for place high place names, @code{lead-end} style elision of external places, a comma for unfolding if possible, and notating jump changes as jumps within parentheses.

Signals a @code{type-error} if @var{string-or-changes} is neither a string nor a list, or if it is a list containing anything other than @code{row}s. Signals a @code{parse-error} if @var{string-or-changes} is a string and is not parseable at @var{stage}, or if @var{stage} is not a @code{stage}. Signals an error if @var{cross} is not a suitable character designator, if @var{allow-jump-changes} is not one of its allowed values, or if @var{string-or-changes} is a list containing @code{row}s of different stages. @xref{write-place-notation}.
@example
@group
(multiple-value-list
(canonicalize-place-notation "-16.X.14-6X1" :stage 6))
@result{} ("x1x4,6" t)
(multiple-value-list
(canonicalize-place-notation "-3-[134265]-1T-" :stage 12))
@result{} ("x3x(24)x1x" nil)
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: cccbr-name METHOD-OR-STRING

Strips the class name and Little and Differential modifiers off a method name to leave just that portion that the CCCBR considers a method’s name. The argument can be either a string or a @code{method}, in which latter case it’s @code{method-name} is used. In either case the value returned is a string. It is strict about the ordering of Differential and Little, and does not strip off stage names. Signals a @code{type-error} if @var{method-or-string} is neither a method nor a string.
See also @ref{method-classification}.
@example
@group
(cccbr-name "Slink Differential Little Place")
@result{} "Slink"
(cccbr-name "Little Bob")
@result{} ""
(cccbr-name "Cambridge Major")
@result{} "Cambridge Major"
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: changep ROW

True if and only if @var{row} is a @code{row} representing a permutation with no bell moving more than one place.
@example
@group
(changep !214365) @result{} t
(changep !143265) @result{} nil
(changep |214365|) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: copy-row INSTANCE
Package

roan

Source

roan.lisp (file)

Function: cycles ROW

Returns a list of lists of bells. Each of the sublists is the orbit of all of its elements in @var{row}. One cycles are included. Thus, if @var{row} is a lead head, all the sublists of length one are hunt bells, all the rest being working bells. If there are two or more sublists of length greater than one the corresponding method is, in Central Council nomenclature, a differential or differential hunter, depending upon the absence or presence of hunt bells. The resulting sublists are each ordered such that the first bell is the lowest numbered bell in that cycle, and the remaining bells occur in the order in which a bell traverses the cycle. Within the top level list, the sublists are ordered such that the first bell of each sublist appear in ascending numerical order.
@example
@group
(cycles !13572468) @result{} ((0) (1 4 2) (3 5 6) (7))
(format nil "~@{(~@{~C~^,~@})~^, ~@}"
(mapcar #’(lambda (x) (mapcar #’bell-name x))
(cycles !13572468)))
@result{} "(1), (2,5,3), (4,6,7), (8)"
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: fch-group ITEM &optional HIGHER-STAGE OUT-OF-COURSE

Returns an @code{fch-group} described by the provided arguments. The @var{item} can be either a @code{row} or a string designator.

If @var{item} is a @code{row} the @code{fch-group} that contains that row among its elements is returned. If it is not at an even stage, major or above, or if it is at an even stage royal or above but with any of the bells conventially called the seven (and represented in Roan by the integer @code{6}) or higher out of their rounds positions, @code{nil} is returned. If @var{item} is a @code{row} at an even stage maximus or above, with the back bells in their home positions, it is treated as if it were the equivalent royal @code{row}. When @var{item} is a @code{row} neither @var{higher-stage} nor @var{out-of-course} may be supplied.

If @var{item} is a string designator the @code{fch-group} that has that name is returned. If the generalized boolean @var{higher-stage} is true a higher stage @code{fch-group} is returned and others a major one. In the case of higher stage groups if the generalized boolean @var{out-of-course} is true the group with the given name containing only out of course elements is returned, and otherwise the one with only in course elements. Both @var{higher-stage} and @var{out-of-course} default to @code{nil} if not supplied. If there is no @code{fch-group} with name @var{item} and the given properties @code{nil} is returned.

Signals a @code{type-error} if @var{item} is neither a @code{row} nor a string designator. Signals an error if @var{item} is a @code{row} and @var{higher-stage} or @var{out-of-course} is supplied.
@example
@group
(let ((g (fch-group !2436578)))
(list (fch-group-name g)
(fch-group-parity g)
(stage (first (fch-group-elements g)))))
@result{} ("B" nil 8)
(fch-group "a1" t nil) @result{} nil
(fch-group-elements (fch-group "a1" t t)) @result{} (!1234657890)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: fch-group-elements INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-name INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-parity INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-groups-string COLLECTION &rest MORE-COLLECTIONS

Returns a string succinctly describing a set of @code{fch-group}s, in a conventional order. The set of @code{fch-group}s is the union of all those contained in the arguments, each of which should be a sequence or @code{hash-set}, all of whose elements are @code{fch-group}s. The resulting string contains the names of the distinct @code{fch-group}s. If there are no groups @code{nil}, rather than an empty string, is returned.

For higher stages there are two sequences of group names in the string, separated by a solidus (@samp{/}); those before the solidus are in course and those after it out of course. For example, @code{"B/Da1"} represents the higher course in course elements of group B and out of course elements of groups D and a1.

The group names are presented in the conventional order. For major the groups containing in course, tenors together elements appear first, in alphabetical order; followed by those all of whose tenors together elements are out of course, in alphabetical order; finally followed by those all of whose elements are tenors parted. For higher stages the capital letter groups in each half of the string come first, in alphabetical order, followed by those with lower case names. Note that a lower case name can never appear before the solidus.

Signals a @code{type-error} if any of the arguments are not sequences or @code{hash-set}s, or if any of their elements is not an @code{fch-group}. Signals a @code{mixed-stage-fch-groups-error} if some of the elements are major and some are higher stage @code{fch-group}s.
@example
@group
(fch-groups-string (list (fch-group "a") (fch-group "B")))
@result{} "Ba"
(fch-groups-string #((fch-group "D" t t)
(fch-group "a1" t t))
(hash-set (fch-group "B" t)))
@result{} "B/Da1"
(fch-groups-string (list (fch-group "T" t nil)))
@result{} "T/"
(fch-groups-string (list (fch-group "T" t t)))
@result{} "/T"
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: format-pattern TREE &optional UPPER-CASE

Returns a string that if parsed with @code{parse-pattern}, would return the parse tree @var{tree}. Note that the generation of a suitable string from @var{tree} is not unique, and this function simply returns one of potentially many equivalent possibilities. The case of any bells represented by letters is controlled by @var{upper-case}, which defaults to the current value of @code{*print-bells-upper-case*}. Signals an error if tree is not a parse tree for a pattern.
@example
(format-pattern ’(:sequence 0 1 2 :any 7) t) @result{} "123*8"
@end example

Package

roan

Source

pattern.lisp (file)

Function: hash-set &rest INITIAL-ELEMENTS

Returns a new @code{hash-set} containing the elements of @var{initial-elements}. If no @var{initial-elements} are supplied, the returned @code{hash-set} is empty. @example
@group
(hash-set 1 :foo 2 :foo 1) @result{} #<HASH-SET 3>
(hash-set-elements (hash-set 1 :foo 2 :foo 1))
@result{} (1 2 :foo)
(hash-set-elements (hash-set)) @result{} nil
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-adjoin SET &rest ELEMENTS

Returns a @code{hash-set} contains all the elements of @var{set} to which have been added the @var{elements}. As usual duplicate elements are not added, though exactly which of any potential duplicates are retained is undefined. The @code{hash-set-adjoin} function returns a freshly created @code{hash-set} and does not modify @var{set}, while @code{hash-set-nadjoin} modifies and returns @var{set}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.
@example
@group
(hash-set-elements (hash-set-adjoin (hash-set 1 2 3) 4 3 2))
@result{} (3 4 1 2)
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-clear SET

Removes all elements from @var{set}, and then returns the now empty @code{hash-set}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.

Package

roan

Source

util.lisp (file)

Function: hash-set-copy SET &rest KEYS &key SIZE REHASH-SIZE REHASH-THRESHOLD

===lambda: (set &key size rehash-size rehash-threshold)
Returns a new @code{hash-set} containing the same elements as the @code{hash-set} @var{set}. If any of @var{size}, @var{rehash-size} or @var{rehash-threshold} are supplied they have the same meanings as the eponymous arguments to @code{copy-hash-table}. A @code{type-error} is signaled if @var{set} is not a @code{hash-set}.

Package

roan

Source

util.lisp (file)

Function: hash-set-count SET

Returns a non-negative integer, the number of elements the @code{hash-set} @var{set} contains. Signals a @code{type-error} if @var{set} is not a @code{hash-set}. @example
@group
(hash-set-count (hash-set !1234 !1342 !1234)) @result{} 2
(hash-set-count (hash-set)) @result{} 0
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-delete SET &rest ELEMENTS

Deletes from the @code{hash-set} @var{set} all elements @code{equalp} to elements of @var{elements}, and returns the modified set. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.

Package

roan

Source

util.lisp (file)

Function: hash-set-difference SET &rest MORE-SETS

Returns a @code{hash-set} containing all the elements of @var{set} that not contained in any of @var{more-sets}. The @code{hash-set-difference} version returns a fresh @code{hash-set}, and does not modify @var{set} or any of the @var{more-sets}. The @code{hash-set-ndifference} version modifies and returns @var{set}, but does not modify any of @var{more-sets}. Signals a @code{type-error} if @var{set} or any of @var{more-sets} are not @code{hash-set}s.
@example
@group
(hash-set-elements
(hash-set-difference
(hash-set !12345 !23451 !34512 !45123)
(hash-set !23451 !54321 !12345)))
@result{} (!34512 !45123)
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-elements SET

Returns a list of all the elements of the @code{hash-set} @var{set}. The order of the elements in the list is undefined, and may vary between two invocations of @code{hash-set-elements}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.
@example
(hash-set-elements (hash-set 1 2 1 3 1)) @result{} (3 2 1)
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-empty-p SET

True if and only if the @code{hash-set} @var{set} contains no elements. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.

Package

roan

Source

util.lisp (file)

Function: hash-set-intersection SET &rest MORE-SETS

Retuns a @code{hash-set} such at all of its elements are also elements of @var{set} and of all the @var{more-sets}. The @code{hash-set-intersection} version returns a fresh @code{hash-set}, and does not modify @var{set} or any of the @var{more-sets}. The @code{hash-set-nintersection} version may modify or destroy @var{set} and one or more of the @var{more-sets}, and the return value may or may not be @code{eq} to one of them. Signals a @code{type-error} if @var{set} or any of @var{more-sets} are not @code{hash-set}s.
@example
@group
(coerce
(hash-set-elements
(hash-set-intersection
(apply #’hash-set (coerce "abcdef" ’list))
(apply #’hash-set (coerce "ACEG" ’list))))
’string)
@result{} "EaC"
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-member ITEM SET

True if and only if @var{item} is an element of the @code{hash-set} @var{set}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}. @example
@group
(hash-set-member !1342 (hash-set !1243 !1342)) @result{} t (hash-set-member !1342 (hash-set !12435 !12425)) @result{} nil
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-nadjoin SET &rest ELEMENTS

===merge: hash-set-adjoin

Package

roan

Source

util.lisp (file)

Function: hash-set-ndifference SET &rest MORE-SETS

===merge: hash-set-difference

Package

roan

Source

util.lisp (file)

Function: hash-set-nintersection SET &rest MORE-SETS

===merge: hash-set-intersection

Package

roan

Source

util.lisp (file)

Function: hash-set-nunion &rest SETS

===merge: hash-set-union

Package

roan

Source

util.lisp (file)

Function: hash-set-p OBJECT
Package

roan

Source

util.lisp (file)

Function: hash-set-proper-subset-p SUBSET SUPERSET

===merge: hash-set-subset-p

Package

roan

Source

util.lisp (file)

Function: hash-set-remove SET &rest ELEMENTS

Returns a new @code{hash-set} that contains all the elements of @var{set} that are not @code{equalp} to any of the @var{elements}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.

Package

roan

Source

util.lisp (file)

Function: hash-set-subset-p SUBSET SUPERSET

The @code{hash-set-subset-p} predicate is true if and only if all elements of @var{subset} occur in @var{superset}. The @code{hash-set-proper-subset-p} predicate is true if and only that is the case and further that @code{subset} does not contain all the elements of @var{superset}. @code{type-error} is signaled if either argument is not a @code{hash-set}.
@example
@group
(hash-set-subset-p (hash-set 1) (hash-set 2 1) @result{} t
(hash-set-proper-subset-p (hash-set 1) (hash-set 2 1) @result{} t
(hash-set-subset-p (hash-set 1 2) (hash-set 2 1) @result{} t (hash-set-proper-subset-p (hash-set 1 2) (hash-set 2 1) @result{} nil (hash-set-subset-p (hash-set 1 3) (hash-set 2 1) @result{} nil (hash-set-proper-subset-p (hash-set 1 3) (hash-set 2 1) @result{} nil
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: hash-set-union &rest SETS

Returns a @code{hash-set} containing all the elements that appear in one or more of the @var{sets}. The @code{hash-set-union} version returns a fresh @code{hash-set}, and does not modify any of the @var{sets}. The @code{hash-set-nunion} may modify or destroy one or more of the @var{sets}, and the return value may or may not be @code{eq} to one of them. Signals a @code{type-error} if any of the @var{sets} are not @code{hash-set}s. @example
@group
(coerce
(hash-set-elements
(hash-set-union
(apply #’hash-set (coerce "abcdef" ’list))
(apply #’hash-set (coerce "ACEG" ’list))))
’string)
@result{} "FaeGbcd"
(hash-set-empty-p (hash-set-union)) @result{} t
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: in-course-p ROW

True if and only if @var{row} is a @code{row} representing an even permutation. @example
@group
(in-course-p !132546) @result{} t
(in-course-p !214365) @result{} nil
(in-course-p "132546") @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: inverse ()

Returns the inverse of the @code{row} @var{row}. That is, the @code{row}, @var{r}, such that when @var{row} is permuted by @var{r}, the result is rounds. A theorem of group theory implies also that when @var{r} is permuted by @var{row} the result will also be rounds. Signals a @code{type-error} if @var{row} is not a @code{row}.
@example
@group
(inverse !13427586) @result{} !14236857
(inverse !14236857) @result{} !13427586
(inverse !12436587) @result{} !12436587
(inverse !12345678) @result{} !12345678
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: involutionp ROW

True if and only if @var{row} is a @code{row} that is its own inverse. @example
@group
(involutionp !13248765) @result{} t
(involutionp !13425678) @result{} nil
(involutionp nil) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: lookup-method NAME &optional STAGE

===merge: lookup-methods-by-name 1

Package

roan

Source

method.lisp (file)

Function: lookup-methods-by-name NAME &key STAGE LIMIT UPDATE URL DATABASE BUSY-TIMEOUT

===summary===
Roan provides an @url{https://www.sqlite.org/,SQLite database} of method definitions, containing the same methods as in the @url{http://www.ringing.org/methods/,ringing.org web site}. Because use of SQLite requires installation of a binary library, @code{libsqlite3} available from the @url{https://www.sqlite.org/,SQLite web site}, some Roan users may perfer to avoid it. Roan, without any of the facilities in this section for looking up methods, can be loaded by using the system @code{roan-base} instead of the full @code{roan}. Everything else in Roan should work fine without the lookup functions, and any calls to them will result in an error indicating that they are not loaded.

In addition to all the methods recognized by the CCCBR at the time Roan’s database was last updated, the database also contains a variety of methods not CCCBR recognized, or, in some cases, with names or classifications differing from those with the CCCBR’s imprimatur. For example, it contains methods with jump changes; methods that the Council does not consider distinct from others (for example, New Grandsire); sometimes attaches commonly-used names to methods in addition to those blessed by the Council (for example, what the Council calls Bastow Little Bob Doubles is in the database under that name, and also under St Helen’s Doubles and Cloister Doubles); and methods that were disavowed by the Council because they were rung and named in a peal that did not meet the Council’s requirements at the time is was rung (for example, Brindle Bob Royal, which itself met the Council’s requirements at the time it was rung in spliced, but the peal contained another method, then illegal but now perfectly acceptable even to the Council). While this database does extend what the Central Council’s collection of methods provides, it is still not as complete and comprehensive as it could be, though I hope it is at least helpful.

This database can be interrogated with the @code{lookup-methods-by-name}, @code{lookup-method}, @code{lookup-methods-by-notation} and @code{lookup-methods-from-changes} functions.

The methods in the database provided by Roan are a collation of methods extracted from several different sources
@itemize @bullet
@item
The Central Council of Church Bell Ringers Method’s Committee’s @url{http://www.methods.org.uk/,,collection of methods}. This collection is copyright by the Central Council of Church Bell Ringers, and the method definitions extracted from it have been modified: their place notation and other details have been reformated, and they have been merged with method definitions from other sources.

@item
Tony Smith’s
@url{http://www.methods.org.uk/supplement/provisionally-named/intro.txt,,
Collection of Provisionally Named Methods}. This collection is copyright by Tony Smith, and the method definitions extracted from it have been modified: their place notation and other details have been reformated, and they have been merged with method definitions from other sources.

@item
The Central Council’s 1988 @emph{Collection of Plain Methods},

@item
Steven Coleman’s @emph{The Method Ringer’s Companion}, 1995,

@item
Peter Hinton’s @url{http://www.cambridgeringing.info/Methods/Doubles/DoublesMethods-index.htm,, Palindromic Plain Doubles Methods} web page,

@item
a variety of helpful messages on the @url{http://www.bellringers.net/mailman/listinfo/ringing-theory_bellringers.net,, ringing-theory mailing list},

@item and tradition and word of mouth.
@end itemize
===endsummary===
The @code{lookup-methods-by-name} function returns a list of @code{method}s of a given @var{stage} and with a name matching @var{name}, or an empty list if there are no such methods in the database. If the @var{stage} argument is not provided it defaults to the current value of @code{*default-stage*}. Comparison is done case-insensitively. Note that, just like for @code{method} objects, the name in this function is not the same as the name in the CCCBR’s taxonomy: it includes what the CCCBR calls the class as well as appropriate modifiers such as “Differential” and “Little”. That is, for purposes of this function, the name is the method’s entire title with the stage removed. So, for example, the name of Cambridge Surprise Major is “Cambridge Surprise”, and that of Baldrick Differential Little Bob Cinques is “Baldrick Differential Little Bob”.

The @var{name} argument to @code{lookup-methods-by-name} can include wildcard characters: @samp{?} matches any one character, and @samp{*} matches any sequence of zero or more characters. To include a @samp{?} or @samp{*} in a string, not as a wildcard, escape it with a backslash @samp{\}. Note that in Lisp literal strings you must backslash escape a backslash so you will typically end up with two backslashes. To include a backslash in a @var{name} pattern escape it with a backslash; in a Lisp literal string this will be a total of four backslashes. Any other use of backslash in a @var{name} pattern other than escaping @samp{?}, @samp{*} or @samp{\} signals an error.

For the common case of looking up a single method by name the function @code{lookup-method} is available. If a @code{method} is found it is returned and otherwise @code{nil} is returned. Apart from the @var{name}, which may not contain wildards, and the optiional @var{stage}, which defaults to the current value of @code{*default-stage*}, no other arguments may be supplied. Apart from not allowing wildcards, @code{lookup-method} behaves similarly to @code{lookup-methods-by-name} when @var{limit}, @var{update}, @var{url}, @var{database} and @var{busy-timeout} are all @code{nil} or unsupplied.

The @code{lookup-methods-by-notation} function returns a list of @code{method}s of a given @var{stage} and with a plain lead defined by the place notation @var{notation}, a string, or an empty list if there are no such methods in the database. If
@var{stage} is not supplied it defaults to the current value of @code{*default-stage*}. If the generalized boolean @var{rotations} is true it also returns any methods whose changes are a rotation of those given. While the CCCBR recognizes only one method with any given notation, or rotation thereof, Roan’s database may contain multiple such. Wildcards cannot be used in @var{notation}.

The @code{lookup-methods-from-changes} function returns a list of @code{method}s with a given list of @var{changes} constituting its plain lead. All the elements of the list @var{changes} must be @code{row}s, and be of the same stage. The @var{rotations} argument is as for @code{lookup-methods-by-notation}.

There is no guarantee of what order methods are in the lists returned by any of these three functions.

For any of these functions the @var{limit} keyword argument can be used to limit the number of methods returned. If supplied it should be a positive integer. If @code{nil}, the default, there is no limit.

For any of these functions the @var{update} argument can be used to ask that the database be updated from @url{http://www.ringing.org/methods/,,ringing.org} before querying it. Possible values for @var{update} are:
@table @asis
@item @code{nil} (the default)
no updating is done: whatever version of the database is
already present is used as is

@item @code{:query} or @code{t}
@url{http://www.ringing.org/methods/,ringing.org} is queried
before executing the lookup, and, if it appears the version of the database on the server is more recent than that already on the local machine, a fresh copy is downloaded from the web site and used to replace the version already present

@item a non-negative integer
a time duration, in units of seconds: only if at least this
much time has elapsed since the version on the local machine was created is the server queried and, if a new version is present there, downloaded; the time the database on the server was created is not the same as the created or modified timestamp on the local file, nor the time it was download to the local machine

@item @code{:force}
the most recent version on the server is downloaded, regardless of
whether or not it appears to be any more recent than the version already on the local machine
@end table
An error is signaled if @var{update} has any other value. If the database does not exist on the local machine an @code{error} is signaled if @var{update} is @code{nil}, and otherwise an attempt is made to download and install it.

Unfortunately the libraries required to download and unzip an updated libary do not currently (as of June 2017) work in CLISP or LispWorks. An attempt to update the the database with a non-nil value of @var{update} will signal an error in these Lisp implementations. @xref{update-methods-database}.

The @var{url} argument can be used to specify a different location for downloading a fresh database, if @var{update} indicates that such an action should be taken. If @var{update} is @code{nil}, or otherwise indicates that the server need not be queried, @var{url} is ignored. If @code{nil} the default location is used, and otherwise @var{url} should be a string.

The @var{database} argument enables use of a different database than Roan’s default. It should be a pathname designator for an existing file which is an SQLite database with the same schema as Roan’s default database. @xref{with-methods-database} for further information on such databases. If @var{database} is @code{nil}, the default, Roan’s default location for the database is used.

The @var{busy-timout} argument specifies how long to wait, in milliseconds, for a locked database; if @code{nil}, the default, operations on a locked database fail immediately.

There is no guarantee that any @code{method} object returned by any of these functions is distinct from that returned by a different call to the same one or a different one that needs to return such an object describing the same underlying method. For example, if two different invocations of one or two of these methods are asked to provide a definition for Cambridge Surprise Majoy the resulting @code{method} objects may or may not be @code{eq}, and subsequent changes to one may or may not be reflected in the “other” (since it may or may not be the same one).

A @code{type-error} is signaled if @var{stage} is not a @code{stage}; @var{name} or @var{notation} is not a string; @var{changes} is not a non-empty list of @code{row}s; @var{limit} is neither @code{nil} nor a positive integer; @var{update} is not of any of the types itemized above; @var{url} is neither @code{nil} nor a string; @var{database} is not a pathname designator; or @var{busy-timeout} is neither @code{nil} nor a non-negative integer. A @code{parse-error} is signaled if @var{notation} is a string and is not parseable as place notation at @var{stage}. An @code{error} is signaled if @var{name} contains a @samp{\} followed by anything other than @samp{?}, @samp{*} or @samp{\}; or if @var{changes} is a list of @code{row}s, but they are not all of the same stage.

A variety of SQLite, file system or network errors may be signaled if there is difficulty opening the database file or, if necessary, reaching the server to download a fresh database.
@example
@group
(method-place-notation
(lookup-method "Advent Surprise" 8))
@result{} "36x56.4.5x5.6x4x5x4x7,8"
(method-place-notation
(first (lookup-methods-by-name "A?ve?t Sur*e" :stage 8)))
@result{} "36x56.4.5x5.6x4x5x4x7,8"
@end group
@group
(method-property
(lookup-methods-by-name 8 "Advent Surprise" :stage 8))
:first-tower)
@result{} "1988-07-31 at Boston, Massachusetts, USA (Advent)"
@end group
(lookup-methods-by-name "No-such-method-anywhere" 8) @result{} nil
(lookup-method "No-such-method-anywhere" 9) @result{} nil
(length (lookup-methods-by-name 8 "Advent *")) @result{} 3
@group
(length (lookup-methods-by-name 8 "Advent *" :limit 2))
@result{} 2
@end group
@group
(method-title
(first
(lookup-methods-by-notation 8 "36x56.4.5x5.6x4x5x4x7,8")))
@result{} "Advent Surprise Major"
@end group
(method-title
(first (lookup-methods-by-changes ’(!214365 !132546))))
@result{} "Original Minor"
@group
(mapcar #’method-title
(lookup-methods-by-notation 5 "5,1.3.1"))
@result{} ("Bastow Little Bob Doubles"
"Cloister Doubles"
"St Helen’s Doubles")
@end group
@group
(mapcar #’method-title
(lookup-methods-by-notation "3,1.5.1.5.1"
:stage 5
:rotations nil))
@result{} ("Grandsire Doubles")
@end group
@group
(mapcar #’method-title
(lookup-methods-by-notation "3,1.5.1.5.1"
:stage 5
:rotations t))
@result{} ("Grandsire Doubles" "New Grandsire Doubles")
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: lookup-methods-by-notation PLACE-NOTATION &key STAGE ROTATIONS LIMIT UPDATE URL DATABASE BUSY-TIMEOUT

===merge: lookup-methods-by-name 2

Package

roan

Source

method.lisp (file)

Function: lookup-methods-from-changes CHANGES &key ROTATIONS LIMIT UPDATE URL DATABASE BUSY-TIMEOUT

===merge: lookup-methods-by-name 3

Package

roan

Source

method.lisp (file)

Function: make-hash-set &rest KEYS &key SIZE REHASH-SIZE REHASH-THRESHOLD INITIAL-ELEMENTS

===lambda: (&key size rehash-size rehash-threshold initial-elements)
Returns a new @code{hash-set}. If @var{initial-elements} is supplied and non-nil,
it must be a list of elements that the return value will contain; otherwise an empty set is returned. If any of @var{size}, @var{rehash-size} or @var{rehash-threshold} are supplied they have meanings analagous to the eponymous arguments to @code{make-hash-table}.

Package

roan

Source

util.lisp (file)

Function: make-match-counter &optional STAGE

Returns a fresh @code{match-counter}, initially containing no patterns, that is configured to attempt to match patterns against @code{row}s of @var{stage} bells. If not supplied, @var{stage} defaults to the current value of @code{*default-stage*}. Attempts to add patterns only appropriate for a different stage or match rows of a different stage with @code{record-matches} will signal an error.

Package

roan

Source

pattern.lisp (file)

Function: map-hash-set FUNCTION SET

Calls @var{function} on each element of the @code{hash-set} @var{set}, and returns @code{nil}. The order in which the elements of @var{set} have @var{function} applied to them is undefined. With one exception, the behavior is undefined if @var{function} attempts to modify the contents of @var{set}: @var{function} may call @code{hash-set-delete} to delete the current element, but no other. A @code{type-error} is signaled if @var{set} is not a @code{hash-set}.
@example
@group
(let ((r nil))
(map-hash-set #’(lambda (e)
(push (list e (in-course-p e)) r))
(hash-set !135246 !123456 !531246))
r)
@result{} ((!135246 nil) (!531246 nil) (!123456 t))
@end group
@end example

Package

roan

Source

util.lisp (file)

Function: match-counter-counts COUNTER &optional LABEL

Returns three values, the number of times the pattern with label @code{equalp} to @var{label} in @var{counter} has matched @code{row}s presented to it with @code{record-matches} since @var{counter} was reset or the relevent pattern was added to it. The first return value is the total number of matches, the second the number of matches at handstroke, and the third the number of matches at backstroke. If no @var{label} is supplied it instead returns three a-lists mapping the labels of the patterns in @var{counter} to the number of matches, again total, handstroke and backstroke. The elements of these a-lists are in the order in which the corresponding patterns were first added to @var{counter}. Returns @code{nil} if there is no pattern labeled @var{label}. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Function: match-counter-handstroke-p COUNTER

Returns a generalized boolean indicating that the next row presented to @var{counter} will be a handstroke. Can be used with @code{setf} to tell @var{counter} whether or not it should consider the next row a handstroke or a backstroke. If not explicitly set again, either with @code{(setf match-counter-handstroke-p)}, or with the @var{handstroke-p} argument to @code{record-matches}, whether or not subsequent rows will be considered handstroke or backstroke will alternate. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Setf Expander

(setf match-counter-handstroke-p) (setf expander)

Setf Expander: (setf match-counter-handstroke-p) COUNTER
Package

roan

Source

pattern.lisp (file)

Reader

match-counter-handstroke-p (function)

Function: match-counter-labels COUNTER

Returns two lists, the labels of those patterns in @var{count} that are matched against a single row, and those that are matched against two rows. Both lists are in the order in which the corresponding patterns were first added to @var{counter}. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Function: match-counter-pattern COUNTER LABEL &optional AS-STRING UPPER-CASE

Returns two values: the first is the pattern whose label in @var{count} is @code{equalp} to @var{label}, if any, and otherwise @code{nil}; the second is a generalized boolean if and only if the first value is non-nil and the pattern is to be matched against two rows rather than just one. If the generalized boolean @var{as-string} is true the pattern is returned as a string, as by @code{format-pattern}, with the case of any bells represented by letters controled by the generalized boolean @var{upper-case}; and otherwise as a parse tree, as by @code{parse-pattern}. A string return value may not be @code{string-equal} to that added to @var{counter}, but will match the same @code{row}s. If @var{as-string} is not supplied it defaults to true; if @var{upper-case} is not supplied it defaults to the current value of @code{*print-bells-upper-case*}. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Function: match-counter-stage INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: method &key TITLE STAGE NAME PLACE-NOTATION PROPERTIES

Creates a new @code{method} instance, with the specified @var{stage}, @var{name} @var{place-notation} and @var{properties}. If @var{title} is supplied it provides default values for @var{name} and @var{stage} if none are explicitly provided or are @code{nil}. If @var{stage} is not provided, and no default is provided by @var{title}, it defaults to the current value of @code{*default-stage*}. A @code{type-error} is signaled if @var{stage} is supplied and is neither @code{nil} nor a @code{stage}; if any of @var{name}, @var{title} or @var{place-notation} are supplied and are neither @code{nil} nor a string; or if @code{properties} is supplied and is not a list.

Package

roan

Source

method.lisp (file)

Function: method-canonical-rotation-key METHOD

If @var{method} has its stage and place notation set returns a string uniquely identifying, using @code{equal}, the changes of a lead of this method, invariant under rotation. That is, if two methods are rotations of one another their @code{method-canonical-rotation-key}s will always be @code{equal}. The string is, other than being a string, essentially an opaque type and should generally not be displayed to an end user or otherwise have its structure depended upon. Case is significant; @code{equalp} should not be used to compare these keys. While, within one version of Roan, this key can be counted on to be the same in different sessions and on different machines, it may change between versions of Roan. If @var{method} does not have both its stage and place notation set @code{method-canonical-rotation-key} returns @code{nil}.

Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if @var{method}’s place notation cannot be properly parsed at its stage.
@example
@group
(method-canonical-rotation-key
(lookup-method "Cambridge Surprise" 8))
@result{} "bAvzluTjWO5P"
(method-canonical-rotation-key
(method :stage 8 :place-notation "5x6x7,x4x36x25x4x3x2"))
@result{} "bAvzluTjWO5P"
(method-canonical-rotation-key
(method :stage 8 :place-notation "x1x4,2"))
@result{} "bEvy3Zo"
(method-canonical-rotation-key
(method :stage 10 :place-notation "x1x4,2"))
@result{} "Oi3Jd2sC"

(method-canonical-rotation-key (method) @result{} nil
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-changes METHOD

If @var{method}’s stage and place-notation have been set returns a fresh list of @code{row}s, representing changes, that constitute a plain lead of @var{method}, and otherwise returns @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-changes (method :stage 6
:place-notation "x2,6"))
@result{} (!214365 !124365 !214365 !132546)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-classification METHOD

If @var{method} has had its stage and place-notation set returns a list of keywords
describing how it fits into the CCCBR’s taxonomy of methods (see @url{http://www.methods.org.uk/ccdecs.htm,Central Council’s Decisions}), and otherwise @code{nil}. In the absence of jump changes the first element of the result will be one of @code{:principle}, @code{:bob}, @code{:place}, @code{:slow-course}, @code{:treble-bob}, @code{:delight}, @code{:surprise}, @code{:treble-place}, @code{:alliance} or
@code{:hybrid}. This may be followed by @code{:differential} and/or @code{:little}, if appropriate. While the CCCBR considers “differentials” as a distinct class from “principles”, what the CCCBR calls a pure “differential” is here described as @code{(:principle :differential)}, in parallel with with “differential
hunters@footnote{No, “differential hunter” is not a description of an infintesimal horse used for sport, it is an unattractive name for a meta-class of methods. See the CCCBR Decisions for further details.}” Note that a principle, whether or not differential, can never be
little.

The CCCBR’s taxonomy deals only with methods not containing jump changes, and it is not at
all clear how it should be extended to deal with methods that do contain them. Therefore @code{method-classificaiton} simply returns @code{(:jump)} for any such methods, and never appends @code{:differential} or @code{:little} to such a classification. Be careful when constructing the titles of such methods as the bands that have rung them have sometimes
used more complex names, such as “treble jump” to describe them.

The CCCBR’s taxonomy unfortunately does contain some ambiguities around unusual methods;
for example little treble dodging methods containing multiple hunt bells with different
cross section locations. The @code{method-classification} function will take its best
guess in such cases, but there is no guarantee that what it returns is how the Council
will end up classifying such methods if they are rung and named.

Signals a @code{type-error} if @var{method} is not a @code{method}, and a
@code{parse-error} if its place-notation cannot be parsed at its stage.

See also @ref{set-method-classified-name} and @ref{method-hunt-bells}.
@example
@group
(method-classification (method :stage 8
:place-notation "x3x4x2x34,2")
@result{} (:surprise :little)
(method-classification (method :stage 11
:place-notation "3.1.E.3.1.3,1")
@result{} (:principle)
(method-classification (method :stage 12
:place-notation "58x1x67x67x49x,x")
@result{} (:hybrid :differential :little)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-contains-jump-changes METHOD

If @var{method}’s stage and place-notation have been set and method contains one or more jump changes returns true, and otherwise returns @code{nil}. Note that even if the place notation is set and implies jump changes, if the stage is not set @code{method-contains-jump-changes} will still return @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-contains-jump-changes
(method :place-notation "x3x4x2x3x4x5,2"
:stage 6))
@result{} nil
(method-contains-jump-changes
(method :place-notation "x3x(24)x2x(35)x4x5,2"
:stage 6))
@result{} t
(method-contains-jump-changes
(method :stage 6))
@result{} nil
(method-contains-jump-changes
(method :place-notation "x3x(24)x2x(35)x4x5,2"
:stage nil))
@result{} nil
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-course-length METHOD

If @var{method}’s stage and place-notation have been set returns a positive integer, the length of a plain course of @var{method}, and otherwise @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-course-length
(method :title "Cambridge Surprise Minor"
:place-notation "x3x4x2x3x4x5,2"))
@result{} 120
(method-course-length
(method :title "Cromwell Tower Block Minor"
:place-notation "3x3.4x2x3x4x3,6"))
@result{} 24
(method-course-length
(method :title "Bexx Differential Bob Minor"
:place-notation "x1x1x23,2"))
@result{} 72
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-falseness METHOD

Computes the most commonly considered kinds of internal falseness of the most common methods: those at even stages major or higher with a single hunt bell, the treble, and all the working bells forming one cycle, that is, not differential. Falseness is only considered with the treble fixed, as whole leads, and, for stages royal and above, with the seventh (that is, the bell roan denotes by @code{6}) and above fixed. Returns three values: a summary of the courses that are false; for methods that have Plain Bob lead ends and lead heads and the usual palindromic symmetry, the false course head groups that are present; and a description of the incidence of falseness.

The first value is a list of course heads, @code{row}s that have the treble and tenors fixed, such that the plain course is false against the courses starting with any of these course heads. Rounds is included only if the falseness occurs between rows at two different positions within the plain course. Course heads for major have just the tenor (that is, the bell represented in Roan by the integer @code{7}) fixed, while course heads for higher stages have all of the seventh and above (that is, bells represented in Roan by the integers @code{6} and larger) fixed in their rounds positions.

If @var{method} has Plain Bob lead ends and lead heads, and the usual palindromic symmetry, the second value returned is a list of @code{fch-group} objects, and otherwise the second value is @code{nil}. Note also that for methods that are completely clean in the context used by this function, for example plain royal methods, an empty list also will be returned. These two cases can be disambiguated by examining the first value returned.

There is some ambiguity in the interpretation of “A” falseness. In Roan a method is only said to have “A” falseness if its plain course is false. That is, the trivial falseness implied by a course being false against itself and against its reverse by virtue of containing exactly the same rows is not reported as “A” falseness. “A” falseness is only reported if there is some further, not-trivial falseness between rows at two different positions within the plain course.

The third value returned is a two dimensional, square array, each of the elements of that array being a possibly empty list of course heads. For element @var{e}, the list at @var{m},@var{n} of this array, lead @var{m} of the plain course of @var{method} is false against lead @var{n} of each of the courses starting with an element of @var{e}. The leads are counted starting with zero. That is, if @var{s} is the stage of @var{method}, then 0≤@var{m}<@var{s}-1 and 0≤@var{n}<@var{s}-1.

A @code{type-error} is signaled if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage. If @var{method} does not have its stage or place-notation set a @code{no-place-notation-error}. If @var{method} is not at an even stage major or above, does not have one hunt bell, the treble, or is differential, an @code{inappropriate-method-error} is signaled.
@example
@group
(multiple-value-bind (ignore1 groups ignore2)
(method-falseness
(method :stage 8
:place-notation "x34x4.5x5.36x34x3.2x6.3,8"))
(declare (ignore ignore1 ignore2)
(fch-groups-string groups))
@result{} "BDacZ"
(fch-groups-string
(second
(multiple-value-list
(method-falseness
(lookup-method "Zorin Surprise" 10)))))
@result{} "T/BDa1c"
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-hunt-bells METHOD

If @var{method}’s stage and place-notation have been set @code{method-hunt-bells}
returns a fresh list of @code{bell}s (that is, small integers, with the treble represented by zero) that are hunt bells of @var{method} (that is, that return to their starting place at each lead head), and otherwise returns @code{nil}. The bells in the list are ordered in increasing numeric order. Note that for a method with no hunt bells this function will also return @code{nil}.

The CCCBR’s taxonomy of methods is largely driven by a division of hunt bells into “principal” hunt bells and “secondary” hunt bells (see the @url{http://www.methods.org.uk/ccdecs.htm,Central Council’s Decisions} for details). The @code{method-principal-hunt-bells} and @code{method-secondary-hunt-bells} functions return lists, again ordered in increasing numeric order, of these hunt bells. The lists returned by these two functions are disjoint, and, in the absence of jump changes, their union consists exactly of the contents of the list returned by @code{method-hunt-bells}. The CCCBR’s taxonomy, and its definitions of principal and secondary hunt bells, is predicated on the absence of jump changes, and it is not clear how they would best be extended for methods with jump changes. The @code{method-principal-hunt-bells} and @code{method-secondary-hunt-bells} functions therefore return @code{nil} for any methods containing jump changes; however, @code{method-hunt-bells} can still be usefully used for such methods. Note that @code{method-principal-hunt-bells} and @code{method-secondary-hunt-bells} also return @code{nil} for methods without jump changes that do not contain any of the relevant hunt bells, as well as for methods that have not had both their stage and place-notation set.

All three of these functions ignal a @code{type-error} if @var{method} is not a @code{method}, and signal a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-hunt-bells (method :stage 5
:place-notation "3,1.5.1.5.1"))
@result{} (0 1)
(method-principal-hunt-bells (method :stage 5
:place-notation "3,1.5.1.5.1"))
@result{} (0 1)
(method-secondary-hunt-bells (method :stage 5
:place-notation "3,1.5.1.5.1"))
@result{} nil
(method-principal-hunt-bells (method :stage 5
:place-notation "5.1.5.1.125,2"))
@result{} (0)
(method-secondary-hunt-bells (method :stage 5
:place-notation "5.1.5.1.345,2"))
@result{} (1)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-lead-count METHOD

If @var{method}’s stage and place-notation have been set returns a positive integer, the number of leads in a plain course of @var{method}, and otherwise @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-lead-count
(method :title "Cambridge Surprise Minor"
:place-notation "x3x4x2x3x4x5,2"))
@result{} 5
(method-lead-count
(method :title "Cromwell Tower Block Minor"
:place-notation "3x3.4x2x3x4x3,6"))
@result{} 1
(method-lead-count
(method :title "Bexx Differential Bob Minor"
:place-notation "x1x1x23,2"))
@result{} 6
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-lead-head METHOD

If @var{method}’s stage and place-notation have been set returns a @code{row}, the lead head generated by one plain lead of @var{method}, and otherwise @code{nil}. If @var{method} has a one lead plain course the result will be rounds. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-lead-head (method :stage 8
:place-notation "x1x4,2"))
@result{} !16482735
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-lead-head-code METHOD

Returns the lead head code for @var{method} if its stage and place notation are set and it has Plain Bob lead ends, and otherwise returns @code{nil}. Considers neither twin hunt methods, such as Grandsire, nor any method below minimus, as having Plain Bob lead ends, and Rounds is not considered a Plain Bob lead head. When not @code{nil} the result is a string containing a lower case letter, possibly followed by a digit.

The CCCBR’s various collections of methods have, for several decades, use succinct codes to denote the combination of a Plain Bob lead head and the change that leads to
it (@url{http://methods.org.uk/online/notes.htm}). While officially just a convention for these collections it has become a de facto standard. Unfortunately these codes are not precisely defined, and there are ambiguities for some uncommon hunt paths. Consequently this function only returns a non-@code{nil} result for single hunt, non-hybrid methods, including little methods, that do not contain any jump changes. Thus there are cases where a code is used in a CCCBR collection, but not returned by @code{method-lead-head-code}. It is also worth noting that for odd stages there are Plain Bob lead heads for which the CCCBR does not define any code; when called on such a method @code{method-lead-head-code} also returns @code{nil}.

Signals a @code{type-error} if @var{method} is not a @code{method}, and a @code{parse-error} if @var{method}’s place notation cannot be interpreted at its stage.
@example
@group
(method-lead-head-code
(lookup-method "Ashtead Surprise" 8))
@result{} "d"
(method-lead-head-code
(lookup-method "Zanussi Surprise" 12))
@result{} "j2"
(method-lead-head-code
(lookup-method "Twerton Little Bob" 9))
@result{} "q1"
(method-lead-head-code
(lookup-method "Double Glasgow Surprise" 8))
@result{} nil
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-lead-length METHOD

If @var{method}’s stage and place-notation have been set returns a positive integer, the length of one lead of @var{method}, and otherwise @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-lead-length
(method :title "Cambridge Surprise Minor"
:place-notation "x3x4x2x3x4x5,2"))
@result{} 24
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-plain-course METHOD

If @var{method}’s stage and place-notation have been set returns a fresh list of the @code{row}s that constitute a plain course of @var{method}, and otherwise @code{nil}. The list returned will start with rounds, and end with the @code{row} immediately preceding the final rounds. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.

Package

roan

Source

method.lisp (file)

Function: method-plain-lead METHOD

If @var{method}’s stage and place-notation have been set returns a fresh list of @code{row}s, starting with rounds, that constitute the first lead of the plain course of @var{method}, and otherwise returns @code{nil}. The lead head that starts the next lead is not included. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-plain-lead (method :stage 6
:place-notation "x2,6"))
@result{} (!123456 !214365 !213456 !124365)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-principal-hunt-bells METHOD

===merge: method-hunt-bells 1

Package

roan

Source

method.lisp (file)

Function: method-property METHOD KEY &optional DEFAULT

Returns the property attached to @var{method} with the given @var{key}, if there is one, and otherwise returns @var{default}, or @code{nil} if no @var{default} is supplied. Can be used with @code{setf} to change a property. Signals a @code{type-error} if @var{method} is not a @code{method}. Just a short-hand for, and equivalent to, @code{(getf (method-properties @var{method}) @var{key} @var{default})}.
@example
@group
(let ((m (method :title "Advent Surprise Major")))
(setf (method-property m :first-rung) "1988-07-31")
(method-property m :first-rung))
@result{} "1988-07-31"
@end group
@end example

Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-property) (setf expander)

Setf Expander: (setf method-property) METHOD KEY &optional DEFAULT
Package

roan

Source

method.lisp (file)

Reader

method-property (function)

Function: method-rotations-p METHOD-1 METHOD-2

Returns true if and only if the changes constituting a lead of @var{method-1} are the same as those constituting a lead of @var{method-2}, possibly rotated. If the changes are the same even without rotation that is considered a trivial rotation, and also returns true. Note that if @var{method-1} and @var{method-2} are of different stages the result will always be false.

Signals a @code{no-place-notation-error} if either argument does not have its stage or place notation set. Signals a @code{type-error} if either argument is not a @code{method}. Signals a @code{parse-error} if the place notation of either argument cannot be parsed as place notation at its stage.
@example
@group
(method-rotations-p
(method :stage 5 :place-notation "3,1.5.1.5.1")
(method :stage 5 :place-notation "5.1.5.1,1.3"))
@result{} t
(method-rotations-p
(method :stage 5 :place-notation "3,1.5.1.5.1")
(method :stage 5 :place-notation "3,1.5.1.5.1"))
@result{} t
(method-rotations-p
(method :stage 5 :place-notation "3,1.5.1.5.1")
(method :stage 5 :place-notation "3,1.3.1.5.1")
@result{} nil
(method-rotations-p
(method :stage 5 :place-notation "3,1.5.1.5.1")
(method :stage 7 :place-notation "5.1.5.1,1.3"))
@result{} nil)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-secondary-hunt-bells METHOD

===merge: method-hunt-bells 2

Package

roan

Source

method.lisp (file)

Function: method-title METHOD &optional SHOW-UNKNOWN

Returns a string containing as much of the @var{method}’s title as is known. If @var{show-unknown}, a generalized boolean defaulting to false, is not true then an unknown name is described as "Unknown", and otherwise is simply omitted. If neither the name nor the stage is known, and @var{show-unknown} is @code{nil}, then @code{nil} is returned instead of a string. Can be used with @code{setf}, in which case it potentially sets both the name and stage of @var{method}.
@example
@group
(method-title (method :stage 8 :name "Advent Surprise"))
@result{} "Advent Surprise Major"
(method-title (method :stage 8))
@result{} "Major"
(method-title (method :stage 8) t)
@result{} "Unknown Major
(method-title (method :stage nil :name "Advent Surprise"))
@result{} "Advent Surprise"
(method-title (method :stage nil))
@result{} nil
@end group
@end example

Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-title) (setf expander)

Setf Expander: (setf method-title) METHOD &optional SHOW-UNKNOWN
Package

roan

Source

method.lisp (file)

Reader

method-title (function)

Function: method-true-plain-course-p METHOD &optional ERROR-IF-NO-PLACE-NOTATION

If @var{method} has a non-nil stage and place notation set, returns true if @var{method}’s plain course is true and @code{nil} otherwise. If @var{method} does not have a non-nil stage or place notation a @code{no-place-notation-error} is signaled if the generalized boolean @var{error-if-no-place-notation} is true, and otherwise @code{nil} is returned; if @var{error-if-no-place-notation} is not supplied it defaults to true. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-true-plain-course-p
(method :title "Little Bob Minor"
:place-notation "x1x4,2"))
@result{} t
(method-true-plain-course-p
(method :title "Unnamed Little Treble Place Minor"
:place-notation "x5x4x2,2"))
@result{} nil
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: method-working-bells METHOD

If @var{method}’s stage and place-notation have been set returns a list of lists of @code{bell}s (that is, small integers, with the treble represented by zero) that are working bells of @var{method} (that is, that do not return to their starting place at each lead head), and otherwise returns @code{nil}. The sublists each represent a cycle of working bells. For example, for a major method with Plain Bob lead heads, there will be one sublist returned, of length seven, containing the bells 1 through 7; while for a differential method there will be at least two sublists returned. Each of the sublists is ordered starting with the smallest bell in that sublist, and then in the order the place bells follow one another in the method. Within the overall, top-level list the sublists are ordered such that the first element of each sublist occur in increasing numeric order. Note that for a method with no working bells (which will then have a one lead plain course) this function also returns @code{nil}. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{parse-error} if the place notation string cannot be properly parsed as place notation at @var{method}’s stage.
@example
@group
(method-working-bells (method :stage 7
:place-notation "7.1.7.47,27"))
@result{} ((1 4 5) (2 6 3))
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: methods-database-attributes &optional DATABASE

Returns five values describing the Roan methods database:
@itemize
@item
the truename of the database file

@item
the date and time the database was created, as a univeral time; note that this will typically not be be same as the time the file was created nor the time it was downloaded

@item
a string (the ETag) representing that state of the file on the server, typically used to determine if an updated version is available

@item
the number of methods (that is, distinct stage and name pairs) that the database contains

@item
a vector, indexed by stage, of the number methods at each stage that the database contains
@end itemize
If @var{database} does not name a database currently on the local machine a single value, @code{nil}, is returned. If @var{database} is @code{nil} or not supplied the default location for Roan’s database is used.

Signals a @code{type-error} if @var{database} is neither @code{nil} nor a pathname designator. May also signal a variety of file system or SQLite errors if the database cannot be opened or is not in the correct format.

Package

roan

Source

method.lisp (file)

Function: order ROW

Returns a positive integer, the order of @var{row}: the minimum number of times it must be permuted by itself to produce rounds. A @code{type-error} is signaled if @var{row} is not a @code{row}.
@example
@group
(order !13527486) @result{} 7
(order !31256784) @result{} 15
(order !12345678) @result{} 1
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: parse-method-title STRING

Returns two values, the method name and the stage extracted from @var{string}, if they are present. If one or both components is missing @code{nil} is returned as the corresponding value. Signals a @code{type-error} if @var{string} is neither a non-empty string nor @code{nil}.
@example
@group
(multiple-value-list
(parse-method-title "Advent Surprise Major"))
@result{} ("Advent Surprise" 8)
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: parse-pattern PATTERN &optional STAGE

Converts a string representation of a pattern to its parse tree, and returns it. The @var{stage} is the stage for which @var{pattern} is parsed, and defaults to @code{*default-stage*}. If @var{pattern} is a non-empty list it is presumed to be a pattern parse tree and is returned unchanged. Signals a @code{type-error} if @var{pattern} is neither a string nor a non-empty list, or if @var{stage} is not a @code{stage}. Signals a @code{parse-error} if @var{pattern} is a string but cannot be parsed as a pattern, or contains bells above those appropriate for @var{stage}.
@example
@group
(parse-pattern "(?[234]*|*4-9%4?)*T" 12)
@result{}
(:sequence (:or (:sequence :one (:class 1 2 3) :any)
(:sequence :any (:run 3 8 4 t) :one))
:any
11)
@end group
@end example

Package

roan

Source

pattern.lisp (file)

Function: parse-place-notation STRING &key STAGE START END JUNK-ALLOWED

===summary===
@cindex Lisp reader
@cindex reader macro
@cindex sharp bang
@cindex @code{#!} reader macro
@cindex place notation
@cindex palindromes
@cindex jump changes
@cindex involutions
@cindex London Treble Jump Minor
@cindex parentheses
@cindex brackets
@cindex @samp{(} in place notation
@cindex @samp{[} in place notation
@cindex dot
@cindex @samp{.} in place notation
@cindex comma
@cindex @samp{,} in place notation
@cindex @samp{x} in place notation
@cindex @samp{-} in place notation
@cindex @samp{)} following place notation
@cindex quote
Place notation manipulated by Roan is extended to support jump changes and comma as an unfolding operator for easy notation of palindromic sequences of changes.

Jump changes may be included in the place notation in two ways. Within changes may appear parenthesized pairs of places, indicating that the bell in the first place jumps to the second place. Thus the change (13)6 corresponds to the jump change 231546. As usual implied leading or lying places may be omitted, so that could also be written simply (13). However, just as with ordinary place notation, all internal places must be noted explicitly; for example, the change (13)(31) is illegal, and must be written (13)2(31). Using this notation the first half-lead of London Treble Jump Minor can be written 3x3.(24)x2x(35).4x4.3.

Jump changes may also be written by writing the full row between square brackets. So that same half-lead of London Treble Jump Minor could instead be notated 3x3[134265]x2x[214536]4x4.3. Or they can be mixed 3x3[134265]x2x(35).4x4.3.

Palindromes may be conveniently notated using a comma operator, which means the changes preceding the comma are rung backwads, following the last of the changes before the comma, which is not repeated; followed by the changes following the comma, similarly unfolded. Thus x3x4,2x3 is equivalent to x3x4x3x2x3x2. A piece of place notation may include at most one comma. Neither the changes before the comma nor after it may be empty. Any piece of place notation including a comma is necessarily of even length.

If jump changes appear in place notation that is being unfolded then when rung in reverse the jump changes are inverted; this makes no difference to ordinary changes, which are always involutions, but is important for jump changes that are not involutions. If the central change about which the unfolding operation takes place, that is the last change in a sequence of changes being unfolded, is not an involution an error is signaled. As an example, a plain lead of London Treble Jump Minor can be notated as 3x3.(24)x2x(35).4x4.3,2 which is equivalent to 3x3.(24)x2x(35).4x4.3.4x4.(53)x2x(42).3x3.2.

While place notation is normally written using dots (full stops) only between non-cross changes, @code{parse-place-notation} will accept, and ignore, them between any changes, adjacent to other dots, and before and after place notation to be parsed. This may simplify operation with other software that emits place notation with extraneous dots.

Just as Roan augments the Lisp reader with @samp{!} to read @code{row}s, it augments it with the @samp{#!} reader macro to read place notatation. The stage at which the place notation is to be interpreted can be written as an integer between the @samp{#} and the @samp{!}. If no explict stage is provided the current value (at read time) of @code{*default-stage*} is used. The sequence of place notation must be followed by a character that cannot appear in place notation, such as whitespace, or by end of file. There is an exception that an unbalanced close parenthesis will also end the reading; this allows using this to read place notation in lists and vectors without requiring whitespace following the place notation. The place notation may be extended with the comma unfolding operator, and with jump changes. The stage at which the place notation is being iterpreted is not considered in deciding which characters to consume; all that might apply as place notation at any stage will be consumed. If some are not appropriate an error will only be signaled after all the continguous, place notation characters have been read.

Note that, unlike @code{row}s, which are Lisp atoms, the result of reading place notation is a list, so @samp{#!} quotes it. This is appropriate in the usual case where the result of @samp{#!} is evaluated, but if used in a context where it is not evaluated care must be exercised.
@example
@group
ROAN> #6!x2,1
(!214365 !124365 !214365 !132546)
ROAN> ’(symbol #6!x2,1 x #6!x2x1)
(SYMBOL ’(!214365 !124365 !214365 !132546) X
’(!214365 !124365 !214365 !132546))
ROAN> ‘(symbol ,#6!x2,1 x ,#6!x2x1)
(SYMBOL (!214365 !124365 !214365 !132546) X
(!214365 !124365 !214365 !132546))
ROAN> #6!x2
(!214365 !124365)
ROAN> (equalp #10!x1x4,2 #10!x1x4x1x2)
T
ROAN> #6!x3.(13)(64)
(!214365 !213546 !231645)
ROAN> #6!x3.(13).(64)
(!214365 !213546 !231546 !132645)
ROAN> #6!x3[231546](64)
(!214365 !213546 !231546 !132645)
@end group
@end example
===endsummary===
Parses place notation from @var{string}, returning a list of @code{row}s, representing changes, of stage @var{stage}. The place notation is parsed as applying to stage @var{stage}, which, if not supplied, defaults to current value of @code{*default-stage*}. Only that portion of @var{string} between @var{start} and @var{end} is parsed; @var{start} should be a non-negative integer, and @var{end} either an integer larger than @var{start} or @code{nil}, which latter is equivalent to the length of @var{string}. If @var{junk-allowed}, a generalized Boolean, is @code{nil}, the default, @var{string} must consist of the place notation parsed and nothing else; otherwise non-place notation characters may follow the place notation. For purposes of parsing @var{stage} is not initially considered: if the place notation is only appropriate for higher stages it will not terminate the parse even if @var{junk-allowed} is true, it will instead signal an error. Two values are returned. The first is a list of @code{row}s, the changes parsed. The second is the index of the next character in @var{string} following the place notation that was parsed.

If the section of @var{string} delimited by @var{start} and @var{end} does not contain place notation suitable for @var{stage} a @code{parse-error} is signaled. If @var{string} is not a string, @var{stage} is not a @code{stage} or @var{start} or @var{end} are not suitable bounding index designators a @code{type-error} is signaled. @example
@group
(multiple-value-list (parse-place-notation "x2.3" :stage 6))
@result{} ((!214365 !124365 !213546) 4)
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: parse-row STRING &key START END JUNK-ALLOWED

Contructs a @code{row} from the conventional symbols for bells in the section of string @var{string} delimited by @var{start} and @var{end}, possibly preceded or followed by whitespace. The treble can be elided, in which case it is assumed to be leading; a @code{parse-error} is signaled if any other bell is omitted. Bells represented by letters can be either upper or lower case. If @var{string} is not a string a @code{type-error} is signaled. If the generalized boolean @var{junk-allowed} is false, the default, an error will be signaled if additional non-whitespace characters follow the representation of a row. Returns two values: the @code{row} read and a non-negative integer, the index into the string of the next character following all those that were parsed, including any trailing whitespace; if parsing consumed the whole of @var{string}, the second value will be length of @var{string}.

Package

roan

Source

roan.lisp (file)

Function: pattern-parse-error &optional MESSAGE &rest ARGS
Package

roan

Source

pattern.lisp (file)

Function: permute ()

===lambda: (row &rest changes)
Permutes @var{row} by the @var{changes} in turn. That is, @var{row} is first permuted by the first of the @var{changes}, then the resuling row is permuted by second of the @var{changes}, and so on. Returns the row resulting from applying all the changes. So long as one or more @var{changes} are supplied the returned @code{row} is always a freshly created one: @var{row} and none of the @var{changes} are modified (as you’d expect, since they are intended to be viewed as immutable). The @var{row} and all the @var{changes} should be @code{row}s.

At each step of permuting a row by a change, if the row is of higher stage than the change, only the first @var{stage} bells of the row are permuted, where @var{stage} is the stage of the change, all the remaining bells of the row being unmoved. If the row is of lower stage than the change, it is as if the row were extended with bells in their rounds’ positions for all the bells @var{stage} and above. Thus the result of each permuation step is a @code{row} whose stage is the larger of those of the row and the change.

If no @var{changes} are supplied @code{row} is returned. Signals a @code{type-error} if @var{row} or any of the @var{changes} are not @code{row}s.
@example
@group
(permute !34256 !35264) @result{} !145362
(permute !34125 !4321 !1342) @result{} !24315
(permute !4321 !654321) @result{} !651234
(let ((r !13572468))
(list (eq (permute r) r)
(equalp (permute r (rounds 8)) r)
(eq (permute r (rounds 8)) r)))
@result{} (t t nil)
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: permute-by-inverse ()

Equivalent to @code{(permute @var{row} (inverse @var{change}))}. Signals a @code{type-error} if either @var{row} or @var{change} is not a @code{row}. @example
@group
(permute-by-inverse !13456287 !45678123) @result{} !28713456 (permute-by-inverse !54312 !2438756) @result{} !54137862 (permute-by-inverse !762345 !4312) @result{} !6271345
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: place-notation-error PARSING FORMAT-STRING &rest ARGS
Package

roan

Source

roan.lisp (file)

Function: place-notation-string CHANGES &rest KEYS &key COMMA ELIDE CROSS UPPER-CASE ALLOW-JUMP-CHANGES

===lambda: (changes &key comma elide cross upper-case allow-jump-changes)
Returns a string of the place notation representing the list @var{changes}. The arguments are the same as the like named arguments to @code{write-place-notation}. A leading ’#!’ is never included in the result.

Signals a @code{type-error} if any elements of @var{changes} are not @code{row}s. Signals an error if @var{changes} is empty or contains rows of different stages.
@example
@group
(multiple-value-list
(place-notation-string #8!x1x4,1 :elide nil))
@result{} ("x18x14x18x18" nil)
(multiple-value-list
(place-notation-string #8!x1x4,1 :comma t))
@result{} ("x1x4,8" t)
(multiple-value-list
(place-notation-string #8!x1x4,2 :elide :interior))
@result{} ("x18x4x18x18" nil)
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: placesp ROW &rest PLACES

Returns true if and only if @var{row} is a (non-jump) change, with exactly the specified @var{places} being made, and no others. To match a cross at even stages supply no @var{places}.

Signals a @code{type-error} if @var{row} is not a @code{row} or any of @var{places} are not @code{bell}s. Signals an @code{error} if any of @var{places} are not less than the stage of @var{row}, or are duplicated.
@example
@group
(placesp !21354768 2 7) @result{} t
(placesp !21346587 2 7) @result{} nil
(placesp !21354768 2) @result{} nil
(placesp !2135476 2) @result{} t
(placesp !21436587) @result{} t
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: plain-bob-lead-end-p ROW

Returns true if @var{row} is a lead end (that is, the handstroke of the treble’s full lead) of a lead of a plain course of Plain Bob at its stage, and otherwise @code{nil}. For the purposes of this function no @code{row} below minimus can be a Plain Bob lead end. Signals a @code{type-error} if @var{row} is not a @code{row}.
@example
@group
(plain-bob-lead-end-p !124365) @result{} t
(plain-bob-lead-end-p !674523) @result{} t
(plain-bob-lead-end-p !13527486) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: position-of-bell BELL ROW

===merge: bell-at-position

Package

roan

Source

roan.lisp (file)

Function: read-place-notation &optional STREAM STAGE EOF-ERROR-P EOF-VALUE RECURSIVE-P

Reads place notation from a stream, resulting in a list of @code{row}s representing changes. Reads all the consecutive characters that can appear in (extended) place notation, and then tries to parse them as place notation. It accumulates characters that could appear as place notation at any stage, even stages above @var{stage}. The sequence of place notation must be followed by a character that cannot appear in place notation, such as whitespace, or by end of file. There is an exception, in that an unbalanced close parenthesis will also end the read; this allows using this to read place notation in lists and vectors without requiring whitespace following the place notation. The place notation may be extended with the comma unfolding operator, and with jump changes, as in @code{parse-place-notation}. The argument @var{stream} is a character stream open for reading, and defaults to the current value of @code{*standard-input*}; @var{stage} is a @code{stage}, an integer, and defaults to the current value of @code{*default-stage*}; and @var{eof-error-p}, @var{eof-value} and @var{recursive-p} are as for the standard @code{read} function, defaulting to @code{t}, @code{nil} and @code{nil}, respectively. Returns a non-empty list of @code{row}s, all of stage @var{stage}. Signals an error if no place notation constituents are available, if the characters read cannot be parsed
as (extended) place noation at @var{stage}, or if one of the usual errorneous conditions while reading occurs.

Package

roan

Source

roan.lisp (file)

Function: read-row &optional STREAM EOF-ERROR-P EOF-VALUE RECURSIVE-P

Constructs and returns a @code{row} from the conventional symbols for bells read from the @var{stream}. The stage of the row read is determined by the bells present, that is by the largest bell for which a symbol is read. The treble can be elided, in which case it is assumed to be leading; a @code{parse-error} is signaled if any other bell is omitted. Bells represented by letters can be either upper or lower case.

Package

roan

Source

roan.lisp (file)

Function: record-matches COUNTER ROW &optional FOLLOWING-ROW HANDSTROKE-P

Causes all the single-row patterns of @var{counter} to be matched against @var{row}, and, if a @var{following-row} is supplied and not @code{nil}, also all the double-row patterns to be matched against both rows. If the generalized boolean @var{handstroke-p} is supplied it indicates whether @var{row} is to be considered a handstroke or not, and, unless explicitly set again, either with the @var{handstroke-p} argument to @code{record-matches} by with @code{(setf match-counter-handstroke-p)}, whether or not subsequent rows will be considered handroke or backstroke will alternate. That is, supplying a @var{handtroke-p} argument to @code{record-matches} is equivalent to calling @code{(setf match-counter-handstoke-p)} immediately before it. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}, @var{row} is not a @code{row}, or @var{following-row} is neither a @code{row} nor @code{nil}.

Package

roan

Source

pattern.lisp (file)

Function: remove-all-patterns COUNTER

Removes all the patterns in the @code{method-counter} @var{counter}, and returns a positive integer, the number of patterns so removed, if any, or @code{nil} if @var{counter} had no patterns. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Function: remove-pattern COUNTER LABEL

Removes any pattern in @code{method-counter} @var{count} with its label @code{equalp} to @var{label}. Returns @code{t} if such a pattern was found and removed, and @code{nil} otherwise. Signals a @code{type-error} if @var{count} is not a @code{method-counter}.

Package

roan

Source

pattern.lisp (file)

Function: reset-match-counter COUNTER

Resets all the counts associated with all the patterns in @var{counter} to zero. Signals a @code{type-error} if @var{counter} is not a @code{match-counter}.

Package

roan

Source

pattern.lisp (file)

Function: rounds &optional STAGE

Returns a row representing rounds at the given @var{stage}, which defaults to @code{*default-stage*} Signals a @code{type-error} if @var{stage} is not a @code{stage}, that is an integer between @code{+minimum-stage+} and @code{+maximum-stage+}, inclusive.

Package

roan

Source

roan.lisp (file)

Function: roundsp ROW

True if and only if @var{row} is a @code{row} representing rounds at its stage. @example
@group
(roundsp !23456) @result{} t
(roundsp !123546) @result{} nil
(roundsp 123456) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: row &rest BELLS

Constructs and returns a @code{row} containing the @var{bells}, in the order they appear in the argument list. If the treble is not present, it defaults to being the first bell in the row. Duplicate bells or bells other than the treble missing result in an error being signaled.
@example
(row 2 1 3 4 7 6 5) @result{} !13245876
@end example

Package

roan

Source

roan.lisp (file)

Function: row-match-error FORMAT &rest ARGS
Package

roan

Source

pattern.lisp (file)

Function: row-match-p PATTERN ROW &optional FOLLOWING-ROW

===summary===
Roan provides a simple pattern language for matching rows. This is useful, among other things, for counting rows considered particularly musical or unmusical.

A pattern string describes the bells in a row, with several kinds of wildcards and other constructs matching multiple bells. Bells’ names match themselves, so, for example, "13572468" matches queens on eight. A question mark matches any bell, and an asterisk matches runs of zero or more bells. Thus "*7468", at major, matches all twenty-four 7468s, and "?5?6?7?8" matches all twenty-four major rows that have the 5-6-7-8 in the positions they are in in tittums. Alternatives can be separated by the pipe character, @samp{|}. Thus "13572468|12753468" matches either queens or Whittingtons. Concatentation of characters binds more tightly than alternation, but parentheses can be used to group subexpressions. Thus "*(4|5|6)(4|5|6)78" at major matches all 144 combination rollups. When matched against two major rows "?*12345678*?" matches wraps of rounds, but not either row being rounds.

Two further notations are possible. In each case it does not extend what can be expressed, it merely makes more compact something that can be expressed with the symbols already described. The first is a bell class, which consits of one or more bell names within square brackets, and indicates any one of those bells. Thus an alternative way to match the 144 combination rollups at major is "*[456][456]78".

A more compact notation is also available for describing runs of consecutive bells. Two bell symbols separated by a hyphen represent the run of bells from one to the other. Thus "*5-T" matches all rows ending 567890ET. If such a run description is followed by a solidus, @samp{/}, and a one or two digit integer, it matches all runs of the length of that integer that are subsequences of the given run. Thus "*2-8/4" is equivalent to "*(2345|3456|4567|5678)". If instead of a solidus a percent sign, ’%’, is used it matches subsequences of both the run and its reverse. Thus "1-6%4*" matches all little bell runs off the front of length four selected from the bells 1 through 6, and is equivalent to the pattern "(1234|4321|2345|5432|3456|6543)*". There is some possible ambiguity with this notation, in that the second digit of an integer following a solidus or percent sign could be interpreted as a digit or a bell symbol. In these cases it is always interpreted as a digit, but the other use can be specified by using parentheses or a space.

Spaces, but no other whitespace, can be included in patterns. However no spaces may be included within bell classes or run descriptions. Thus " 123 [456] 7-T/3 * " is equivalent to "123[456]7-T/3*", but both "123[ 4 5 6 ]7-T/3*" and
"123[456]7-T / 3*" are illegal, and will cause an error to be signaled.

In addition to strings, patterns may be represented by parse trees, which are simple list structures made up of keywords and bells (that is, small, non-negative integers). Strings are generally more convenient for reading and writing patterns by humans, but parse trees can be more convenient for programmatically generated patterns. The function @code{pattern-parse} converts the string representation of a pattern to such a tree structure. Sequences of elements are represented by lists starting with @code{:sequence}; alternatives by lists starting with @code{:or}; bell classes by lists of the included bells preceded by @code{:class}; runs by a list of the form @code{(:run @var{start} @var{end} @var{length} @var{bi})}, where @var{start} is the starting @code{bell}, @var{end} the ending @code{bell}, @var{length} the length of the run, and @var{bi} is a generalized boolean saying whether or not the runs are bidirectional; @code{bell}s are represented by themselves; and @samp{?} and @samp{*} by @code{:one} and @code{:any}, respectively. The elements of the @code{:sequence} and @code{:or} lists may also be lists themselves, representating subexpressions. For example, the string "(?[234]*|*4-9%4?)*T" is equivalent to the tree
@example
@group
(:sequence (:or (:sequence :one (:class 1 2 3) :any)
(:sequence :any (:run 3 8 4 t) :one))
:any
11)
@end group
@end example
===endsummary===
Determines whether @var{row}, or pair of consecutive @code{row}s, @var{row} and @var{following-row}, match a pattern. If @var{following-row} is supplied it should be of the same stage as @var{row}. The @var{pattern} may be a string or a tree, and should be constructed to be appropriate for the stage of @var{row}; an error is signaled if it contains explicit matches for bells of higher stage than @var{row}. Returns a generalized boolean indicating whether or not @var{pattern} matches.
@example
@group
(row-match-p "*[456][456]78" !32516478) @result{} t
(row-match-p "*[456][456]78" !12453678) @result{} nil
(row-match-p "*[456][456]78" !9012345678) @result{} t
(row-match-p "?*123456*?" !651234 !562143) @result{} t
(row-match-p "?*123456*?" !651234 !652143) @result{} nil
(row-match-p "?*123456*?" !123456) @result{} nil
(row-match-p ’(:sequence :any 6 7) !65432178) @result{} t
(row-match-p ’(:sequence :any 6 7) !23456781) @result{} nil
@end group
@end example

Signals an error if @var{pattern} cannot be parsed as a pattern, if @var{row} is not a @code{row}, if @var{following-row} is neither a @code{row} nor @code{nil}, if @var{pattern} contains bells above the stage of @var{row}, or if @var{following-row} is a @code{row} of a different stage than @var{row}.

Care should be used when matching against two rows. In the usual use case when searching for things like wraps every row typically will be passed twice to this method, first as @var{row} and then as @var{following-row}. A naive pattern might end up matching twice, and thus double counting. For example, if at major "*12345678*" were used to search for wraps of rounds it would match whenever @var{row} or @var{following-row} were themselves rounds, possibly leading to double counting. Instead a search for wraps of rounds might be better done against something like "?*12345678*?".

Package

roan

Source

pattern.lisp (file)

Function: row-string ROW &optional UPPER-CASE

Returns a string representing the @code{row} @var{row}. The case of any bells represented by letters is controlled by @var{upper-case}, a generalized
boolean defaulting to the current value of @code{*print-bells-upper-case*}. Signals a @code{type-error} if @var{row} is not a @code{row}.

Package

roan

Source

roan.lisp (file)

Function: rowp OBJECT
Package

roan

Source

roan.lisp (file)

Function: set-method-classified-name METHOD NAME &optional ERROR-IF-NAMED

If @var{method} has its stage and place notation set, sets its @code{method-name} to be @var{name} suitably augmented with its class and other modifiers, mostly from the CCCBR taxonomy (@pxref{method-classification}). That is, @var{name} will be what the CCCBR calls its “name”, and its @code{method-name} will be set so that its @code{method-title} will usually be as the CCCBR dictates. @var{name} may not be null, but may be an empty string. If @var{method}’s stage or place notation is not set @code{set-method-classified-name} does nothing. Returns @var{method}.

Both because of ambiguities in the CCCBR Decsisions, for example around complex combinations of hunt bell types, and that Roan supports jump changes, there are
some methods that may not be classified exactly as the CCCBR would dictate. Since the CCCBR doesn’t recognize ringing incorporating jump changes there are no standards for the name of methods containing them, and there have been a variety of styles of names applied by those bands that do enjoy them: @code{set-method-classified-name} always just appends “jump” to @var{name}.
methods containing jump changes

If the generalized boolean @var{error-if-named} is true, the default, an error will be signaled if @var{method} already has its name set and that name is not @code{string-equal} to the one @code{set-method-classified-name} will set it to. If @var{error-if-named} is false any existing name will be superseded.

Signals a @code{type-error} if @var{method} is not a @code{method} or if @var{name} is not a string. Signals a @code{parse-error} if @var{method}’s place notation cannot be parsed at @var{method}’s stage. Signals an error if @var{error-if-named} is true, @var{method} already has a name and @code{set-method-classified-name} would change that name. @example
@group
(let ((meth (method :stage 8 :place-notation "x34x45x34,2"))) (set-method-classified-name meth "Trafalgar")
(method-name meth))
@result{} "Trafalgar Differential Little Alliance"
(method-title
(set-method-classified-name
(method :stage 12 :place-notation "x1x4,2")
""))
@result{} "Little Bob Maximus"
(method-title
(set-method-classified-name
(method :stage 9 :place-notation "147.(13)(46)(79)")
"Roller Coaster"))
@result{} "Roller Coaster Jump Caters"
@end group
@end example

Package

roan

Source

method.lisp (file)

Function: stage ROW

The number of @code{bell}s of which the @code{row} @var{row} is a permutation.

Package

roan

Source

roan.lisp (file)

Function: stage-from-name NAME

Returns a stage, a small, positive integer, with its name the same as the string designator @var{name}, or, if there is no stage with such a name, @code{nil}. The determination is made case-insensitively.
@example
@group
(stage-from-name "cinques") @result{} 11
(stage-from-name "no-such-stage") @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: stage-name STAGE

Returns a string, the conventional name for this @var{stage}, capitalized, or @code{nil} if @var{stage} is not an integer corresponding to a supported stage. @example
@group
(stage-name 8) @result{} "Major"
(stage-name 22) @result{} "Twenty-two"
(stage-name (1+ +maximum-stage+)) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: tenors-fixed-p ROW &optional STARTING-AT

Returns true if and only if all the bells of @var{row} at positions @var{starting-at} or higher are in their rounds positions. In the degenerate case of @var{starting-at} being equal to or greater than the stage of @var{row} it returns true. Note that it is equivalent to @code{(not (null (alter-stage @var{row} @var{starting-at})))}. If not supplied @var{starting-at} defaults to @code{6}, that is the position of the bell conventionally called the seven, though represented in Roan by the small integer @code{6}. Signals a @code{type-error} if @var{row} is not a @code{row} or @var{starting-at} is not a non-negative integer.
@example
@group
(tenors-fixed-p !13254678) @result{} t
(tenors-fixed-p !13254678 5) @result{} t
(tenors-fixed-p !13254678 4) @result{} nil
(tenors-fixed-p !54321) @result{} t
(tenors-fixed-p !54321 4) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: update-methods-database &key SINCE FORCE URL DATABASE

Possibly downloads a fresh copy of the methods database from @url{http://www.ringing.org/methods/,the ringing.org server}.

If @var{since} is not @code{nil} it should be a non-negative integer. If fewer than that number of seconds have passed since the database was created, as recorded in the database, @code{update_methods-databse} will return @code{nil} immediately, doing nothing further.

Typically, before downloading the database, @code{update-methods-database} queries the server to see if the copy thereon differs from the local copy, and does not download it if they are the same. If @var{force} is not @code{nil}, however, it will always attempt to download a fresh copy of the database, even if it appears to be unchanged.

However, if the database does not exist on the local machine both @var{since} and @var{force} are ignored, and in this case an attempt is always made to download the database. That is, if the database does not exist locally the behavior is as if @var{since} were @code{nil} and @var{force} were @code{t}.

For example,
@example
(update-methods-database :since (* 24 60 60 30))
@end example
will download a fresh database only if the current one was created at least thirty days ago, and the version on the server is different than the one currently
stored locally; or if there is currently no such database on the local machine.

If @var{url} is @code{nil}, the default, a standard location from which to download the database is used. This can be changed by providing a URL as a string as @var{url}.

If @var{database} is @code{nil}, the default, a standard location is used for the database. This can be overriden by supplying a pathname designator as @var{database}.

Returns the pathname of the database if a fresh database is downloaded and @code{nil} otherwise.

Signals a @code{type-error} if since is neither @code{nil} nor a non-negative integer; @var{url} is neither @code{nil} nor a string; or @var{database} is neither @code{nil} nor a pathname designator.

Unforunately some of the libraries (Drakma, usocket and zip) required to download and unzip the updated database either don’t install or no longer work in CLISP and LispWorks, as of June 2017. On these implementations a call to @code{update-methods-database} will result in an error. Several work arounds are practical:
@itemize
@item
The version of the database that is downloaded with Roan will have been reasonably current at the time that version of Roan was released. For many purposes there may be no need to update it.

@item
Roan can be used to update it in a different Lisp implementation, such as SBCL or Clozure CL: the copy of the database so updated will then be available to CLISP
or LispWorks.

@item
The database can be downloaded by hand. Consult the source code for @code{update-methods-database} for the URL, and where to put the file after unzipping it. If simply unzipped and not altered it will work for all purposes except searching for rotations of exisiting methods. To support that as well another column of one of the tables in the database must be populated after downloading the new database; in addition some indecies are created to speed up access slightly. This, too, can easily be done by hand: again, consult the source code.
@end itemize

Package

roan

Source

method.lisp (file)

Function: use-roan-package &optional PACKAGE

A convenience function for using the @code{roan} package. Causes @var{package}, which defaults to the current value of @code{*package*}, to inherit all the external symbols of the @code{roan} package, and shadows @code{method} and @code{method-name}. Signals a @code{type-error} if @var{package} is not a package designator. Signals a @code{package-error} if @var{package} is the @code{keyword} package.
@example
@group
MY-PACKAGE> *package*
#<Package "MY-PACKAGE">
MY-PACKAGE> (package-use-list *)
(#<Package "COMMON-LISP">)
MY-PACKAGE> (roan:use-roan-package)
T
MY-PACKAGE> +maximum-stage+
24
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: which-grandsire-lead-head ROW

If @var{row} is a lead head of a plain course of Grandsire at its stage returns a positive integer identifying which lead head it is; returns @code{nil} if @var{row} is not a Grandsire lead head. If @var{row} is the first lead head of a plain course of Grandsire @code{1} is returned, if the second @code{2}, etc. For the purposes of this function rounds is not a Grandsire lead head, nor is any row below doubles. Signals a @code{type-error} if @var{row} is not a @code{row}.
@example
@group
(which-plain-bob-lead-head !1253746) @result{} 1
(which-plain-bob-lead-head !28967453) @result{} 4
(which-plain-bob-lead-head !135264) @result{} nil
(which-plain-bob-lead-head !12345) @result{} nil
(which-plain-bob-lead-head !1243) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: which-plain-bob-lead-head ROW

If @var{row} is a lead head of a plain course of Plain Bob at its stage returns a positive integer identifying which lead head it is; returns @code{nil} if @var{row} is not a Plain Bob lead head. If @var{row} is the first lead head of a plain course of Plain Bob @code{1} is returned, if the second @code{2}, etc. For the purposes of this function rounds is not a Plain Bob lead head, nor is any row below minimus. Signals a @code{type-error} if @var{row} is not a @code{row}.
@example
@group
(which-plain-bob-lead-head !13527486) @result{} 1
(which-plain-bob-lead-head !42638507T9E) @result{} 10
(which-plain-bob-lead-head !129785634) @result{} nil
(which-plain-bob-lead-head !12345) @result{} nil
(which-plain-bob-lead-head !132) @result{} nil
@end group
@end example

Package

roan

Source

roan.lisp (file)

Function: write-place-notation CHANGES &key STREAM ESCAPE COMMA ELIDE CROSS UPPER-CASE JUMP-CHANGES

Writes to @var{stream} characters representing place notation for @var{changes}, a list of @code{row}s.

The list @var{changes} should be a non-empty list of @code{row}s, all of the same stage. The @var{stream} should a character stream open for writing. It defaults to the current value of @code{*standard-output*}. If the generalized boolean @var{escape}, which defaults to the current value of @code{*print-escape*}, is true the place notation will be written using the @samp{#!} read macro to allow the Lisp @code{read} function to read it; in this case the stage will always be explicitly noted between the @samp{#} and the @samp{!}. If the generalized boolean @var{upper-case}, which defaults to the current value of @code{*print-bells-upper-case*}, is true positions notated using letters will be written in upper case, and otherwise in lower case.

The argument @var{cross} controls which character is used to denote a cross change at even stages. It must be a character designator for@code{ #\x}, @code{#\X} or @code{#\-}, and defaults to the current value of @code{*cross-character*}.

The argument @var{jump-changes} should be one of @code{nil}, @code{:jumps} or @code{:full}. It determines how jump changes will be notated. If it is @code{nil} and @var{changes} contains any jump changes an error will be signaled. If it is @code{:jumps} any jump changes will be notated using pairs of places between parentheses. While @code{parse-place-notation} and @code{read-place-notation} can interpret ordinary conjunct motion or even place making notated in parentheses, @code{write-place-notation} will only use parentheses for bells actually moving more than one place. If @var{jump-changes} is @code{:full} jump changes will be notated as a row between square brackets. Again, while ordinary changes notated this way can be parsed or read, @code{write-place-notation} will only use bracket notation for jump changes.

The argument @var{elide} determines whether, and how, to omit leading and/or lying places. If the stage of the changes in @var{changes} is odd, or if @var{elide} is @code{nil}, no such elision takes place. Otherwise @var{elide} should be one of @code{:interior}, @code{:leading}, @code{:lying} or @code{:lead-end}, which last is its default value. For any of these non-nil values leading or lying places will always be elided if there are interior places. They differ only for hunts (that is, changes with both a leading and lying place, and no interior places). If @code{:interior}, no elision takes place if there are no interior places. If @code{:leading}, the ’1’ is elided as implicitly available. If @code{:lying}, the lying place is elided, so that the result is always ’1’. The value @code{:lead-end} specifies the same behavior as @code{:lying} for all the elements of @var{changes} except the last, for which it behaves as @code{:leading}; this is often convenient for notating leads of treble dominated methods at even stages.

If the generalized boolean @var{comma} is true an attempt is made to write @var{changes} using a comma operator separating it into palindromes. In general there can be multiple ways of splitting an arbitrary piece of place notation into palindromes. If this is the case the choice is made to favor first a division that has the palindrome after the comma of length one, and if that is not possible the division that has the shortest palindrome before the comma. Any sequence of changes of length two can be trivially divided into palindromes, but notating them with a comma is unhelpful, so @var{comma} applies only to even length lists of changes of length greater than two. Whether or not a partitioning into palindromes was possible can be determined by examining the second value returned by this function, which will be true only if a comma was written.

Returns two values, @var{changes}, and a generalized Boolean indicating whether or not the result was written with a comma.

Signals an error if @var{changes} is empty, or contains rows of different stages, if @var{stream} is not a character stream open for writing, or if any of the usual IO errors occurs.

Package

roan

Source

roan.lisp (file)

Function: write-row ROW &key STREAM ESCAPE UPPER-CASE

Writes @var{row}, which should be a @code{row}, to the indicated @var{stream}.
The case of any bells represented by letters is controlled by @var{upper-case}, a generalized boolean defaulting to the current value of @code{*print-bells-upper-case*}. @var{escape}, a generalized Boolean defaulting to the current value of @code{*print-escape*}, determines whether or not to write it in a form that read can understand. Signals a @code{type-error} if @var{row} is not a @code{row}, and the usual errors if @var{stream} is not open for writing, etc.

Package

roan

Source

roan.lisp (file)


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

5.1.5 Generic functions

Generic Function: generate-rows CHANGES &optional INITIAL-ROW

Generates a sequence of @code{row}s by permuting a starting @code{row}
successively by each element of the sequence @var{changes}. The elements of @var{changes} should be @code{row}s. If @var{initial-row} is supplied it should be a @code{row}. If it is not supplied, rounds at the same stage as the first element of @var{changes} is used; if @var{changes} is empty, rounds at @code{*default-stage*} is used. Two values are returned. The first is a sequence of the same length as @var{changes}, and the second is a @code{row}. So long as @var{changes} is not empty, the first element of the first return value is @var{initial-row}, or the default rounds. The next value is that @code{row} permuted by the first element of @var{changes}; then that @code{row} permuted by the next element of @var{changes}, and so on, until all but the last element of @var{changes} has been used. The second return value is the last element of the first return value permuted by the last element of @var{changes}. If @var{changes} is empty, then the first return value is also empty, and @var{initial-row}, or the default rounds, is the second return value. Thus, for most methods, if @var{changes} are the changes of a lead, the first return value will be the rows of a lead starting with @var{initial-row}, and the second return value the lead head of the following lead.

If @var{changes} is a list, the first return value is a list; if @var{changes} is a vector, the first return value is a vector. The @code{generate-rows} function always returns a fresh sequence as its first return value, while @code{ngenerate-rows} resuses @var{changes}, replacing its elements by the permuted rows and returning it. The fresh vector created and returned by @code{generate-rows} is always a simple, general vector.

Signals an error if @var{initial-row} is neither a @code{row} nor @code{nil}, if @var{changes} isn’t a sequence, or if any elements of @var{changes} are not @code{row}s.
@example
@group
(multiple-value-list
(generate-rows ’(!2143 !1324 !2143 !1324) !4321))
@result{} ((!4321 !3412 !3142 !1324) !1234)
@end group
@end example

Package

roan

Source

roan.lisp (file)

Methods
Method: generate-rows CHANGES &optional INITIAL-ROW
Method: generate-rows (CHANGES vector) &optional INITIAL-ROW
Method: generate-rows (CHANGES list) &optional INITIAL-ROW
Generic Function: inappropriate-method-error-details CONDITION
Package

roan

Methods
Method: inappropriate-method-error-details (CONDITION inappropriate-method-error)
Source

method.lisp (file)

Generic Function: inappropriate-method-error-method CONDITION
Package

roan

Methods
Method: inappropriate-method-error-method (CONDITION inappropriate-method-error)
Source

method.lisp (file)

Generic Function: method-name OBJECT
Generic Function: (setf method-name) NEW-VALUE OBJECT
Package

roan

Methods
Method: method-name METHOD
Source

method.lisp (file)

Method: method-name (METHOD method)

automatically generated reader method

Source

method.lisp (file)

Method: (setf method-name) NEW-VALUE (METHOD method)

automatically generated writer method

Source

method.lisp (file)

Method: (setf method-name) VALUE (METHOD method) before
Source

method.lisp (file)

Generic Function: method-place-notation OBJECT
Generic Function: (setf method-place-notation) NEW-VALUE OBJECT
Package

roan

Methods
Method: method-place-notation METHOD
Source

method.lisp (file)

Method: method-place-notation (METHOD method)

automatically generated reader method

Source

method.lisp (file)

Method: (setf method-place-notation) NEW-VALUE (METHOD method)

automatically generated writer method

Source

method.lisp (file)

Method: (setf method-place-notation) VALUE (METHOD method) before
Source

method.lisp (file)

Generic Function: method-properties OBJECT
Generic Function: (setf method-properties) NEW-VALUE OBJECT
Package

roan

Methods
Method: method-properties METHOD
Source

method.lisp (file)

Method: method-properties (METHOD method)

automatically generated reader method

Source

method.lisp (file)

Method: (setf method-properties) NEW-VALUE (METHOD method)

automatically generated writer method

Source

method.lisp (file)

Method: (setf method-properties) VALUE (METHOD method) before
Source

method.lisp (file)

Generic Function: method-stage OBJECT
Generic Function: (setf method-stage) NEW-VALUE OBJECT
Package

roan

Methods
Method: method-stage METHOD
Source

method.lisp (file)

Method: method-stage (METHOD method)

automatically generated reader method

Source

method.lisp (file)

Method: (setf method-stage) NEW-VALUE (METHOD method)

automatically generated writer method

Source

method.lisp (file)

Method: (setf method-stage) VALUE (METHOD method) before
Source

method.lisp (file)

Generic Function: named-row-pattern NAME &optional STAGE COVERED

Returns a pattern, as a parse tree, that matches a named row at
@var{stage}. The @var{name} is one of those listed below. If @var{stage} is not supplied it defaults to the current value of @code{*default-stage*}. If @var{covered}, a generalized boolean, is non-nil the @code{row}(’s) that will be matched will assume an implicit tenor. If @var{covered} is not supplied it defaults to @code{nil} for even stages and @code{t} for odd stages. If there is no such named row known that corresponds to the values of @var{stage} and @var{covered} @code{nil} is returned. Signals an error if @var{name} is not a keyword or is not a known named row name as enumerated below, or if @var{stage} is not a @code{stage}.

The supported values for @var{name}, and the stages at which they are defined, are: @table @code
@item :backrounds
any stage
@item :queens
uncovered singles and above, or covered two and above.
@item :kings
uncovered minimus and above, or covered singles and above; note that kings at uncovered minor or covered doubles is the same row as Whittingtons at those stages
@item :whittingtons
uncovered minor and above, or covered doubles and above; note that Whittingtons at uncovered minor or covered doubles is the same row as kings at those stages
@item :double-whittingtons
covered cinques or uncovered maximus, only
@item :roller-coaster
covered caters or uncovered royal, only
@item :near-miss
any stage
@end table

@example
@group
(format-pattern (named-row-pattern :whittingtons 10 nil))
@result{} "1234975680"
(format-pattern (named-row-pattern :whittingtons 9 t)
@result{} "123497568"
(format-pattern (named-row-pattern :whittingtons 9 nil))
@result{} "123864579"
(named-row-pattern :whittingtons 4)
@result{} nil
@end group
@end example

Package

roan

Source

pattern.lisp (file)

Methods
Method: named-row-pattern (NAME (eql near-miss)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql roller-coaster)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql double-whittingtons)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql whittingtons)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql kings)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql queens)) &optional STAGE COVERED
Method: named-row-pattern (NAME (eql back-rounds)) &optional STAGE COVERED
Method: named-row-pattern NAME &optional STAGE COVERED
Generic Function: ngenerate-rows CHANGES &optional INITIAL-ROW

===merge: generate-rows

Package

roan

Source

roan.lisp (file)

Methods
Method: ngenerate-rows CHANGES &optional INITIAL-ROW
Method: ngenerate-rows (CHANGES vector) &optional INITIAL-ROW
Method: ngenerate-rows (CHANGES list) &optional INITIAL-ROW
Generic Function: npermute-by-collection ROW COLLECTION

===merge: permute-collection 3

Package

roan

Source

roan.lisp (file)

Methods
Method: npermute-by-collection ROW COLLECTION
Method: npermute-by-collection ROW (COLLECTION hash-set)
Method: npermute-by-collection ROW (COLLECTION vector)
Method: npermute-by-collection ROW (COLLECTION list)
Generic Function: npermute-collection COLLECTION CHANGE

===merge: permute-collection 2

Package

roan

Source

roan.lisp (file)

Methods
Method: npermute-collection COLLECTION CHANGE
Method: npermute-collection (COLLECTION hash-set) CHANGE
Method: npermute-collection (COLLECTION vector) CHANGE
Method: npermute-collection (COLLECTION list) CHANGE
Generic Function: permute-by-collection ROW COLLECTION

===merge: permute-collection 1

Package

roan

Source

roan.lisp (file)

Methods
Method: permute-by-collection ROW COLLECTION
Method: permute-by-collection ROW (COLLECTION hash-set)
Method: permute-by-collection ROW (COLLECTION vector)
Method: permute-by-collection ROW (COLLECTION list)
Generic Function: permute-collection COLLECTION CHANGE

Permutes each of the elements of a sequence or @code{hash-set} and an
individual @code{row}, collecting the results into a similar collection. The @code{permute-collection} version permutes each the elements of @var{collection} by @var{change}; @code{permute-by-collection} permutes @var{row} by each of the elements of @var{collection} by @var{change}. The return value is a list, vector or @code{hash-set} if @var{collection} is a list, vector or @code{hash-set}, respectively. The @code{permute-collection} and @code{permute-by-collection} versions always return a fresh collection; the @code{npermute-collection} and @code{npermute-by-collection} versions modify @var{collection}, replacing its contents by the permuted rows. If @var{collection} is a sequence the contents of the result are in the same order: that is, the Nth element of the result is the Nth element supplied in @var{collection} permuted by or permuting @var{change} or @var{row}. If @var{collection} is a vector, @code{permute-collection} and @code{permute-by-collection} always return a simple, general vector.

If the result is a sequence, or if all the elements of @var{collection} were of the same stage as one another, it is guaranteed that the result will be the same length or cardinality as @var{collection}. However, if @var{collection} is a @code{hash-set} containing rows of different stages the result may be of lower cardinality than then the supplied @code{hash-set}, if @var{collection} contained two or more elements that were not @code{equalp} because they were of different stages, but after being permuted by, or permuting, a higher stage row the results are @code{equalp}.

Signals a @code{type-error} if @var{change}, @var{row} or any of the elements of @var{collection} are not @code{rows}s, or if @var{collection} is not a sequence or @code{hash-set}.

Package

roan

Source

roan.lisp (file)

Methods
Method: permute-collection COLLECTION CHANGE
Method: permute-collection (COLLECTION hash-set) CHANGE
Method: permute-collection (COLLECTION vector) CHANGE
Method: permute-collection (COLLECTION list) CHANGE

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

5.1.6 Conditions

Condition: inappropriate-method-error ()

Signaled in circumstances when a method with certain properties is
required, but the method supplied does not have those properties. Contains two potentially useful slots accessible with @code{inappropriate-method-error-details} and @code{inappropriate-method-error-method}.

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: details
Initargs

:details

Readers

inappropriate-method-error-details (generic function)

Slot: method
Initargs

:method

Readers

inappropriate-method-error-method (generic function)

Condition: mixed-stage-fch-groups-error ()

Signaled if two or more @code{fch-group}s are used together in a
context that expects homogeneity but are not all major @code{fch-group}s or all higher-stage @code{fch-group}s.

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Condition: no-place-notation-error ()

Signaled in circumstances when the changes constituting a method are
needed but are not available because the method’s place notation or stage is empty. Contains one potentially useful slot accessbile with @code{no-place-notation-error-method}. Note, however, that many functions that make use of a method’s place notation and stage will return @code{nil} rather than signaling this error if either is not present.

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Direct methods

no-place-notation-error-method (method)

Direct slots
Slot: method
Initargs

:method

Readers

no-place-notation-error-method (generic function)

Condition: pattern-parse-error ()

An error signaled when attempting to parse a malformed row pattern.
Contains three potenitally useful slots accessible with @code{pattern-parse-error-message}, @code{pattern-parse-error-pattern} and @code{pattern-parse-error-index}.

Package

roan

Source

pattern.lisp (file)

Direct superclasses

parse-error (condition)

Direct methods
Direct slots
Slot: message
Initargs

:message

Initform

(quote nil)

Readers

pattern-parse-error-message (generic function)

Writers

(setf pattern-parse-error-message) (generic function)

Slot: pattern
Initargs

:pattern

Initform

(quote nil)

Readers

pattern-parse-error-pattern (generic function)

Writers

(setf pattern-parse-error-pattern) (generic function)

Slot: index
Initargs

:index

Initform

(quote nil)

Readers

pattern-parse-error-index (generic function)

Writers

(setf pattern-parse-error-index) (generic function)

Condition: row-match-error ()

Signaled when an anomolous situation is encountered when attempting to match @code{row}s against a pattern.

Package

roan

Source

pattern.lisp (file)

Direct superclasses

simple-error (condition)


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

5.1.7 Structures

Structure: fch-group ()

===summary===
Most methods that have been rung and named at stages major and above have been rung at even stages, with Plain Bob lead ends and lead heads, without jump changes, and with the usual palindromic symmetry. For major, and at higher stages if the tenors are kept together, the false course heads of such methods are traditionally partitioned into named sets all of whose elements must occur together in such methods. These are traditionally called “false course head groups” (FCHs), although they are not what mathemeticians usually mean by the word “group”. Further information is available from a variety of sources, including Appendix B of the @url{http://www.methods.org.uk/method-collections/xml-zip-files/method+xml+1.0.pdf, CCCBR Methods Committee’s XML format documentation}.

Roan provides a collection of @code{fch-group} objects that represent these FCH groups. Each is intended to be an singleton object, and under normal circumstances new instances should not be created. They can thus be compared using @code{eq}, if desired. The @code{fch-group}s for major are distinct from those for higher stages, though their contents are closely related.

An @code{fch-group} can be retrieved using the @code{fch-group} function. The first argument to this function can be either a @code{row} or a string. If a @code{row}
the @code{fch-group} that contains that row is returned. If a string the @code{fch-group} with that name is returned. In this latter case two further, optional arguments can be used to state that the group for higher stages is desired, and whether the one with just in course or just out of course false course heads is desired; for major all the @code{fch-group}s contain both in and out of course elements.

The @code{fch-group-name}, @code{fch-group-parity} and @code{fch-group-elements} functions can be used to retrieve the name, parity and elements of a @code{fch-group}. The @code{method-falseness} function calculates the false course heads of non-differential, treble dominated methods at even stages major and above, and for those with the usual palindromic symmetry and Plain Bob lead heads and lead ends, also returns the relevant @code{fch-group}s. The @code{fch-groups-string} function can be used to format a collection of @code{fch-group} names in a traditional, compact manner.

It is possible to extend the usual FCH groups to methods with non-Plain Bob lead heads. However, Roan currently provides no support for this.
===endsummary===
Describes a false course head group, including its name, parity if for even stages above major, and a list of the course heads it contains. The parity is @code{nil} for major @code{fch-group}s, and one of the keywords @code{:in-course} or @code{:out-of-course} for higher stages. The elements of a major @code{fch-group} are major @code{row}s while those for a higher stage @code{fch-group} are royal @code{row}s.

Package

roan

Source

method.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: index
Type

integer

Initform

0

Readers

fch-group-index (function)

Writers

(setf fch-group-index) (function)

Slot: name
Type

string

Initform

""

Readers

fch-group-name (function)

Writers

(setf fch-group-name) (function)

Slot: parity
Type

symbol

Readers

fch-group-parity (function)

Writers

(setf fch-group-parity) (function)

Slot: elements
Type

list

Readers

fch-group-elements (function)

Writers

(setf fch-group-elements) (function)

Structure: hash-set ()

===summary===
@cindex sets
@cindex @code{equalp}
For change ringing applications it is often useful to manipulate sets of rows. That is, unordered collections of rows without duplicates. To support this and similar uses Roan supplies @code{hash-set}s, which use @code{equalp} as the comparison for whether or not two candidate elements are “the same”. In addition, @code{equalp} can be used to compare two @code{hash-set}s themselves for equality: they are @code{equalp} if they contain the same number of elements, and each of the elements of one is @code{equalp} to an element of the other.
@example
@group
(equalp (hash-set !12345678 !13572468 !12753468 !13572468)
(hash-set-union (hash-set !12753468 !12345678)
(hash-set !13572468 !12753468 !13572468)))
@result{} t
@end group
@end example
===endsummary===
A set data structure, with element equality determined by @code{equalp}. That is, no two elements of such a set will ever be @code{equalp}, only one of those added remaining present in the set. Set membership testing, adding new elements to the set, and deletion of elements from the set is, on average, constant time. Two @code{hash-set}s can be compared with @code{equalp}: they are considered @code{equalp} if and only if they contain the same number of elements, and each of the elements of one is @code{equalp} to an element of the other.

Package

roan

Source

util.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: table
Type

hash-table

Initform

(make-hash-table :test (function equalp))

Readers

hash-set-table (function)

Writers

(setf hash-set-table) (function)

Structure: match-counter ()

===summary===
Often one would like to count how many times a variety of patterns match many different rows. To support this use Roan provides @code{match-counter}s. After creating a @code{match-counter} with @code{make-match-counter} you add a variety of patterns to it, with @code{add-pattern} or @code{add-patterns}, each with a label, which will typically be a symbol or string, but can be any Lisp object. You then apply the @code{match-counter} to @code{row}s with @code{record-matches}, and query how many matches have occurred with @code{match-counter-counts}.

The order in which patterns are added to a @code{match-counter} is preserved, and is reflected in the return values of @code{match-counter-labels}, and @code{match-counter-counts} called without a second argument. Replacing an existing pattern by adding a different one with a @var{label} that is @code{equalp} to an existing one does not change the order, but deleting a pattern with @code{remove-pattern} and then re-adding it does move it to the end of the order. When a pattern has been replaced by one with an @code{equalp} @var{label} that is not @code{eq} to the original @var{label} which label is retained is undefined.

A @code{match-counter} also distinguishes matches that occur at handstroke from those that occur at backstroke. Typically you tell the @code{match-counter} which stroke the next @code{row} it is asked to match is on, and it then automatically alternates handstrokes and backstrokes for subsequent @code{row}s. For patterns that span two rows, such as wraps, the stroke is considered to be that between the rows; for example a wrap of rounds that spans a backstroke lead would be considered to be “at” backstroke. @example
@group
(let ((m (make-match-counter 8)))
(add-patterns m ’((cru "*[456][456]78")
(wrap "?*12345678*?" t)
(lb4 "1-7%4*|*1-7%4")))
(loop for (row following)
on (generate-rows #8!36.6.5.3x5.56.5,2)
do (record-matches m row following))
(values (match-counter-counts m)))
@result{} ((cru . 3) (wrap . 1) (lb4 . 5))
@end group
@end example
===endsummary===
Used to collect statistics on how many rows match a variety of patterns.

Package

roan

Source

pattern.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: stage
Initform

roan:*default-stage*

Readers

match-counter-stage (function)

Writers

(setf match-counter-stage) (function)

Slot: %handstroke-p
Initform

t

Readers

match-counter-%handstroke-p (function)

Writers

(setf match-counter-%handstroke-p) (function)

Slot: patterns-vector
Initform

(make-array roan::+initial-match-counter-size+ :fill-pointer 0 :adjustable t)

Readers

match-counter-patterns-vector (function)

Writers

(setf match-counter-patterns-vector) (function)

Slot: patterns-table
Initform

(make-hash-table :test (function equalp) :size roan::+initial-match-counter-size+)

Readers

match-counter-patterns-table (function)

Writers

(setf match-counter-patterns-table) (function)

Slot: dfas
Readers

match-counter-dfas (function)

Writers

(setf match-counter-dfas) (function)

Structure: row ()

===summary===
@cindex immutable
The fundamental units of ringing are rows and changes, permutations of a fixed set of
bells. A distinction between them is often made, where a row is a permutation of bells and
a change is a permutation taking one row to the next. In Roan they are both represented by
the same data type, @code{row}; @code{row}s should be treated as immutable.

@cindex Lisp reader
@cindex reader macro
@cindex bang
@cindex @code{!} reader macro
@cindex printing @code{row}s
@cindex writing @code{row}s
@cindex quote
The @url{http://www.lispworks.com/documentation/HyperSpec/Body/23_.htm,,Lisp reader} is
augmented by Roan to read @code{row}s printed in the notation usually used by change
ringers by using the @samp{!} reader macro. For example, queens on twelve can be entered
in Lisp as @code{!13579E24680T}. When read with the @samp{!} reader macro bells
represented by alphabetic characters can be either upper or lower case; so queens on
twelve can also be entered as @code{!13579e24680t} or @code{!13579e24680T}.

To support the common case of writing lead heads of treble dominated methods if the treble
is leading it can be omitted. Thus, queens on twelve can also be entered as
@code{!3579E24680T}. Apart from a leading treble, however, if any bell is omitted from a
row written with a leading @samp{!} character an error will be signaled.

Note that @code{row}s are Lisp atoms, and thus literal values can be written using
@samp{!} notation without quoting, though quoting @code{row}s read that way will do no
harm when they are evaluated.

Similarly, @code{row}s are printed using this same notation, @url{http://www.lispworks.com/documentation/HyperSpec/Body/v_pr_esc.htm#STprint-escapeST,,@code{*print-escape*}} controlling whether or not they are preceded by @samp{!} characters. Note that the
characters used to represent bells in this printed representation differ from the small
integer @code{bell}s used to represent them internally, since the latter are zero based.
For example, the treble is represented internally by the integer 0, but in this printed
representation by the digit character @samp{1}. When printing rows in this way a leading
treble is not elided. And @code{*print-bells-upper-case*} can be used to control the case
of bells in the printed representation of @code{row}s that are representated by letters,
in cinques and above.
@example
@group
CL-USER> !12753468
!12753468
CL-USER> ’!2753468
!12753468
CL-USER> (format t "with: ~S~%without: ~:*~A~%" !TE0987654123)
with: !TE0987654123
without: TE0987654123
NIL
CL-USER> (let ((roan:*print-bells-upper-case* nil))
(format nil "~A" !TE0987654123))
"te0987654123"
CL-USER>
@end group
@end example

@cindex equality
@cindex comparing @code{row}s
@cindex @code{equalp}
@cindex @code{equal}
Rows can be compared for equality using @code{equalp} (but not @code{equal}). That is,
two different @code{row} objects that correspond to the same ordering of the same number of
bells will be @code{equalp}. Hash tables with a @code{:test} of @code{equalp} are often
useful with @code{row}s. @xref{hash-set}.
@example
@group
(equalp !13572468 !13572468) @result{} t
(equalp !13572468 !12753468) @result{} nil
(equalp !13572468 !1357246) @result{} nil
(equalp !13572468 !3572468) @result{} t
@end group
@end example
===endsummary===
A permutation of bells at a particular stage. The type @code{row} is used to represent
both change ringing rows and changes; that is, rows may be permuted by other rows.
Instances of @code{row} should normally be treated as immutable.

Package

roan

Source

roan.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
  • make-load-form (method)
  • print-object (method)
Direct slots
Slot: bells
Type

roan::%bells-vector

Readers

row-bells (function)

Writers

(setf row-bells) (function)


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

5.1.8 Classes

Class: method ()

===summary===
Roan provides the @code{method} type to describe change ringing methods, not to be confused with CLOS methods. A @code{method} can only describe a method that can be viewed as a fixed sequence of changes, including jump changes; while this includes all methods recognized by the Central Council (as of mid-2017), and many others, it does exclude, for example, Dixonoids. A @code{method} has a stage, a name, an associated place-notation, and a property list, though any or all of these may be @code{nil}. In the case of the stage, name or place notation @code{nil} indicates that the corresponding value is not known. The stage, if known, should be a @code{stage}, and the name and place notation, if known, should be strings. The name is not just the portion that the Central Council considers its name: it also includes any explictly named class, such as ’Surprise’, as well as modifiers such as ’Little’ or ’Differential’. For example, the name of Littleport Little Surprise Royal is "Littleport Little Surprise".

The property list may be used to store further information about a method. For example, @code{lookup-methods-by-name} typically adds the properties @code{:first-tower} and @code{:first-hand} to methods it creates with details of their first performances. Besides accessing the property list as a whole with @code{method-properties} individual properties can be interrogated and set with @code{method-property}.

Because a ringing method is unrelated to a CLOS method the @code{roan} package
shadows @code{common-lisp:method} and @code{common-lisp:method-name}.
===endsummary===
Describes a change ringing method, typically including its name, stage and place notation, and possibly other properties of the method.

Package

roan

Source

method.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: stage
Readers

method-stage (generic function)

Writers

(setf method-stage) (generic function)

Slot: name
Readers

method-name (generic function)

Writers

(setf method-name) (generic function)

Slot: place-notation
Readers

method-place-notation (generic function)

Writers

(setf method-place-notation) (generic function)

Slot: properties
Readers

method-properties (generic function)

Writers

(setf method-properties) (generic function)

Slot: traits

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

5.1.9 Types

Type: bell ()

===summary===
Roan supports ringing on as few as 2, or as many as 24, bells. Bells are represented as small, non-negative integers less than this maximum stage. However, bells as the integers used in Roan are zero-based: the treble is zero, the tenor on eight is 7, and so on. The @code{bell} type corresponds to integers in this range. There are functions for mapping bells to and from the characters corresponding to their usual textual representation in change ringing.
===endsummary===
A representation of a bell. These are zero-based, small integers, so the treble is @code{0}, the second is @code{1}, up to the tenor is one less than the stage.

Package

roan

Source

roan.lisp (file)

Type: stage ()

===summary===
The @code{stage} type represents the subset of small, positive integers corresponding to the numbers of bells Roan supports. While Roan represents stages as small, positive integers, it is conventional in ringing to refer to them by names, such as “Minor” or “Caters”. There are functions for mapping stages, the integers used by Roan, to and from their conventional names as strings.
===endsummary===
A supported number of bells, an integer between @code{+minimum-stage+} and @code{+maximum-stage+}, inclusive.

Package

roan

Source

roan.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Constants

Constant: +alliance+
Package

roan

Source

method.lisp (file)

Constant: +bell-names+
Package

roan

Source

roan.lisp (file)

Constant: +change-cache-size+
Package

roan

Source

roan.lisp (file)

Constant: +char-code-array-length+
Package

roan

Source

roan.lisp (file)

Constant: +cross-changes+
Package

roan

Source

roan.lisp (file)

Constant: +database-entry-name+
Package

roan

Source

method-lookup.lisp (file)

Constant: +early-index+
Package

roan

Source

method.lisp (file)

Constant: +even-stage-lead-head-codes+
Package

roan

Source

method.lisp (file)

Constant: +extended-place-notation-scanner+*
Package

roan

Source

roan.lisp (file)

Constant: +huffman-table+
Package

roan

Source

method.lisp (file)

Constant: +hunt-changes+
Package

roan

Source

roan.lisp (file)

Constant: +hunt-index+
Package

roan

Source

method.lisp (file)

Constant: +hunt-path-keywords+
Package

roan

Source

method.lisp (file)

Constant: +hybrid+
Package

roan

Source

method.lisp (file)

Constant: +incidence-initial-hash-set-size+
Package

roan

Source

method.lisp (file)

Constant: +initial-cross-character+
Package

roan

Source

roan.lisp (file)

Constant: +initial-match-counter-size+
Package

roan

Source

pattern.lisp (file)

Constant: +initial-print-bells-upper-case+
Package

roan

Source

roan.lisp (file)

Constant: +late-index+
Package

roan

Source

method.lisp (file)

Constant: +methods-database+
Package

roan

Source

method-lookup.lisp (file)

Constant: +methods-database-url+
Package

roan

Source

method-lookup.lisp (file)

Constant: +named-bells+
Package

roan

Source

roan.lisp (file)

Constant: +named-stages+
Package

roan

Source

roan.lisp (file)

Constant: +no-explicit-class-names+
Package

roan

Source

method.lisp (file)

Constant: +odd-stage-lead-head-codes+
Package

roan

Source

method.lisp (file)

Constant: +pattern-cache-size+
Package

roan

Source

pattern.lisp (file)

Constant: +pattern-characters+
Package

roan

Source

pattern.lisp (file)

Constant: +pattern-token+*
Package

roan

Source

pattern.lisp (file)

Constant: +place-notation-chars+
Package

roan

Source

roan.lisp (file)

Constant: +place-notation-fragment-scanner+
Package

roan

Source

roan.lisp (file)

Constant: +plain+
Package

roan

Source

method.lisp (file)

Constant: +rounds-bell-array+
Package

roan

Source

roan.lisp (file)

Constant: +row-signature-shift+
Package

roan

Source

method.lisp (file)

Constant: +run-token+*
Package

roan

Source

pattern.lisp (file)

Constant: +seconds-index+
Package

roan

Source

method.lisp (file)

Constant: +stage-names+
Package

roan

Source

roan.lisp (file)

Constant: +status-ok+
Package

roan

Source

method-lookup.lisp (file)

Constant: +summary-initial-hash-set-size+
Package

roan

Source

method.lisp (file)

Constant: +timestamp-scanner+
Package

roan

Source

method-lookup.lisp (file)

Constant: +treble-dodging+
Package

roan

Source

method.lisp (file)

Constant: +treble-place+
Package

roan

Source

method.lisp (file)


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

5.2.2 Special variables

Special Variable: *change-cache*
Package

roan

Source

roan.lisp (file)

Special Variable: *collapsable-whitespace-scanner*
Package

roan

Source

util.lisp (file)

Special Variable: *contains-collapsable-whitespace-scanner*
Package

roan

Source

util.lisp (file)

Special Variable: *dfa-stage*
Package

roan

Source

pattern.lisp (file)

Special Variable: *dfa-states*
Package

roan

Source

pattern.lisp (file)

Special Variable: *fch-groups-by-course-head*
Package

roan

Source

method.lisp (file)

Special Variable: *fch-groups-by-name*
Package

roan

Source

method.lisp (file)

Special Variable: *last-fch-group-index*
Package

roan

Source

method.lisp (file)

Special Variable: *last-nfa-id*
Package

roan

Source

pattern.lisp (file)

Special Variable: *nfa-stage*
Package

roan

Source

pattern.lisp (file)

Special Variable: *pattern-cache*
Package

roan

Source

pattern.lisp (file)

Special Variable: *pattern-parse-state*
Package

roan

Source

pattern.lisp (file)

Special Variable: *rows-distinct-p-hash-table*
Package

roan

Source

method.lisp (file)

Special Variable: *threading-p*
Package

roan

Source

util.lisp (file)

Special Variable: +cccbr-name-pattern+
Package

roan

Source

method.lisp (file)


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

5.2.3 Macros

Macro: check-type* OBJECT TYPE
Package

roan

Source

util.lisp (file)

Macro: clause-for-in-hash-set-1 &key (FOR VAR) (IN-HASH-SET SET)

Binds @var{var} to elements of the @code{hash-set} @var{set}. The order in which the elements are iterated over is undefined, and may vary between invocations of this clause on the same @code{hash-set}. If @var{set} is not a @code{hash-set} a @code{type-error} is signaled.

Package

roan

Source

util.lisp (file)

Macro: def-named-row NAME (&optional STAGE-VAR COVERED-VAR MINIMUM-BELLS) &body BODY
Package

roan

Source

pattern.lisp (file)

Macro: define-hunt-path-constants &rest KEYS
Package

roan

Source

method.lisp (file)

Macro: define-method-lookup NAME LAMBDA-LIST &optional DOCSTRING
Package

roan

Source

method.lisp (file)

Macro: define-method-trait NAME (UPDATE-FN &optional DEPENDS-ON) DOC-STRING
Package

roan

Source

method.lisp (file)

Macro: define-thread-local NAME &optional INITIAL-VALUE
Package

roan

Source

util.lisp (file)

Macro: deflock NAME
Package

roan

Source

util.lisp (file)

Macro: fch-list-f PLACE
Package

roan

Source

method.lisp (file)

Macro: get-entry KEY CACHE
Package

roan

Source

util.lisp (file)

Macro: logiorf PLACE &rest NUMBERS
Package

roan

Source

pattern.lisp (file)

Macro: with-bell-property-resolver &body BODY
Package

roan

Source

roan.lisp (file)

Macro: with-initial-format-characters &body BODY
Package

roan

Source

roan.lisp (file)

Macro: with-lock (LOCK) &body BODY
Package

roan

Source

util.lisp (file)

Macro: with-warnings-muffled (&key CONDITION IF) &body BODY

Evaluates BODY in a dynamic environment such that nothing is printed for warnings signaled. Only warnings of type CONDITION, which is not evaluated, are muffled; and only if IF, a genearlized Boolean, which is evaluated once, before BODY is evaluated, and outside the dynamic envirnoment muffling warnings, is non-nil. Returns the values of the last form in BODY.

Package

roan

Source

util.lisp (file)


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

5.2.4 Functions

Function: %%lookup-methods-from-changes CHANGES ROTATIONS LIMIT UPDATE URL DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %assemble-row BELLS
Package

roan

Source

roan.lisp (file)

Function: %counts COUNT
Package

roan

Source

pattern.lisp (file)

Function: %execute-with-methods-database THUNK DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %extreme-hash-set SETS TEST
Package

roan

Source

util.lisp (file)

Function: %fill-bells-vector ()
Package

roan

Source

roan.lisp (file)

Function: %get-changes METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-classification METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-contains-jump-changes METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-course-length METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-hunt-bell-info METHOD TRAITS BELL
Package

roan

Source

method.lisp (file)

Function: %get-hunt-bells METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-lead-count METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-lead-head METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-lead-head-code METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-lead-length METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-plain-course METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-plain-lead METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-principal-hunt-bells METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-secondary-hunt-bells METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %get-working-bells METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

Function: %hash-set-intersection SETS COPY
Package

roan

Source

util.lisp (file)

Function: %hash-set-union SETS COPY
Package

roan

Source

util.lisp (file)

Function: %in-course-p ()
Package

roan

Source

roan.lisp (file)

Function: %lookup-method NAME STAGE
Package

roan

Source

method-lookup.lisp (file)

Function: %lookup-methods STAGE WHERE PARAM LIMIT UPDATE URL DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %lookup-methods-by-name NAME STAGE LIMIT UPDATE URL DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %lookup-methods-by-notation PLACE-NOTATION STAGE ROTATIONS LIMIT UPDATE URL DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %lookup-methods-from-changes CHANGES ROTATIONS LIMIT UPDATE URL DATABASE BUSY-TIMEOUT
Package

roan

Source

method-lookup.lisp (file)

Function: %make-hash-set TABLE
Package

roan

Source

util.lisp (file)

Function: %make-match-counter STAGE
Package

roan

Source

pattern.lisp (file)

Function: %make-row BELLS
Package

roan

Source

roan.lisp (file)

Function: %methods-database-attributes DATABASE
Package

roan

Source

method-lookup.lisp (file)

Function: %npermute-hash-set SET FUNCTION
Package

roan

Source

roan.lisp (file)

Function: %parse-change CHANGE STAGE
Package

roan

Source

roan.lisp (file)

Function: %parse-place-notation SEGMENT STAGE
Package

roan

Source

roan.lisp (file)

Function: %permute ()
Package

roan

Source

roan.lisp (file)

Function: %placesp BELLS &rest PLACES
Package

roan

Source

roan.lisp (file)

Function: %plain-classification METHOD TRAITS PRINCIPAL-HUNTS SECONDARY-HUNTS
Package

roan

Source

method.lisp (file)

Function: %roundsp BELLS
Package

roan

Source

roan.lisp (file)

Function: %rows-match-p DFA ROW1 ROW2
Package

roan

Source

pattern.lisp (file)

Function: %tenors-fixed-p BELLS STARTING-AT
Package

roan

Source

roan.lisp (file)

Function: %treble-dodging-classification METHOD TRAITS PRINCIPAL-HUNTS
Package

roan

Source

method.lisp (file)

Function: %update-changes METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-classification METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-course-length METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-lead-count METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-lead-length METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-methods-database SINCE FORCE URL DATABASE
Package

roan

Source

method-lookup.lisp (file)

Function: %update-plain-course METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-plain-lead METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %with-lock LOCK THUNK
Package

roan

Source

util.lisp (file)

Function: %write-place-notation CHANGES STREAM STAGE ELIDE JUMP-CHANGES
Package

roan

Source

roan.lisp (file)

Function: add-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: add-transition SOURCE-STATE DESTINATION-STATE &optional BELL
Package

roan

Source

pattern.lisp (file)

Function: advance-token &optional STATE
Package

roan

Source

pattern.lisp (file)

Function: build-dfa-state NFA-STATES
Package

roan

Source

pattern.lisp (file)

Function: cache-count CACHE

Returns the number of elements currently in the @code{lru-cache} @var{cache}.

Package

roan

Source

util.lisp (file)

Function: canonical-rotation CHANGES
Package

roan

Source

method.lisp (file)

Function: changes-info CHANGES
Package

roan

Source

roan.lisp (file)

Function: checked-hash-set-table SET
Package

roan

Source

util.lisp (file)

Function: clear-method-traits METHOD
Package

roan

Source

method.lisp (file)

Function: clrcache CACHE

Removes all the entries from the lru-cache CACHE. Returns CACHE, which is now empty.

Package

roan

Source

util.lisp (file)

Function: collapse-whitespace S

Collapses multiple space characters and one or more tabs to single spaces, and removes leading or trailing spaces and tabs. If @var{s} contains any such whitespace that needs to be collapsed returns a copy suitably corrected, and otherwise returns S unchanged. If @var{s} is not a string or @code{nil}, signals an @code{type-error}.

Package

roan

Source

util.lisp (file)

Function: compare-rows ROW1 ROW2
Package

roan

Source

method.lisp (file)

Function: create-fch-group NAME PARITY &rest ELEMENTS
Package

roan

Source

method.lisp (file)

Function: current-token &optional STATE
Package

roan

Source

pattern.lisp (file)

Function: download-zipped-database URL
Package

roan

Source

method-lookup.lisp (file)

Function: encode-place-notation NOTATION STAGE
Package

roan

Source

method.lisp (file)

Function: ensure-valid-bell BELL STAGE &optional PARSING
Package

roan

Source

pattern.lisp (file)

Function: ensure-valid-bell-class CLASS &optional STAGE PARSING
Package

roan

Source

pattern.lisp (file)

Function: ensure-valid-run RUN &optional STAGE PARSING
Package

roan

Source

pattern.lisp (file)

Function: execute-with-methods-database THUNK DATABASE BUSY-TIMEOUT
Package

roan

Source

method.lisp (file)

Function: falseness-groups METHOD FCHS
Package

roan

Source

method.lisp (file)

Function: fch-group-index INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-p OBJECT
Package

roan

Source

method.lisp (file)

Function: fch-lessp R1 R2
Package

roan

Source

method.lisp (file)

Function: follow-empty-transitions STATE TABLE
Package

roan

Source

pattern.lisp (file)

Function: generate-rows-error CHANGES
Package

roan

Source

roan.lisp (file)

Function: generate-rows-initial-row INITIAL-ROW CHANGE
Package

roan

Source

roan.lisp (file)

Function: get-accessor-names SLOT
Package

roan

Source

method.lisp (file)

Function: get-db-info CONNECTION
Package

roan

Source

method-lookup.lisp (file)

Function: get-etag URL
Package

roan

Source

method-lookup.lisp (file)

Function: get-method-traits METHOD
Package

roan

Source

method.lisp (file)

Function: get-newest-key CACHE &optional DEFAULT

Retrieves the key of the most recently accesed entry in @var{cache}, which should be an @code{lru-cache}. @var{default} can be any object. Returns two values. If there are any entries in @var{cache}, the key associated with the most recently accessed entry, and @code{t}, are returned. If @var{cache} is empty, @var{default} and @code{nil} are returned.

Package

roan

Source

util.lisp (file)

Function: get-newest-value CACHE &optional DEFAULT

Retrieves the value of the most recently accesed entry in @var{cache}, which should be an @code{lru-cache}. @var{default} can be any object. Returns two values. If there are any entries in @var{cache}, the value associated with the most recently accessed entry, and @code{t}, are returned. If @var{cache{ is empty, @var{default} and @code{nil} are returned.

Package

roan

Source

util.lisp (file)

Function: getcache KEY CACHE &optional DEFAULT

Retrieves a value from @var{cache}. @var{key} may be any object. @var{cache} should be an @code{lru-cache}. Returns two values. The first is the element in the cache with the given @var{key}, or @var{default} if it is not present in @var{cache}. The second is @code{t} if an element was found, and @code{nil} otherwise. Retrieving an element from the cache marks it as the newest, aging the others in turn. @code{getcache} can be used with @code{setf}.

Package

roan

Source

util.lisp (file)

Setf Expander

(setf getcache) (setf expander)

Setf Expander: (setf getcache) KEY CACHE &optional DEFAULT
Package

roan

Source

util.lisp (file)

Reader

getcache (function)

Function: hash-set-table INSTANCE
Package

roan

Source

util.lisp (file)

Function: header-etag HEADERS
Package

roan

Source

method-lookup.lisp (file)

Function: hunt-path-info-apex INSTANCE
Function: (setf hunt-path-info-apex) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: hunt-path-info-bell INSTANCE
Function: (setf hunt-path-info-bell) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: hunt-path-info-kind INSTANCE
Function: (setf hunt-path-info-kind) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: hunt-path-info-little-p INSTANCE
Function: (setf hunt-path-info-little-p) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: hunt-path-info-section-length INSTANCE
Function: (setf hunt-path-info-section-length) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: jump-change-error CONTROL &rest ARGUMENTS
Package

roan

Source

roan.lisp (file)

Function: lead-end-kind BELLS
Package

roan

Source

method.lisp (file)

Function: lead-head-code LEAD-HEAD CHANGE
Package

roan

Source

method.lisp (file)

Function: make-dfa INITIAL-NFA-STATE
Package

roan

Source

pattern.lisp (file)

Function: make-dfa-state &optional FINAL STAGE
Package

roan

Source

pattern.lisp (file)

Function: make-fch-group &key (INDEX INDEX) (NAME NAME) (PARITY PARITY) (ELEMENTS ELEMENTS)
Package

roan

Source

method.lisp (file)

Function: make-hunt-path-info BELL LITTLE-P APEX
Package

roan

Source

method.lisp (file)

Function: make-lru-cache SIZE &key TEST

Creates an @code{lru-cache} of the given @var{size}, which should be a positive integer. The @var{:test} argument should be suitable for passing as the @var{:test} of @code{make-hash-table}, and is the equality comparison used to compare keys. If during use of the @code{lru-cache} more then @var{size} elements are added, the oldest are deleted to ensure the cache contains at most @var{size} elements. Adding or retrieving an element marks it as the newest, and ages any others in the cache in turn, keeping their current age order.

Package

roan

Source

util.lisp (file)

Function: make-match-counter-dfas COUNTER
Package

roan

Source

pattern.lisp (file)

Function: make-method-traits &key (CHANGES CHANGES) (CONTAINS-JUMP-CHANGES CONTAINS-JUMP-CHANGES) (LEAD-LENGTH LEAD-LENGTH) (LEAD-HEAD LEAD-HEAD) (LEAD-COUNT LEAD-COUNT) (PLAIN-LEAD PLAIN-LEAD) (PLAIN-COURSE PLAIN-COURSE) (COURSE-LENGTH COURSE-LENGTH) (HUNT-BELLS HUNT-BELLS) (PRINCIPAL-HUNT-BELLS PRINCIPAL-HUNT-BELLS) (SECONDARY-HUNT-BELLS SECONDARY-HUNT-BELLS) (WORKING-BELLS WORKING-BELLS) (CLASSIFICATION CLASSIFICATION) (LEAD-HEAD-CODE LEAD-HEAD-CODE)
Package

roan

Source

method.lisp (file)

Function: make-nfa TREE *NFA-STAGE* FINAL-TOKEN
Package

roan

Source

pattern.lisp (file)

Function: make-nfa-state &optional STAGE
Package

roan

Source

pattern.lisp (file)

Function: make-pattern-parse-state STRING STAGE
Package

roan

Source

pattern.lisp (file)

Function: make-row-count LABEL PATTERN DOUBLE-ROW-P
Package

roan

Source

pattern.lisp (file)

Function: match-counter-%handstroke-p INSTANCE
Function: (setf match-counter-%handstroke-p) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: match-counter-dfas INSTANCE
Function: (setf match-counter-dfas) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: match-counter-patterns-table INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: match-counter-patterns-vector INSTANCE
Function: (setf match-counter-patterns-vector) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: method-traits-changes INSTANCE
Function: (setf method-traits-changes) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-classification INSTANCE
Function: (setf method-traits-classification) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-contains-jump-changes INSTANCE
Function: (setf method-traits-contains-jump-changes) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-course-length INSTANCE
Function: (setf method-traits-course-length) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-hunt-bells INSTANCE
Function: (setf method-traits-hunt-bells) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-lead-count INSTANCE
Function: (setf method-traits-lead-count) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-lead-head INSTANCE
Function: (setf method-traits-lead-head) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-lead-head-code INSTANCE
Function: (setf method-traits-lead-head-code) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-lead-length INSTANCE
Function: (setf method-traits-lead-length) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-plain-course INSTANCE
Function: (setf method-traits-plain-course) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-plain-lead INSTANCE
Function: (setf method-traits-plain-lead) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-principal-hunt-bells INSTANCE
Function: (setf method-traits-principal-hunt-bells) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-secondary-hunt-bells INSTANCE
Function: (setf method-traits-secondary-hunt-bells) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-traits-working-bells INSTANCE
Function: (setf method-traits-working-bells) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: move-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: named-row-definition STAGE COVERED MINIMUM-BELLS THUNK
Package

roan

Source

pattern.lisp (file)

Function: nfa-id NFA-STATE
Package

roan

Source

pattern.lisp (file)

Function: nunfold CHANGES
Package

roan

Source

roan.lisp (file)

Function: parse-alternative ()
Package

roan

Source

pattern.lisp (file)

Function: parse-bell-class STRING STAGE
Package

roan

Source

pattern.lisp (file)

Function: parse-disjunction ()
Package

roan

Source

pattern.lisp (file)

Function: parse-element ()
Package

roan

Source

pattern.lisp (file)

Function: parse-run STRING STAGE
Package

roan

Source

pattern.lisp (file)

Function: parse-timestamp TIMESTAMP
Package

roan

Source

method-lookup.lisp (file)

Function: pattern-parse-state-end-p &optional STATE
Package

roan

Source

pattern.lisp (file)

Function: permute-collection-type-error COLLECTION
Package

roan

Source

roan.lisp (file)

Function: prepare-database DB ETAG
Package

roan

Source

method-lookup.lisp (file)

Function: prin1-hash-set SET STREAM
Package

roan

Source

util.lisp (file)

Function: publish-trait THING
Package

roan

Source

method.lisp (file)

Function: putcache KEY CACHE VALUE
Package

roan

Source

util.lisp (file)

Function: remcache KEY CACHE

Removes the entry with key @var{key} from the @code{lru-cache} @var{cache}. Returns @code{t} if there was such an element, and @code{nil} otherwise.

Package

roan

Source

util.lisp (file)

Function: remove-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: row-bells INSTANCE
Function: (setf row-bells) VALUE INSTANCE
Package

roan

Source

roan.lisp (file)

Function: row-count-backstroke INSTANCE
Function: (setf row-count-backstroke) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: row-count-double-row-p INSTANCE
Function: (setf row-count-double-row-p) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: row-count-handstroke INSTANCE
Function: (setf row-count-handstroke) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: row-count-label INSTANCE
Function: (setf row-count-label) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: row-count-pattern INSTANCE
Function: (setf row-count-pattern) VALUE INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: row-creation-error DATA PARSE
Package

roan

Source

roan.lisp (file)

Function: row-list-less-p LIST1 LIST2
Package

roan

Source

method.lisp (file)

Function: rows-distinct-p ROWS

TODO Currently not exported. Consider exporting once provers have been tidied up sufficiently to add it.
Returns true if all the elements of @var{rows} is a @code{row}, and all are distinct. An empty sequence is considered true. Note that if @var{rows} contains two @code{row}s of different stages that, if the smaller were extended to the stage of the larger, would be equal, they are still considered distinct by this function. Signals a @code{type-error} if @var{rows} is not a sequence, or if it detects that any of its elements is not a @code{row}; however, if falseness is discovered, no elements after the first duplicate will be examine, and no error will be signaled if subsequent elements are not @code{row}s.

Package

roan

Source

method.lisp (file)

Function: same-type-p X Y
Package

roan

Source

util.lisp (file)

Function: sharp-bang-reader STREAM SUBCHAR ARG
Package

roan

Source

roan.lisp (file)

Function: signal-method-lookup-error NAME
Package

roan

Source

method.lisp (file)

Function: signature STATES
Package

roan

Source

pattern.lisp (file)

Function: sort-fch-set SET
Package

roan

Source

method.lisp (file)

Function: split-palindromic-changes CHANGES LENGTH CONTAINS-JUMP-CHANGES
Package

roan

Source

roan.lisp (file)

Function: sql-wildcardify STRING
Package

roan

Source

method-lookup.lisp (file)

Function: subseq-reversed-circular CLIST START LENGTH
Package

roan

Source

method.lisp (file)

Function: test-jump-palindrome CHANGES N
Package

roan

Source

roan.lisp (file)

Function: test-ordinary-palindrome CHANGES N
Package

roan

Source

roan.lisp (file)

Function: thread-call NAME &rest ARGS
Package

roan

Source

util.lisp (file)

Function: total-bells STAGE COVERED
Package

roan

Source

pattern.lisp (file)

Function: unzip-database ZIPFILE
Package

roan

Source

method-lookup.lisp (file)

Function: which-lead-head BELLS NEXT-FN
Package

roan

Source

roan.lisp (file)


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

5.2.5 Generic functions

Generic Function: build-nfa THING FROM-STATE &optional ARGS
Package

roan

Source

pattern.lisp (file)

Methods
Method: build-nfa KEY FROM-STATE &optional ARGS
Method: build-nfa (KEY (eql run)) FROM-STATE &optional ARGS
Method: build-nfa (KEY (eql class)) FROM-STATE &optional ARGS
Method: build-nfa (WILDCARD (eql any)) FROM-STATE &optional ARGS
Method: build-nfa (WILDCARD (eql one)) FROM-STATE &optional ARGS
Method: build-nfa (BELL integer) FROM-STATE &optional ARGS
Method: build-nfa (KEY (eql or)) FROM-STATE &optional ARGS
Method: build-nfa (KEY (eql sequence)) STATE &optional ARGS
Method: build-nfa (LIST list) FROM-STATE &optional ARGS
Generic Function: cache-entry-table OBJECT
Package

roan

Methods
Method: cache-entry-table (LRU-CACHE lru-cache)

automatically generated reader method

Source

util.lisp (file)

Generic Function: cache-size OBJECT
Package

roan

Methods
Method: cache-size (LRU-CACHE lru-cache)

automatically generated reader method

Source

util.lisp (file)

Generic Function: empty-transition OBJECT
Generic Function: (setf empty-transition) NEW-VALUE OBJECT
Package

roan

Methods
Method: empty-transition (NFA-STATE nfa-state)

automatically generated reader method

Source

pattern.lisp (file)

Method: (setf empty-transition) NEW-VALUE (NFA-STATE nfa-state)

automatically generated writer method

Source

pattern.lisp (file)

Generic Function: entry-key OBJECT
Generic Function: (setf entry-key) NEW-VALUE OBJECT
Package

roan

Methods
Method: entry-key (CACHE-ENTRY cache-entry)

automatically generated reader method

Source

util.lisp (file)

Method: (setf entry-key) NEW-VALUE (CACHE-ENTRY cache-entry)

automatically generated writer method

Source

util.lisp (file)

Generic Function: entry-value OBJECT
Generic Function: (setf entry-value) NEW-VALUE OBJECT
Package

roan

Methods
Method: entry-value (CACHE-ENTRY cache-entry)

automatically generated reader method

Source

util.lisp (file)

Method: (setf entry-value) NEW-VALUE (CACHE-ENTRY cache-entry)

automatically generated writer method

Source

util.lisp (file)

Generic Function: format-pattern-element TREE STREAM &optional ARGS CONTEXT
Package

roan

Source

pattern.lisp (file)

Methods
Method: format-pattern-element KEY STREAM &optional ARGS CONTEXT
Method: format-pattern-element (KEY (eql run)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (KEY (eql class)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (WILDCARD (eql any)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (WILDCARD (eql one)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (BELL integer) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (KEY (eql or)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (KEY (eql sequence)) STREAM &optional ARGS CONTEXT
Method: format-pattern-element (LIST list) STREAM &optional ARGS CONTEXT
Generic Function: get-final OBJECT
Package

roan

Methods
Method: get-final (DFA-STATE dfa-state)

automatically generated reader method

Source

pattern.lisp (file)

Method: get-final (NFA-STATE nfa-state)

automatically generated reader method

Source

pattern.lisp (file)

Generic Function: newest-entry OBJECT
Generic Function: (setf newest-entry) NEW-VALUE OBJECT
Package

roan

Methods
Method: newest-entry (LRU-CACHE lru-cache)

automatically generated reader method

Source

util.lisp (file)

Method: (setf newest-entry) NEW-VALUE (LRU-CACHE lru-cache)

automatically generated writer method

Source

util.lisp (file)

Generic Function: next-entry OBJECT
Generic Function: (setf next-entry) NEW-VALUE OBJECT
Package

roan

Methods
Method: next-entry (CACHE-ENTRY cache-entry)

automatically generated reader method

Source

util.lisp (file)

Method: (setf next-entry) NEW-VALUE (CACHE-ENTRY cache-entry)

automatically generated writer method

Source

util.lisp (file)

Generic Function: no-place-notation-error-method CONDITION
Package

roan

Methods
Method: no-place-notation-error-method (CONDITION no-place-notation-error)
Source

method.lisp (file)

Generic Function: oldest-entry OBJECT
Generic Function: (setf oldest-entry) NEW-VALUE OBJECT
Package

roan

Methods
Method: oldest-entry (LRU-CACHE lru-cache)

automatically generated reader method

Source

util.lisp (file)

Method: (setf oldest-entry) NEW-VALUE (LRU-CACHE lru-cache)

automatically generated writer method

Source

util.lisp (file)

Generic Function: pattern-parse-error-index CONDITION
Generic Function: (setf pattern-parse-error-index) NEW-VALUE CONDITION
Package

roan

Methods
Method: pattern-parse-error-index (CONDITION pattern-parse-error)
Method: (setf pattern-parse-error-index) NEW-VALUE (CONDITION pattern-parse-error)
Source

pattern.lisp (file)

Generic Function: pattern-parse-error-message CONDITION
Generic Function: (setf pattern-parse-error-message) NEW-VALUE CONDITION
Package

roan

Methods
Method: pattern-parse-error-message (CONDITION pattern-parse-error)
Method: (setf pattern-parse-error-message) NEW-VALUE (CONDITION pattern-parse-error)
Source

pattern.lisp (file)

Generic Function: pattern-parse-error-pattern CONDITION
Generic Function: (setf pattern-parse-error-pattern) NEW-VALUE CONDITION
Package

roan

Methods
Method: pattern-parse-error-pattern (CONDITION pattern-parse-error)
Method: (setf pattern-parse-error-pattern) NEW-VALUE (CONDITION pattern-parse-error)
Source

pattern.lisp (file)

Generic Function: previous-entry OBJECT
Generic Function: (setf previous-entry) NEW-VALUE OBJECT
Package

roan

Methods
Method: previous-entry (CACHE-ENTRY cache-entry)

automatically generated reader method

Source

util.lisp (file)

Method: (setf previous-entry) NEW-VALUE (CACHE-ENTRY cache-entry)

automatically generated writer method

Source

util.lisp (file)

Generic Function: set-final NEW-VALUE OBJECT
Package

roan

Methods
Method: set-final NEW-VALUE (NFA-STATE nfa-state)

automatically generated writer method

Source

pattern.lisp (file)

Generic Function: transitions OBJECT
Package

roan

Methods
Method: transitions (DFA-STATE dfa-state)

automatically generated reader method

Source

pattern.lisp (file)

Method: transitions (NFA-STATE nfa-state)

automatically generated reader method

Source

pattern.lisp (file)


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

5.2.6 Conditions

Condition: jump-change-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses

simple-error (condition)

Condition: row-creation-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses

row-creation-parse-error (condition)

Condition: row-creation-parse-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses
Condition: simple-package-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses
  • simple-error (condition)
  • package-error (condition)

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

5.2.7 Structures

Structure: hunt-path-info ()
Package

roan

Source

method.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: bell
Type

roan:bell

Initform

0

Readers

hunt-path-info-bell (function)

Writers

(setf hunt-path-info-bell) (function)

Slot: kind
Type

integer

Initform

-1

Readers

hunt-path-info-kind (function)

Writers

(setf hunt-path-info-kind) (function)

Slot: little-p
Readers

hunt-path-info-little-p (function)

Writers

(setf hunt-path-info-little-p) (function)

Slot: apex
Readers

hunt-path-info-apex (function)

Writers

(setf hunt-path-info-apex) (function)

Slot: section-length
Readers

hunt-path-info-section-length (function)

Writers

(setf hunt-path-info-section-length) (function)

Structure: method-traits ()
Package

roan

Source

method.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: changes
Readers

method-traits-changes (function)

Writers

(setf method-traits-changes) (function)

Slot: contains-jump-changes
Readers

method-traits-contains-jump-changes (function)

Writers

(setf method-traits-contains-jump-changes) (function)

Slot: lead-length
Readers

method-traits-lead-length (function)

Writers

(setf method-traits-lead-length) (function)

Slot: lead-head
Readers

method-traits-lead-head (function)

Writers

(setf method-traits-lead-head) (function)

Slot: lead-count
Readers

method-traits-lead-count (function)

Writers

(setf method-traits-lead-count) (function)

Slot: plain-lead
Readers

method-traits-plain-lead (function)

Writers

(setf method-traits-plain-lead) (function)

Slot: plain-course
Readers

method-traits-plain-course (function)

Writers

(setf method-traits-plain-course) (function)

Slot: course-length
Readers

method-traits-course-length (function)

Writers

(setf method-traits-course-length) (function)

Slot: hunt-bells
Readers

method-traits-hunt-bells (function)

Writers

(setf method-traits-hunt-bells) (function)

Slot: principal-hunt-bells
Readers

method-traits-principal-hunt-bells (function)

Writers

(setf method-traits-principal-hunt-bells) (function)

Slot: secondary-hunt-bells
Readers

method-traits-secondary-hunt-bells (function)

Writers

(setf method-traits-secondary-hunt-bells) (function)

Slot: working-bells
Readers

method-traits-working-bells (function)

Writers

(setf method-traits-working-bells) (function)

Slot: classification
Readers

method-traits-classification (function)

Writers

(setf method-traits-classification) (function)

Slot: lead-head-code
Readers

method-traits-lead-head-code (function)

Writers

(setf method-traits-lead-head-code) (function)

Structure: row-count ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: label
Readers

row-count-label (function)

Writers

(setf row-count-label) (function)

Slot: pattern
Readers

row-count-pattern (function)

Writers

(setf row-count-pattern) (function)

Slot: double-row-p
Readers

row-count-double-row-p (function)

Writers

(setf row-count-double-row-p) (function)

Slot: handstroke
Initform

0

Readers

row-count-handstroke (function)

Writers

(setf row-count-handstroke) (function)

Slot: backstroke
Initform

0

Readers

row-count-backstroke (function)

Writers

(setf row-count-backstroke) (function)


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

5.2.8 Classes

Class: cache-entry ()

The elements of a doubly-linked list that are threaded through the hash
table entries for this @code{lru-cache}. Elements in the list are maintained in a newest to oldest order.

Package

roan

Source

util.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: key
Readers

entry-key (generic function)

Writers

(setf entry-key) (generic function)

Slot: value
Readers

entry-value (generic function)

Writers

(setf entry-value) (generic function)

Slot: previous
Type

(or roan::cache-entry null)

Readers

previous-entry (generic function)

Writers

(setf previous-entry) (generic function)

Slot: next
Type

(or roan::cache-entry null)

Readers

next-entry (generic function)

Writers

(setf next-entry) (generic function)

Class: dfa-state ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions (generic function)

Slot: final
Type

(quote list)

Initargs

:final

Readers

get-final (generic function)

Class: lru-cache ()

A least recent used cache implemented as a threaded hash table.

Package

roan

Source

util.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: size
Type

(integer 1 *)

Initargs

:size

Readers

cache-size (generic function)

Slot: table
Type

roan::hash

Initargs

:table

Readers

cache-entry-table (generic function)

Slot: newest
Type

(or roan::cache-entry null)

Readers

newest-entry (generic function)

Writers

(setf newest-entry) (generic function)

Slot: oldest
Type

(or roan::cache-entry null)

Readers

oldest-entry (generic function)

Writers

(setf oldest-entry) (generic function)

Class: nfa-state ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions (generic function)

Slot: empty-transition
Type

(quote list)

Initform

(quote nil)

Readers

empty-transition (generic function)

Writers

(setf empty-transition) (generic function)

Slot: final
Readers

get-final (generic function)

Writers

set-final (generic function)

Slot: id
Class: pattern-parse-state ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct slots
Slot: string
Initargs

:string

Slot: stage
Initargs

:stage

Slot: index
Initform

0

Slot: token
Slot: token-end
Initform

0


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

5.2.9 Types

Type: %bells-vector ()
Package

roan

Source

roan.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   R  
Index Entry  Section

F
File, Lisp, roan-base.asd: The roan-base<dot>asd file
File, Lisp, roan-base/method.lisp: The roan-base/method<dot>lisp file
File, Lisp, roan-base/package.lisp: The roan-base/package<dot>lisp file
File, Lisp, roan-base/pattern.lisp: The roan-base/pattern<dot>lisp file
File, Lisp, roan-base/roan.lisp: The roan-base/roan<dot>lisp file
File, Lisp, roan-base/util.lisp: The roan-base/util<dot>lisp file
File, Lisp, roan.asd: The roan<dot>asd file
File, Lisp, roan/method-lookup.lisp: The roan/method-lookup<dot>lisp file

L
Lisp File, roan-base.asd: The roan-base<dot>asd file
Lisp File, roan-base/method.lisp: The roan-base/method<dot>lisp file
Lisp File, roan-base/package.lisp: The roan-base/package<dot>lisp file
Lisp File, roan-base/pattern.lisp: The roan-base/pattern<dot>lisp file
Lisp File, roan-base/roan.lisp: The roan-base/roan<dot>lisp file
Lisp File, roan-base/util.lisp: The roan-base/util<dot>lisp file
Lisp File, roan.asd: The roan<dot>asd file
Lisp File, roan/method-lookup.lisp: The roan/method-lookup<dot>lisp file

R
roan-base.asd: The roan-base<dot>asd file
roan-base/method.lisp: The roan-base/method<dot>lisp file
roan-base/package.lisp: The roan-base/package<dot>lisp file
roan-base/pattern.lisp: The roan-base/pattern<dot>lisp file
roan-base/roan.lisp: The roan-base/roan<dot>lisp file
roan-base/util.lisp: The roan-base/util<dot>lisp file
roan.asd: The roan<dot>asd file
roan/method-lookup.lisp: The roan/method-lookup<dot>lisp file

Jump to:   F   L   R  

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   W  
Index Entry  Section

%
%%lookup-methods-from-changes: Internal functions
%assemble-row: Internal functions
%counts: Internal functions
%execute-with-methods-database: Internal functions
%extreme-hash-set: Internal functions
%fill-bells-vector: Internal functions
%get-changes: Internal functions
%get-classification: Internal functions
%get-contains-jump-changes: Internal functions
%get-course-length: Internal functions
%get-hunt-bell-info: Internal functions
%get-hunt-bells: Internal functions
%get-lead-count: Internal functions
%get-lead-head: Internal functions
%get-lead-head-code: Internal functions
%get-lead-length: Internal functions
%get-plain-course: Internal functions
%get-plain-lead: Internal functions
%get-principal-hunt-bells: Internal functions
%get-secondary-hunt-bells: Internal functions
%get-working-bells: Internal functions
%hash-set-intersection: Internal functions
%hash-set-union: Internal functions
%in-course-p: Internal functions
%lookup-method: Internal functions
%lookup-methods: Internal functions
%lookup-methods-by-name: Internal functions
%lookup-methods-by-notation: Internal functions
%lookup-methods-from-changes: Internal functions
%make-hash-set: Internal functions
%make-match-counter: Internal functions
%make-row: Internal functions
%methods-database-attributes: Internal functions
%npermute-hash-set: Internal functions
%parse-change: Internal functions
%parse-place-notation: Internal functions
%permute: Internal functions
%placesp: Internal functions
%plain-classification: Internal functions
%roundsp: Internal functions
%rows-match-p: Internal functions
%tenors-fixed-p: Internal functions
%treble-dodging-classification: Internal functions
%update-changes: Internal functions
%update-classification: Internal functions
%update-course-length: Internal functions
%update-lead-count: Internal functions
%update-lead-length: Internal functions
%update-methods-database: Internal functions
%update-plain-course: Internal functions
%update-plain-lead: Internal functions
%with-lock: Internal functions
%write-place-notation: Internal functions

(
(setf empty-transition): Internal generic functions
(setf empty-transition): Internal generic functions
(setf entry-key): Internal generic functions
(setf entry-key): Internal generic functions
(setf entry-value): Internal generic functions
(setf entry-value): Internal generic functions
(setf getcache): Internal functions
(setf hunt-path-info-apex): Internal functions
(setf hunt-path-info-bell): Internal functions
(setf hunt-path-info-kind): Internal functions
(setf hunt-path-info-little-p): Internal functions
(setf hunt-path-info-section-length): Internal functions
(setf match-counter-%handstroke-p): Internal functions
(setf match-counter-dfas): Internal functions
(setf match-counter-handstroke-p): Exported functions
(setf match-counter-patterns-vector): Internal functions
(setf method-name): Exported generic functions
(setf method-name): Exported generic functions
(setf method-name): Exported generic functions
(setf method-place-notation): Exported generic functions
(setf method-place-notation): Exported generic functions
(setf method-place-notation): Exported generic functions
(setf method-properties): Exported generic functions
(setf method-properties): Exported generic functions
(setf method-properties): Exported generic functions
(setf method-property): Exported functions
(setf method-stage): Exported generic functions
(setf method-stage): Exported generic functions
(setf method-stage): Exported generic functions
(setf method-title): Exported functions
(setf method-traits-changes): Internal functions
(setf method-traits-classification): Internal functions
(setf method-traits-contains-jump-changes): Internal functions
(setf method-traits-course-length): Internal functions
(setf method-traits-hunt-bells): Internal functions
(setf method-traits-lead-count): Internal functions
(setf method-traits-lead-head): Internal functions
(setf method-traits-lead-head-code): Internal functions
(setf method-traits-lead-length): Internal functions
(setf method-traits-plain-course): Internal functions
(setf method-traits-plain-lead): Internal functions
(setf method-traits-principal-hunt-bells): Internal functions
(setf method-traits-secondary-hunt-bells): Internal functions
(setf method-traits-working-bells): Internal functions
(setf newest-entry): Internal generic functions
(setf newest-entry): Internal generic functions
(setf next-entry): Internal generic functions
(setf next-entry): Internal generic functions
(setf oldest-entry): Internal generic functions
(setf oldest-entry): Internal generic functions
(setf pattern-parse-error-index): Internal generic functions
(setf pattern-parse-error-index): Internal generic functions
(setf pattern-parse-error-message): Internal generic functions
(setf pattern-parse-error-message): Internal generic functions
(setf pattern-parse-error-pattern): Internal generic functions
(setf pattern-parse-error-pattern): Internal generic functions
(setf previous-entry): Internal generic functions
(setf previous-entry): Internal generic functions
(setf row-bells): Internal functions
(setf row-count-backstroke): Internal functions
(setf row-count-double-row-p): Internal functions
(setf row-count-handstroke): Internal functions
(setf row-count-label): Internal functions
(setf row-count-pattern): Internal functions

A
add-entry: Internal functions
add-pattern: Exported functions
add-patterns: Exported functions
add-transition: Internal functions
advance-token: Internal functions
alter-stage: Exported functions

B
bell-at-position: Exported functions
bell-from-name: Exported functions
bell-name: Exported functions
bells-list: Exported functions
bells-vector: Exported functions
build-dfa-state: Internal functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions
build-nfa: Internal generic functions

C
cache-count: Internal functions
cache-entry-table: Internal generic functions
cache-entry-table: Internal generic functions
cache-size: Internal generic functions
cache-size: Internal generic functions
canonical-rotation: Internal functions
canonicalize-method-place-notation: Exported functions
canonicalize-place-notation: Exported functions
cccbr-name: Exported functions
changep: Exported functions
changes-info: Internal functions
check-type*: Internal macros
checked-hash-set-table: Internal functions
clause-for-in-hash-set-1: Internal macros
clear-method-traits: Internal functions
clrcache: Internal functions
collapse-whitespace: Internal functions
compare-rows: Internal functions
copy-row: Exported functions
create-fch-group: Internal functions
current-token: Internal functions
cycles: Exported functions

D
def-named-row: Internal macros
define-hunt-path-constants: Internal macros
define-method-lookup: Internal macros
define-method-trait: Internal macros
define-thread-local: Internal macros
deflock: Internal macros
do-hash-set: Exported macros
download-zipped-database: Internal functions

E
empty-transition: Internal generic functions
empty-transition: Internal generic functions
encode-place-notation: Internal functions
ensure-valid-bell: Internal functions
ensure-valid-bell-class: Internal functions
ensure-valid-run: Internal functions
entry-key: Internal generic functions
entry-key: Internal generic functions
entry-value: Internal generic functions
entry-value: Internal generic functions
execute-with-methods-database: Internal functions

F
falseness-groups: Internal functions
fch-group: Exported functions
fch-group-elements: Exported functions
fch-group-index: Internal functions
fch-group-name: Exported functions
fch-group-p: Internal functions
fch-group-parity: Exported functions
fch-groups-string: Exported functions
fch-lessp: Internal functions
fch-list-f: Internal macros
follow-empty-transitions: Internal functions
format-pattern: Exported functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
format-pattern-element: Internal generic functions
Function, %%lookup-methods-from-changes: Internal functions
Function, %assemble-row: Internal functions
Function, %counts: Internal functions
Function, %execute-with-methods-database: Internal functions
Function, %extreme-hash-set: Internal functions
Function, %fill-bells-vector: Internal functions
Function, %get-changes: Internal functions
Function, %get-classification: Internal functions
Function, %get-contains-jump-changes: Internal functions
Function, %get-course-length: Internal functions
Function, %get-hunt-bell-info: Internal functions
Function, %get-hunt-bells: Internal functions
Function, %get-lead-count: Internal functions
Function, %get-lead-head: Internal functions
Function, %get-lead-head-code: Internal functions
Function, %get-lead-length: Internal functions
Function, %get-plain-course: Internal functions
Function, %get-plain-lead: Internal functions
Function, %get-principal-hunt-bells: Internal functions
Function, %get-secondary-hunt-bells: Internal functions
Function, %get-working-bells: Internal functions
Function, %hash-set-intersection: Internal functions
Function, %hash-set-union: Internal functions
Function, %in-course-p: Internal functions
Function, %lookup-method: Internal functions
Function, %lookup-methods: Internal functions
Function, %lookup-methods-by-name: Internal functions
Function, %lookup-methods-by-notation: Internal functions
Function, %lookup-methods-from-changes: Internal functions
Function, %make-hash-set: Internal functions
Function, %make-match-counter: Internal functions
Function, %make-row: Internal functions
Function, %methods-database-attributes: Internal functions
Function, %npermute-hash-set: Internal functions
Function, %parse-change: Internal functions
Function, %parse-place-notation: Internal functions
Function, %permute: Internal functions
Function, %placesp: Internal functions
Function, %plain-classification: Internal functions
Function, %roundsp: Internal functions
Function, %rows-match-p: Internal functions
Function, %tenors-fixed-p: Internal functions
Function, %treble-dodging-classification: Internal functions
Function, %update-changes: Internal functions
Function, %update-classification: Internal functions
Function, %update-course-length: Internal functions
Function, %update-lead-count: Internal functions
Function, %update-lead-length: Internal functions
Function, %update-methods-database: Internal functions
Function, %update-plain-course: Internal functions
Function, %update-plain-lead: Internal functions
Function, %with-lock: Internal functions
Function, %write-place-notation: Internal functions
Function, (setf hunt-path-info-apex): Internal functions
Function, (setf hunt-path-info-bell): Internal functions
Function, (setf hunt-path-info-kind): Internal functions
Function, (setf hunt-path-info-little-p): Internal functions
Function, (setf hunt-path-info-section-length): Internal functions
Function, (setf match-counter-%handstroke-p): Internal functions
Function, (setf match-counter-dfas): Internal functions
Function, (setf match-counter-patterns-vector): Internal functions
Function, (setf method-traits-changes): Internal functions
Function, (setf method-traits-classification): Internal functions
Function, (setf method-traits-contains-jump-changes): Internal functions
Function, (setf method-traits-course-length): Internal functions
Function, (setf method-traits-hunt-bells): Internal functions
Function, (setf method-traits-lead-count): Internal functions
Function, (setf method-traits-lead-head): Internal functions
Function, (setf method-traits-lead-head-code): Internal functions
Function, (setf method-traits-lead-length): Internal functions
Function, (setf method-traits-plain-course): Internal functions
Function, (setf method-traits-plain-lead): Internal functions
Function, (setf method-traits-principal-hunt-bells): Internal functions
Function, (setf method-traits-secondary-hunt-bells): Internal functions
Function, (setf method-traits-working-bells): Internal functions
Function, (setf row-bells): Internal functions
Function, (setf row-count-backstroke): Internal functions
Function, (setf row-count-double-row-p): Internal functions
Function, (setf row-count-handstroke): Internal functions
Function, (setf row-count-label): Internal functions
Function, (setf row-count-pattern): Internal functions
Function, add-entry: Internal functions
Function, add-pattern: Exported functions
Function, add-patterns: Exported functions
Function, add-transition: Internal functions
Function, advance-token: Internal functions
Function, alter-stage: Exported functions
Function, bell-at-position: Exported functions
Function, bell-from-name: Exported functions
Function, bell-name: Exported functions
Function, bells-list: Exported functions
Function, bells-vector: Exported functions
Function, build-dfa-state: Internal functions
Function, cache-count: Internal functions
Function, canonical-rotation: Internal functions
Function, canonicalize-method-place-notation: Exported functions
Function, canonicalize-place-notation: Exported functions
Function, cccbr-name: Exported functions
Function, changep: Exported functions
Function, changes-info: Internal functions
Function, checked-hash-set-table: Internal functions
Function, clear-method-traits: Internal functions
Function, clrcache: Internal functions
Function, collapse-whitespace: Internal functions
Function, compare-rows: Internal functions
Function, copy-row: Exported functions
Function, create-fch-group: Internal functions
Function, current-token: Internal functions
Function, cycles: Exported functions
Function, download-zipped-database: Internal functions
Function, encode-place-notation: Internal functions
Function, ensure-valid-bell: Internal functions
Function, ensure-valid-bell-class: Internal functions
Function, ensure-valid-run: Internal functions
Function, execute-with-methods-database: Internal functions
Function, falseness-groups: Internal functions
Function, fch-group: Exported functions
Function, fch-group-elements: Exported functions
Function, fch-group-index: Internal functions
Function, fch-group-name: Exported functions
Function, fch-group-p: Internal functions
Function, fch-group-parity: Exported functions
Function, fch-groups-string: Exported functions
Function, fch-lessp: Internal functions
Function, follow-empty-transitions: Internal functions
Function, format-pattern: Exported functions
Function, generate-rows-error: Internal functions
Function, generate-rows-initial-row: Internal functions
Function, get-accessor-names: Internal functions
Function, get-db-info: Internal functions
Function, get-etag: Internal functions
Function, get-method-traits: Internal functions
Function, get-newest-key: Internal functions
Function, get-newest-value: Internal functions
Function, getcache: Internal functions
Function, hash-set: Exported functions
Function, hash-set-adjoin: Exported functions
Function, hash-set-clear: Exported functions
Function, hash-set-copy: Exported functions
Function, hash-set-count: Exported functions
Function, hash-set-delete: Exported functions
Function, hash-set-difference: Exported functions
Function, hash-set-elements: Exported functions
Function, hash-set-empty-p: Exported functions
Function, hash-set-intersection: Exported functions
Function, hash-set-member: Exported functions
Function, hash-set-nadjoin: Exported functions
Function, hash-set-ndifference: Exported functions
Function, hash-set-nintersection: Exported functions
Function, hash-set-nunion: Exported functions
Function, hash-set-p: Exported functions
Function, hash-set-proper-subset-p: Exported functions
Function, hash-set-remove: Exported functions
Function, hash-set-subset-p: Exported functions
Function, hash-set-table: Internal functions
Function, hash-set-union: Exported functions
Function, header-etag: Internal functions
Function, hunt-path-info-apex: Internal functions
Function, hunt-path-info-bell: Internal functions
Function, hunt-path-info-kind: Internal functions
Function, hunt-path-info-little-p: Internal functions
Function, hunt-path-info-section-length: Internal functions
Function, in-course-p: Exported functions
Function, inverse: Exported functions
Function, involutionp: Exported functions
Function, jump-change-error: Internal functions
Function, lead-end-kind: Internal functions
Function, lead-head-code: Internal functions
Function, lookup-method: Exported functions
Function, lookup-methods-by-name: Exported functions
Function, lookup-methods-by-notation: Exported functions
Function, lookup-methods-from-changes: Exported functions
Function, make-dfa: Internal functions
Function, make-dfa-state: Internal functions
Function, make-fch-group: Internal functions
Function, make-hash-set: Exported functions
Function, make-hunt-path-info: Internal functions
Function, make-lru-cache: Internal functions
Function, make-match-counter: Exported functions
Function, make-match-counter-dfas: Internal functions
Function, make-method-traits: Internal functions
Function, make-nfa: Internal functions
Function, make-nfa-state: Internal functions
Function, make-pattern-parse-state: Internal functions
Function, make-row-count: Internal functions
Function, map-hash-set: Exported functions
Function, match-counter-%handstroke-p: Internal functions
Function, match-counter-counts: Exported functions
Function, match-counter-dfas: Internal functions
Function, match-counter-handstroke-p: Exported functions
Function, match-counter-labels: Exported functions
Function, match-counter-pattern: Exported functions
Function, match-counter-patterns-table: Internal functions
Function, match-counter-patterns-vector: Internal functions
Function, match-counter-stage: Exported functions
Function, method: Exported functions
Function, method-canonical-rotation-key: Exported functions
Function, method-changes: Exported functions
Function, method-classification: Exported functions
Function, method-contains-jump-changes: Exported functions
Function, method-course-length: Exported functions
Function, method-falseness: Exported functions
Function, method-hunt-bells: Exported functions
Function, method-lead-count: Exported functions
Function, method-lead-head: Exported functions
Function, method-lead-head-code: Exported functions
Function, method-lead-length: Exported functions
Function, method-plain-course: Exported functions
Function, method-plain-lead: Exported functions
Function, method-principal-hunt-bells: Exported functions
Function, method-property: Exported functions
Function, method-rotations-p: Exported functions
Function, method-secondary-hunt-bells: Exported functions
Function, method-title: Exported functions
Function, method-traits-changes: Internal functions
Function, method-traits-classification: Internal functions
Function, method-traits-contains-jump-changes: Internal functions
Function, method-traits-course-length: Internal functions
Function, method-traits-hunt-bells: Internal functions
Function, method-traits-lead-count: Internal functions
Function, method-traits-lead-head: Internal functions
Function, method-traits-lead-head-code: Internal functions
Function, method-traits-lead-length: Internal functions
Function, method-traits-plain-course: Internal functions
Function, method-traits-plain-lead: Internal functions
Function, method-traits-principal-hunt-bells: Internal functions
Function, method-traits-secondary-hunt-bells: Internal functions
Function, method-traits-working-bells: Internal functions
Function, method-true-plain-course-p: Exported functions
Function, method-working-bells: Exported functions
Function, methods-database-attributes: Exported functions
Function, move-entry: Internal functions
Function, named-row-definition: Internal functions
Function, nfa-id: Internal functions
Function, nunfold: Internal functions
Function, order: Exported functions
Function, parse-alternative: Internal functions
Function, parse-bell-class: Internal functions
Function, parse-disjunction: Internal functions
Function, parse-element: Internal functions
Function, parse-method-title: Exported functions
Function, parse-pattern: Exported functions
Function, parse-place-notation: Exported functions
Function, parse-row: Exported functions
Function, parse-run: Internal functions
Function, parse-timestamp: Internal functions
Function, pattern-parse-error: Exported functions
Function, pattern-parse-state-end-p: Internal functions
Function, permute: Exported functions
Function, permute-by-inverse: Exported functions
Function, permute-collection-type-error: Internal functions
Function, place-notation-error: Exported functions
Function, place-notation-string: Exported functions
Function, placesp: Exported functions
Function, plain-bob-lead-end-p: Exported functions
Function, position-of-bell: Exported functions
Function, prepare-database: Internal functions
Function, prin1-hash-set: Internal functions
Function, publish-trait: Internal functions
Function, putcache: Internal functions
Function, read-place-notation: Exported functions
Function, read-row: Exported functions
Function, record-matches: Exported functions
Function, remcache: Internal functions
Function, remove-all-patterns: Exported functions
Function, remove-entry: Internal functions
Function, remove-pattern: Exported functions
Function, reset-match-counter: Exported functions
Function, rounds: Exported functions
Function, roundsp: Exported functions
Function, row: Exported functions
Function, row-bells: Internal functions
Function, row-count-backstroke: Internal functions
Function, row-count-double-row-p: Internal functions
Function, row-count-handstroke: Internal functions
Function, row-count-label: Internal functions
Function, row-count-pattern: Internal functions
Function, row-creation-error: Internal functions
Function, row-list-less-p: Internal functions
Function, row-match-error: Exported functions
Function, row-match-p: Exported functions
Function, row-string: Exported functions
Function, rowp: Exported functions
Function, rows-distinct-p: Internal functions
Function, same-type-p: Internal functions
Function, set-method-classified-name: Exported functions
Function, sharp-bang-reader: Internal functions
Function, signal-method-lookup-error: Internal functions
Function, signature: Internal functions
Function, sort-fch-set: Internal functions
Function, split-palindromic-changes: Internal functions
Function, sql-wildcardify: Internal functions
Function, stage: Exported functions
Function, stage-from-name: Exported functions
Function, stage-name: Exported functions
Function, subseq-reversed-circular: Internal functions
Function, tenors-fixed-p: Exported functions
Function, test-jump-palindrome: Internal functions
Function, test-ordinary-palindrome: Internal functions
Function, thread-call: Internal functions
Function, total-bells: Internal functions
Function, unzip-database: Internal functions
Function, update-methods-database: Exported functions
Function, use-roan-package: Exported functions
Function, which-grandsire-lead-head: Exported functions
Function, which-lead-head: Internal functions
Function, which-plain-bob-lead-head: Exported functions
Function, write-place-notation: Exported functions
Function, write-row: Exported functions

G
generate-rows: Exported generic functions
generate-rows: Exported generic functions
generate-rows: Exported generic functions
generate-rows: Exported generic functions
generate-rows-error: Internal functions
generate-rows-initial-row: Internal functions
Generic Function, (setf empty-transition): Internal generic functions
Generic Function, (setf entry-key): Internal generic functions
Generic Function, (setf entry-value): Internal generic functions
Generic Function, (setf method-name): Exported generic functions
Generic Function, (setf method-place-notation): Exported generic functions
Generic Function, (setf method-properties): Exported generic functions
Generic Function, (setf method-stage): Exported generic functions
Generic Function, (setf newest-entry): Internal generic functions
Generic Function, (setf next-entry): Internal generic functions
Generic Function, (setf oldest-entry): Internal generic functions
Generic Function, (setf pattern-parse-error-index): Internal generic functions
Generic Function, (setf pattern-parse-error-message): Internal generic functions
Generic Function, (setf pattern-parse-error-pattern): Internal generic functions
Generic Function, (setf previous-entry): Internal generic functions
Generic Function, build-nfa: Internal generic functions
Generic Function, cache-entry-table: Internal generic functions
Generic Function, cache-size: Internal generic functions
Generic Function, empty-transition: Internal generic functions
Generic Function, entry-key: Internal generic functions
Generic Function, entry-value: Internal generic functions
Generic Function, format-pattern-element: Internal generic functions
Generic Function, generate-rows: Exported generic functions
Generic Function, get-final: Internal generic functions
Generic Function, inappropriate-method-error-details: Exported generic functions
Generic Function, inappropriate-method-error-method: Exported generic functions
Generic Function, method-name: Exported generic functions
Generic Function, method-place-notation: Exported generic functions
Generic Function, method-properties: Exported generic functions
Generic Function, method-stage: Exported generic functions
Generic Function, named-row-pattern: Exported generic functions
Generic Function, newest-entry: Internal generic functions
Generic Function, next-entry: Internal generic functions
Generic Function, ngenerate-rows: Exported generic functions
Generic Function, no-place-notation-error-method: Internal generic functions
Generic Function, npermute-by-collection: Exported generic functions
Generic Function, npermute-collection: Exported generic functions
Generic Function, oldest-entry: Internal generic functions
Generic Function, pattern-parse-error-index: Internal generic functions
Generic Function, pattern-parse-error-message: Internal generic functions
Generic Function, pattern-parse-error-pattern: Internal generic functions
Generic Function, permute-by-collection: Exported generic functions
Generic Function, permute-collection: Exported generic functions
Generic Function, previous-entry: Internal generic functions
Generic Function, set-final: Internal generic functions
Generic Function, transitions: Internal generic functions
get-accessor-names: Internal functions
get-db-info: Internal functions
get-entry: Internal macros
get-etag: Internal functions
get-final: Internal generic functions
get-final: Internal generic functions
get-final: Internal generic functions
get-method-traits: Internal functions
get-newest-key: Internal functions
get-newest-value: Internal functions
getcache: Internal functions

H
hash-set: Exported functions
hash-set-adjoin: Exported functions
hash-set-clear: Exported functions
hash-set-copy: Exported functions
hash-set-count: Exported functions
hash-set-delete: Exported functions
hash-set-deletef: Exported macros
hash-set-difference: Exported functions
hash-set-elements: Exported functions
hash-set-empty-p: Exported functions
hash-set-intersection: Exported functions
hash-set-member: Exported functions
hash-set-nadjoin: Exported functions
hash-set-nadjoinf: Exported macros
hash-set-ndifference: Exported functions
hash-set-nintersection: Exported functions
hash-set-nunion: Exported functions
hash-set-p: Exported functions
hash-set-proper-subset-p: Exported functions
hash-set-remove: Exported functions
hash-set-subset-p: Exported functions
hash-set-table: Internal functions
hash-set-union: Exported functions
header-etag: Internal functions
hunt-path-info-apex: Internal functions
hunt-path-info-bell: Internal functions
hunt-path-info-kind: Internal functions
hunt-path-info-little-p: Internal functions
hunt-path-info-section-length: Internal functions

I
in-course-p: Exported functions
inappropriate-method-error-details: Exported generic functions
inappropriate-method-error-details: Exported generic functions
inappropriate-method-error-method: Exported generic functions
inappropriate-method-error-method: Exported generic functions
inverse: Exported functions
involutionp: Exported functions

J
jump-change-error: Internal functions

L
lead-end-kind: Internal functions
lead-head-code: Internal functions
logiorf: Internal macros
lookup-method: Exported functions
lookup-methods-by-name: Exported functions
lookup-methods-by-notation: Exported functions
lookup-methods-from-changes: Exported functions

M
Macro, check-type*: Internal macros
Macro, clause-for-in-hash-set-1: Internal macros
Macro, def-named-row: Internal macros
Macro, define-hunt-path-constants: Internal macros
Macro, define-method-lookup: Internal macros
Macro, define-method-trait: Internal macros
Macro, define-thread-local: Internal macros
Macro, deflock: Internal macros
Macro, do-hash-set: Exported macros
Macro, fch-list-f: Internal macros
Macro, get-entry: Internal macros
Macro, hash-set-deletef: Exported macros
Macro, hash-set-nadjoinf: Exported macros
Macro, logiorf: Internal macros
Macro, permutef: Exported macros
Macro, with-bell-property-resolver: Internal macros
Macro, with-initial-format-characters: Internal macros
Macro, with-lock: Internal macros
Macro, with-methods-database: Exported macros
Macro, with-warnings-muffled: Internal macros
make-dfa: Internal functions
make-dfa-state: Internal functions
make-fch-group: Internal functions
make-hash-set: Exported functions
make-hunt-path-info: Internal functions
make-lru-cache: Internal functions
make-match-counter: Exported functions
make-match-counter-dfas: Internal functions
make-method-traits: Internal functions
make-nfa: Internal functions
make-nfa-state: Internal functions
make-pattern-parse-state: Internal functions
make-row-count: Internal functions
map-hash-set: Exported functions
match-counter-%handstroke-p: Internal functions
match-counter-counts: Exported functions
match-counter-dfas: Internal functions
match-counter-handstroke-p: Exported functions
match-counter-labels: Exported functions
match-counter-pattern: Exported functions
match-counter-patterns-table: Internal functions
match-counter-patterns-vector: Internal functions
match-counter-stage: Exported functions
method: Exported functions
Method, (setf empty-transition): Internal generic functions
Method, (setf entry-key): Internal generic functions
Method, (setf entry-value): Internal generic functions
Method, (setf method-name): Exported generic functions
Method, (setf method-name): Exported generic functions
Method, (setf method-place-notation): Exported generic functions
Method, (setf method-place-notation): Exported generic functions
Method, (setf method-properties): Exported generic functions
Method, (setf method-properties): Exported generic functions
Method, (setf method-stage): Exported generic functions
Method, (setf method-stage): Exported generic functions
Method, (setf newest-entry): Internal generic functions
Method, (setf next-entry): Internal generic functions
Method, (setf oldest-entry): Internal generic functions
Method, (setf pattern-parse-error-index): Internal generic functions
Method, (setf pattern-parse-error-message): Internal generic functions
Method, (setf pattern-parse-error-pattern): Internal generic functions
Method, (setf previous-entry): Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, build-nfa: Internal generic functions
Method, cache-entry-table: Internal generic functions
Method, cache-size: Internal generic functions
Method, empty-transition: Internal generic functions
Method, entry-key: Internal generic functions
Method, entry-value: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, format-pattern-element: Internal generic functions
Method, generate-rows: Exported generic functions
Method, generate-rows: Exported generic functions
Method, generate-rows: Exported generic functions
Method, get-final: Internal generic functions
Method, get-final: Internal generic functions
Method, inappropriate-method-error-details: Exported generic functions
Method, inappropriate-method-error-method: Exported generic functions
Method, method-name: Exported generic functions
Method, method-name: Exported generic functions
Method, method-place-notation: Exported generic functions
Method, method-place-notation: Exported generic functions
Method, method-properties: Exported generic functions
Method, method-properties: Exported generic functions
Method, method-stage: Exported generic functions
Method, method-stage: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, named-row-pattern: Exported generic functions
Method, newest-entry: Internal generic functions
Method, next-entry: Internal generic functions
Method, ngenerate-rows: Exported generic functions
Method, ngenerate-rows: Exported generic functions
Method, ngenerate-rows: Exported generic functions
Method, no-place-notation-error-method: Internal generic functions
Method, npermute-by-collection: Exported generic functions
Method, npermute-by-collection: Exported generic functions
Method, npermute-by-collection: Exported generic functions
Method, npermute-by-collection: Exported generic functions
Method, npermute-collection: Exported generic functions
Method, npermute-collection: Exported generic functions
Method, npermute-collection: Exported generic functions
Method, npermute-collection: Exported generic functions
Method, oldest-entry: Internal generic functions
Method, pattern-parse-error-index: Internal generic functions
Method, pattern-parse-error-message: Internal generic functions
Method, pattern-parse-error-pattern: Internal generic functions
Method, permute-by-collection: Exported generic functions
Method, permute-by-collection: Exported generic functions
Method, permute-by-collection: Exported generic functions
Method, permute-by-collection: Exported generic functions
Method, permute-collection: Exported generic functions
Method, permute-collection: Exported generic functions
Method, permute-collection: Exported generic functions
Method, permute-collection: Exported generic functions
Method, previous-entry: Internal generic functions
Method, set-final: Internal generic functions
Method, transitions: Internal generic functions
Method, transitions: Internal generic functions
method-canonical-rotation-key: Exported functions
method-changes: Exported functions
method-classification: Exported functions
method-contains-jump-changes: Exported functions
method-course-length: Exported functions
method-falseness: Exported functions
method-hunt-bells: Exported functions
method-lead-count: Exported functions
method-lead-head: Exported functions
method-lead-head-code: Exported functions
method-lead-length: Exported functions
method-name: Exported generic functions
method-name: Exported generic functions
method-name: Exported generic functions
method-place-notation: Exported generic functions
method-place-notation: Exported generic functions
method-place-notation: Exported generic functions
method-plain-course: Exported functions
method-plain-lead: Exported functions
method-principal-hunt-bells: Exported functions
method-properties: Exported generic functions
method-properties: Exported generic functions
method-properties: Exported generic functions
method-property: Exported functions
method-rotations-p: Exported functions
method-secondary-hunt-bells: Exported functions
method-stage: Exported generic functions
method-stage: Exported generic functions
method-stage: Exported generic functions
method-title: Exported functions
method-traits-changes: Internal functions
method-traits-classification: Internal functions
method-traits-contains-jump-changes: Internal functions
method-traits-course-length: Internal functions
method-traits-hunt-bells: Internal functions
method-traits-lead-count: Internal functions
method-traits-lead-head: Internal functions
method-traits-lead-head-code: Internal functions
method-traits-lead-length: Internal functions
method-traits-plain-course: Internal functions
method-traits-plain-lead: Internal functions
method-traits-principal-hunt-bells: Internal functions
method-traits-secondary-hunt-bells: Internal functions
method-traits-working-bells: Internal functions
method-true-plain-course-p: Exported functions
method-working-bells: Exported functions
methods-database-attributes: Exported functions
move-entry: Internal functions

N
named-row-definition: Internal functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
named-row-pattern: Exported generic functions
newest-entry: Internal generic functions
newest-entry: Internal generic functions
next-entry: Internal generic functions
next-entry: Internal generic functions
nfa-id: Internal functions
ngenerate-rows: Exported generic functions
ngenerate-rows: Exported generic functions
ngenerate-rows: Exported generic functions
ngenerate-rows: Exported generic functions
no-place-notation-error-method: Internal generic functions
no-place-notation-error-method: Internal generic functions
npermute-by-collection: Exported generic functions
npermute-by-collection: Exported generic functions
npermute-by-collection: Exported generic functions
npermute-by-collection: Exported generic functions
npermute-by-collection: Exported generic functions
npermute-collection: Exported generic functions
npermute-collection: Exported generic functions
npermute-collection: Exported generic functions
npermute-collection: Exported generic functions
npermute-collection: Exported generic functions
nunfold: Internal functions

O
oldest-entry: Internal generic functions
oldest-entry: Internal generic functions
order: Exported functions

P
parse-alternative: Internal functions
parse-bell-class: Internal functions
parse-disjunction: Internal functions
parse-element: Internal functions
parse-method-title: Exported functions
parse-pattern: Exported functions
parse-place-notation: Exported functions
parse-row: Exported functions
parse-run: Internal functions
parse-timestamp: Internal functions
pattern-parse-error: Exported functions
pattern-parse-error-index: Internal generic functions
pattern-parse-error-index: Internal generic functions
pattern-parse-error-message: Internal generic functions
pattern-parse-error-message: Internal generic functions
pattern-parse-error-pattern: Internal generic functions
pattern-parse-error-pattern: Internal generic functions
pattern-parse-state-end-p: Internal functions
permute: Exported functions
permute-by-collection: Exported generic functions
permute-by-collection: Exported generic functions
permute-by-collection: Exported generic functions
permute-by-collection: Exported generic functions
permute-by-collection: Exported generic functions
permute-by-inverse: Exported functions
permute-collection: Exported generic functions
permute-collection: Exported generic functions
permute-collection: Exported generic functions
permute-collection: Exported generic functions
permute-collection: Exported generic functions
permute-collection-type-error: Internal functions
permutef: Exported macros
place-notation-error: Exported functions
place-notation-string: Exported functions
placesp: Exported functions
plain-bob-lead-end-p: Exported functions
position-of-bell: Exported functions
prepare-database: Internal functions
previous-entry: Internal generic functions
previous-entry: Internal generic functions
prin1-hash-set: Internal functions
publish-trait: Internal functions
putcache: Internal functions

R
read-place-notation: Exported functions
read-row: Exported functions
record-matches: Exported functions
remcache: Internal functions
remove-all-patterns: Exported functions
remove-entry: Internal functions
remove-pattern: Exported functions
reset-match-counter: Exported functions
rounds: Exported functions
roundsp: Exported functions
row: Exported functions
row-bells: Internal functions
row-count-backstroke: Internal functions
row-count-double-row-p: Internal functions
row-count-handstroke: Internal functions
row-count-label: Internal functions
row-count-pattern: Internal functions
row-creation-error: Internal functions
row-list-less-p: Internal functions
row-match-error: Exported functions
row-match-p: Exported functions
row-string: Exported functions
rowp: Exported functions
rows-distinct-p: Internal functions

S
same-type-p: Internal functions
set-final: Internal generic functions
set-final: Internal generic functions
set-method-classified-name: Exported functions
Setf Expander, (setf getcache): Internal functions
Setf Expander, (setf match-counter-handstroke-p): Exported functions
Setf Expander, (setf method-property): Exported functions
Setf Expander, (setf method-title): Exported functions
sharp-bang-reader: Internal functions
signal-method-lookup-error: Internal functions
signature: Internal functions
sort-fch-set: Internal functions
split-palindromic-changes: Internal functions
sql-wildcardify: Internal functions
stage: Exported functions
stage-from-name: Exported functions
stage-name: Exported functions
subseq-reversed-circular: Internal functions

T
tenors-fixed-p: Exported functions
test-jump-palindrome: Internal functions
test-ordinary-palindrome: Internal functions
thread-call: Internal functions
total-bells: Internal functions
transitions: Internal generic functions
transitions: Internal generic functions
transitions: Internal generic functions

U
unzip-database: Internal functions
update-methods-database: Exported functions
use-roan-package: Exported functions

W
which-grandsire-lead-head: Exported functions
which-lead-head: Internal functions
which-plain-bob-lead-head: Exported functions
with-bell-property-resolver: Internal macros
with-initial-format-characters: Internal macros
with-lock: Internal macros
with-methods-database: Exported macros
with-warnings-muffled: Internal macros
write-place-notation: Exported functions
write-row: Exported functions

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

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

A.3 Variables

Jump to:   %   *   +  
A   B   C   D   E   F   H   I   K   L   M   N   O   P   S   T   V   W  
Index Entry  Section

%
%handstroke-p: Exported structures

*
*change-cache*: Internal special variables
*collapsable-whitespace-scanner*: Internal special variables
*contains-collapsable-whitespace-scanner*: Internal special variables
*cross-character*: Exported special variables
*default-stage*: Exported special variables
*dfa-stage*: Internal special variables
*dfa-states*: Internal special variables
*fch-groups-by-course-head*: Internal special variables
*fch-groups-by-name*: Internal special variables
*last-fch-group-index*: Internal special variables
*last-nfa-id*: Internal special variables
*nfa-stage*: Internal special variables
*pattern-cache*: Internal special variables
*pattern-parse-state*: Internal special variables
*print-bells-upper-case*: Exported special variables
*rows-distinct-p-hash-table*: Internal special variables
*threading-p*: Internal special variables

+
+alliance+: Internal constants
+bell-names+: Internal constants
+cccbr-name-pattern+: Internal special variables
+change-cache-size+: Internal constants
+char-code-array-length+: Internal constants
+cross-changes+: Internal constants
+database-entry-name+: Internal constants
+early-index+: Internal constants
+even-stage-lead-head-codes+: Internal constants
+extended-place-notation-scanner+*: Internal constants
+huffman-table+: Internal constants
+hunt-changes+: Internal constants
+hunt-index+: Internal constants
+hunt-path-keywords+: Internal constants
+hybrid+: Internal constants
+incidence-initial-hash-set-size+: Internal constants
+initial-cross-character+: Internal constants
+initial-match-counter-size+: Internal constants
+initial-print-bells-upper-case+: Internal constants
+late-index+: Internal constants
+maximum-stage+: Exported constants
+methods-database+: Internal constants
+methods-database-url+: Internal constants
+minimum-stage+: Exported constants
+named-bells+: Internal constants
+named-stages+: Internal constants
+no-explicit-class-names+: Internal constants
+odd-stage-lead-head-codes+: Internal constants
+pattern-cache-size+: Internal constants
+pattern-characters+: Internal constants
+pattern-token+*: Internal constants
+place-notation-chars+: Internal constants
+place-notation-fragment-scanner+: Internal constants
+plain+: Internal constants
+rounds-bell-array+: Internal constants
+row-signature-shift+: Internal constants
+run-token+*: Internal constants
+seconds-index+: Internal constants
+stage-names+: Internal constants
+status-ok+: Internal constants
+summary-initial-hash-set-size+: Internal constants
+timestamp-scanner+: Internal constants
+treble-dodging+: Internal constants
+treble-place+: Internal constants

A
apex: Internal structures

B
backstroke: Internal structures
bell: Internal structures
bells: Exported structures

C
changes: Internal structures
classification: Internal structures
Constant, +alliance+: Internal constants
Constant, +bell-names+: Internal constants
Constant, +change-cache-size+: Internal constants
Constant, +char-code-array-length+: Internal constants
Constant, +cross-changes+: Internal constants
Constant, +database-entry-name+: Internal constants
Constant, +early-index+: Internal constants
Constant, +even-stage-lead-head-codes+: Internal constants
Constant, +extended-place-notation-scanner+*: Internal constants
Constant, +huffman-table+: Internal constants
Constant, +hunt-changes+: Internal constants
Constant, +hunt-index+: Internal constants
Constant, +hunt-path-keywords+: Internal constants
Constant, +hybrid+: Internal constants
Constant, +incidence-initial-hash-set-size+: Internal constants
Constant, +initial-cross-character+: Internal constants
Constant, +initial-match-counter-size+: Internal constants
Constant, +initial-print-bells-upper-case+: Internal constants
Constant, +late-index+: Internal constants
Constant, +maximum-stage+: Exported constants
Constant, +methods-database+: Internal constants
Constant, +methods-database-url+: Internal constants
Constant, +minimum-stage+: Exported constants
Constant, +named-bells+: Internal constants
Constant, +named-stages+: Internal constants
Constant, +no-explicit-class-names+: Internal constants
Constant, +odd-stage-lead-head-codes+: Internal constants
Constant, +pattern-cache-size+: Internal constants
Constant, +pattern-characters+: Internal constants
Constant, +pattern-token+*: Internal constants
Constant, +place-notation-chars+: Internal constants
Constant, +place-notation-fragment-scanner+: Internal constants
Constant, +plain+: Internal constants
Constant, +rounds-bell-array+: Internal constants
Constant, +row-signature-shift+: Internal constants
Constant, +run-token+*: Internal constants
Constant, +seconds-index+: Internal constants
Constant, +stage-names+: Internal constants
Constant, +status-ok+: Internal constants
Constant, +summary-initial-hash-set-size+: Internal constants
Constant, +timestamp-scanner+: Internal constants
Constant, +treble-dodging+: Internal constants
Constant, +treble-place+: Internal constants
contains-jump-changes: Internal structures
course-length: Internal structures

D
details: Exported conditions
dfas: Exported structures
double-row-p: Internal structures

E
elements: Exported structures
empty-transition: Internal classes

F
final: Internal classes
final: Internal classes

H
handstroke: Internal structures
hunt-bells: Internal structures

I
id: Internal classes
index: Exported conditions
index: Exported structures
index: Internal classes

K
key: Internal classes
kind: Internal structures

L
label: Internal structures
lead-count: Internal structures
lead-head: Internal structures
lead-head-code: Internal structures
lead-length: Internal structures
little-p: Internal structures

M
message: Exported conditions
method: Exported conditions
method: Exported conditions

N
name: Exported structures
name: Exported classes
newest: Internal classes
next: Internal classes

O
oldest: Internal classes

P
parity: Exported structures
pattern: Exported conditions
pattern: Internal structures
patterns-table: Exported structures
patterns-vector: Exported structures
place-notation: Exported classes
plain-course: Internal structures
plain-lead: Internal structures
previous: Internal classes
principal-hunt-bells: Internal structures
properties: Exported classes

S
secondary-hunt-bells: Internal structures
section-length: Internal structures
size: Internal classes
Slot, %handstroke-p: Exported structures
Slot, apex: Internal structures
Slot, backstroke: Internal structures
Slot, bell: Internal structures
Slot, bells: Exported structures
Slot, changes: Internal structures
Slot, classification: Internal structures
Slot, contains-jump-changes: Internal structures
Slot, course-length: Internal structures
Slot, details: Exported conditions
Slot, dfas: Exported structures
Slot, double-row-p: Internal structures
Slot, elements: Exported structures
Slot, empty-transition: Internal classes
Slot, final: Internal classes
Slot, final: Internal classes
Slot, handstroke: Internal structures
Slot, hunt-bells: Internal structures
Slot, id: Internal classes
Slot, index: Exported conditions
Slot, index: Exported structures
Slot, index: Internal classes
Slot, key: Internal classes
Slot, kind: Internal structures
Slot, label: Internal structures
Slot, lead-count: Internal structures
Slot, lead-head: Internal structures
Slot, lead-head-code: Internal structures
Slot, lead-length: Internal structures
Slot, little-p: Internal structures
Slot, message: Exported conditions
Slot, method: Exported conditions
Slot, method: Exported conditions
Slot, name: Exported structures
Slot, name: Exported classes
Slot, newest: Internal classes
Slot, next: Internal classes
Slot, oldest: Internal classes
Slot, parity: Exported structures
Slot, pattern: Exported conditions
Slot, pattern: Internal structures
Slot, patterns-table: Exported structures
Slot, patterns-vector: Exported structures
Slot, place-notation: Exported classes
Slot, plain-course: Internal structures
Slot, plain-lead: Internal structures
Slot, previous: Internal classes
Slot, principal-hunt-bells: Internal structures
Slot, properties: Exported classes
Slot, secondary-hunt-bells: Internal structures
Slot, section-length: Internal structures
Slot, size: Internal classes
Slot, stage: Exported structures
Slot, stage: Exported classes
Slot, stage: Internal classes
Slot, string: Internal classes
Slot, table: Exported structures
Slot, table: Internal classes
Slot, token: Internal classes
Slot, token-end: Internal classes
Slot, traits: Exported classes
Slot, transitions: Internal classes
Slot, transitions: Internal classes
Slot, value: Internal classes
Slot, working-bells: Internal structures
Special Variable, *change-cache*: Internal special variables
Special Variable, *collapsable-whitespace-scanner*: Internal special variables
Special Variable, *contains-collapsable-whitespace-scanner*: Internal special variables
Special Variable, *cross-character*: Exported special variables
Special Variable, *default-stage*: Exported special variables
Special Variable, *dfa-stage*: Internal special variables
Special Variable, *dfa-states*: Internal special variables
Special Variable, *fch-groups-by-course-head*: Internal special variables
Special Variable, *fch-groups-by-name*: Internal special variables
Special Variable, *last-fch-group-index*: Internal special variables
Special Variable, *last-nfa-id*: Internal special variables
Special Variable, *nfa-stage*: Internal special variables
Special Variable, *pattern-cache*: Internal special variables
Special Variable, *pattern-parse-state*: Internal special variables
Special Variable, *print-bells-upper-case*: Exported special variables
Special Variable, *rows-distinct-p-hash-table*: Internal special variables
Special Variable, *threading-p*: Internal special variables
Special Variable, +cccbr-name-pattern+: Internal special variables
stage: Exported structures
stage: Exported classes
stage: Internal classes
string: Internal classes

T
table: Exported structures
table: Internal classes
token: Internal classes
token-end: Internal classes
traits: Exported classes
transitions: Internal classes
transitions: Internal classes

V
value: Internal classes

W
working-bells: Internal structures

Jump to:   %   *   +  
A   B   C   D   E   F   H   I   K   L   M   N   O   P   S   T   V   W  

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

A.4 Data types

Jump to:   %  
B   C   D   F   H   I   J   L   M   N   P   R   S   T  
Index Entry  Section

%
%bells-vector: Internal types

B
bell: Exported types

C
cache-entry: Internal classes
Class, cache-entry: Internal classes
Class, dfa-state: Internal classes
Class, lru-cache: Internal classes
Class, method: Exported classes
Class, nfa-state: Internal classes
Class, pattern-parse-state: Internal classes
Condition, inappropriate-method-error: Exported conditions
Condition, jump-change-error: Internal conditions
Condition, mixed-stage-fch-groups-error: Exported conditions
Condition, no-place-notation-error: Exported conditions
Condition, pattern-parse-error: Exported conditions
Condition, row-creation-error: Internal conditions
Condition, row-creation-parse-error: Internal conditions
Condition, row-match-error: Exported conditions
Condition, simple-package-error: Internal conditions

D
dfa-state: Internal classes

F
fch-group: Exported structures

H
hash-set: Exported structures
hunt-path-info: Internal structures

I
inappropriate-method-error: Exported conditions

J
jump-change-error: Internal conditions

L
lru-cache: Internal classes

M
match-counter: Exported structures
method: Exported classes
method-traits: Internal structures
mixed-stage-fch-groups-error: Exported conditions

N
nfa-state: Internal classes
no-place-notation-error: Exported conditions

P
Package, roan: The roan package
pattern-parse-error: Exported conditions
pattern-parse-state: Internal classes

R
roan: The roan system
roan: The roan package
roan-base: The roan-base system
row: Exported structures
row-count: Internal structures
row-creation-error: Internal conditions
row-creation-parse-error: Internal conditions
row-match-error: Exported conditions

S
simple-package-error: Internal conditions
stage: Exported types
Structure, fch-group: Exported structures
Structure, hash-set: Exported structures
Structure, hunt-path-info: Internal structures
Structure, match-counter: Exported structures
Structure, method-traits: Internal structures
Structure, row: Exported structures
Structure, row-count: Internal structures
System, roan: The roan system
System, roan-base: The roan-base system

T
Type, %bells-vector: Internal types
Type, bell: Exported types
Type, stage: Exported types

Jump to:   %  
B   C   D   F   H   I   J   L   M   N   P   R   S   T