The roan Reference Manual

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

The roan Reference Manual

This is the roan Reference Manual, version 9.0.28, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 05:46:47 2022 GMT+0.

Table of Contents


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.

Note that Quicklisp creates a new distribution about once a month, so there may be a lag of that duration between when a new version is available in the Bitbucket repository and when that version is available in Quicklisp. If you need it sooner, you may need to download it yourself from Bitbucket.

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.


2 Systems

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


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

2.1 roan

A library to support change ringing applications

Author

Don Morrison <dfm@ringing.org>

License

MIT

Version

9.0.28

Dependencies
  • alexandria (system).
  • iterate (system).
  • named-readtables (system).
  • cl-interpol (system).
  • cl-ppcre (system).
  • plump (system).
  • local-time (system).
  • binascii (system).
  • uuid (system).
  • cl-fad (system).
  • drakma (system).
  • zip (system).
  • asdf (system).
  • asdf-encodings (system).
Source

roan.asd.

Child Components

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

3.1.1 roan/roan.asd

Source

roan.asd.

Parent Component

roan (system).

ASDF Systems

roan.


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

3.1.2 roan/package.lisp

Source

roan.asd.

Parent Component

roan (system).

Packages

roan.


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

3.1.3 roan/readtables.lisp

Dependency

package.lisp (file).

Source

roan.asd.

Parent Component

roan (system).

Public Interface
Internals

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

3.1.4 roan/util.lisp

Dependency

package.lisp (file).

Source

roan.asd.

Parent Component

roan (system).

Public Interface
Internals

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

3.1.5 roan/roan.lisp

Dependencies
Source

roan.asd.

Parent Component

roan (system).

Public Interface
Internals

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

3.1.6 roan/pattern.lisp

Dependencies
Source

roan.asd.

Parent Component

roan (system).

Public Interface
Internals

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

3.1.7 roan/method.lisp

Dependencies
Source

roan.asd.

Parent Component

roan (system).

Public Interface
Internals

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}, @code{method-name}, @code{class} and @code{class-name} from the @code{common-lisp} package. This is done because methods and their classes are important concepts in change ringing, albeit ones unrelated to CLOS methods and classes. Typically @code{method}, @code{method-name}, @code{class} and @code{class-name} should be shadowed in other packages that use the @code{roan} package. This can be done with @code{shadowing-import-from}, or the @code{:shadowing-import} option to @code{defpackage}. Note that the original Common Lisp symbols will still be available as @code{cl:method}, @code{cl:method-name}, @code{cl:class} and @code{cl:class-name}. @xref{use-roan}. @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 three symbols from the @code{common-lisp} package: @code{method}, @code{method-name}, @code{class} and @code{class-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.

Use List
  • alexandria.
  • common-lisp.
  • iterate.
Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


5.1.1 Constants

Constant: +maximum-stage+

The largest number of bells supported, 24.

Package

roan.

Source

roan.lisp.

Constant: +minimum-stage+

The smallest number of bells supported, 2.

Package

roan.

Source

roan.lisp.


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

5.1.2 Special variables

Special Variable: *blueline-default-parameters*
Package

roan.

Source

method.lisp.

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.

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.

Special Variable: *method-library-path*
Package

roan.

Source

method.lisp.

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.


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.

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.

Macro: roan-syntax (&optional on-off modify)

Turns on or off the read macros for @samp{!} and @samp{#!}, for reading rows and place notation.

If the generalized boolean @var{on-off} is true, the default, it turns on these read macros. Unless the generalized boolean @var{modify} is false, the default, it first pushes the current read table onto a stack, modifying a copy of it and making that copy the current read table. If @var{modify} is true it makes no copy and instead modifies the current readtable in place.

If @var{on-off} is false it restores the previous readtable by popping the stack. If the stack is empty it sets the readtable to a new, standard one. When @var{on-off} is false @var{modify} is ignored.

This is performed in an @code{eval-when} context to ensure it happens at compile time as well as load and execute time.

An alternative to using @code{roan-syntax} is to use @url{https://github.com/melisgl/named-readtables/, Named Readtables}. Roan defines two such readtables with names @code{:roan} and @code{:roan+interpol}. The former augments the initial Common Lisp read table with Roan’s read macros, and the latter also adds the syntax from @url{http://edicl.github.io/cl-interpol/,CL-INTERPOL}.

Package

roan.

Source

readtables.lisp.


5.1.4 Setf expanders

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

roan.

Source

pattern.lisp.

Reader

match-counter-handstroke-p (function).

Setf Expander: (setf method-class) (method)
Package

roan.

Source

method.lisp.

Reader

method-class (function).

Writer

set-method-class (function).

Setf Expander: (setf method-differential-p) (method)
Package

roan.

Source

method.lisp.

Reader

method-differential-p (function).

Writer

set-method-differential-p (function).

Setf Expander: (setf method-jump-p) (method)
Package

roan.

Source

method.lisp.

Reader

method-jump-p (function).

Writer

set-method-jump-p (function).

Setf Expander: (setf method-little-p) (method)
Package

roan.

Source

method.lisp.

Reader

method-little-p (function).

Writer

set-method-little-p (function).

Setf Expander: (setf method-stage) (method)
Package

roan.

Source

method.lisp.

Reader

method-stage (function).

Writer

set-method-stage (function).

Setf Expander: (setf method-title) (method)
Package

roan.

Source

method.lisp.

Reader

method-title (function).

Writer

set-method-title (function).


5.1.5 Ordinary 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.

Function: add-patterns (counter lists)

===merge: add-pattern

Package

roan.

Source

pattern.lisp.

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.

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.

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.

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

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.

Function: bells-vector (row &optional vector)

===merge: bells-list

Package

roan.

Source

roan.lisp.

Function: blueline (destination method &rest keys &key layout hunt-bell working-bell figures place-notation place-bells)

Draws the blue line of @var{method} as a Scalable Vector Graphics (SVG) image. The @var{method} should have its stage and place notation set. While Roan only writes SVG format images, many other pieces of software, such as @url{https://imagemagick.org/,ImageMagick}, are able to convert SVG images to other formats.

The @var{destination} can be
@itemize
@item
A text stream, open for writing:
the SVG will be written to this stream, and the stream is returned as the value of the call to @code{blueline}.

@item
The symbol @code{t}:
the SVG will be written to @code{*standard-output*}, and the value of @code{*standard-output*} is returned as the value of the
call to @code{blueline}.

@item
A pathname:
an SVG file will be written to this pathname, which will be opened with
@code{if-exists :supersede}, and the truename of the resulting file is returned.

@item
A string with a fill pointer:
the SVG will be appended to this string, as by @code{vector-push-extend}, which is returned.

@item
The symbol @code{nil}:
the SVG will be written to a new string, which is returned.
@end itemize

Several keyword parameters can be used to control details of the image produced
@table @var
@item layout
Controls the distribution of leads into columns. For differentials, or methods with multiple, equal length cycles of working bells, each cycle always starts a new column. Within a cycle the value of @var{layout} controls the number of leads in a column. If it is a non-negative integer, this is the maximum number of rows in a column; though if the lead length exceeds this value each column will contain one lead. If @code{nil} this is no limit to the number of leads in a column, each cycle of working bells then filling a column.The special value @code{:grid} may also be supplied, in which case only a single column is used for a single lead, with all the bells blue lines combined into it as a grid. The default value for @var{layout} is @code{100}.

@item hunt-bell
Controls which hunt bells are displayed specially. Those not displayed specially, are treated as working bells. If a @code{bell}, that is, a small, non-negative integer less than the stage of @var{method}, this is the hunt bell displayed specially; a list of @code{bell}s may also be supplied, for multiple hunt bells. If a supplied @code{bell} is not actually a hunt bell of @var{method} it is ignored. The keyword @code{first} is equivalent to supplying whatever the smallest hunt bell of @var{method} is. The keyword @code{:all} is equivalent to supplying a list of all the hunt bells of @var{method}. The keyword @code{:working} treats all of the hunt bells as working bells. If @var{hunt-bell} is @code{nil} no hunt bells are displayed. The default value for @var{hunt-bell} is @code{:first}.

@item working-bell
Controls which working bell of each cycle is drawn first, the others following on in the order in which they are rung. This can be a @code{bell}, or a list thereof, or one of the keywords @code{:natural}, @code{:largest} or @code{:smallest}. If @code{:natural} for each cycle the largest bell that makes a place across the lead end is chosen; if there is no such bell in a cycle the largest bell in that cycle is used. For methods with Grandsire-like palindromic symmetry the first row of the lead is used instead of the lead end. The default value for @var{working-bell} is @code{:natural}.

@item figures
If non-null figures will also be drawn, in addition to the blue line. If @code{t} they will be drawn for all leads. If @code{:lead} only for the first lead of each cycle. If @code{:half} and the @var{method} has the usual palindromic symmetry around the half lead, with one additional change at the lead end, they will only be drawn for the first half-lead; otherwise @code{:half} is equivalent to @code{:lead}. If @code{:head} the figures will only be drawn for the first lead head in each column. The default value for @var{figures} is @code{nil}.

@item place-notation
if non-null the place notation will be drawn to the left of the blue lines. If @code{t} it will be drawn for the first lead in each column. If @code{:lead} it will only be drawn for the first columnn. If @code{:half} and the @var{method} has the usual palindromic symmetry around the half lead, with one additional change at the lead end, it will only be drawn for the first half lead, plus at the lead end; otherwise @code{:half} is equivalent to @code{:lead}. The default value for @code{place-notation} is @code{nil}.

@item place-bells
May have a value of @code{nil}, @code{:dot} or @code{:label}. If non-null dots are drawn where each place bell starts, and if @code{:label} a label is drawn to the right of the blue line at each place bell’s start. The default value for @var{place-bells} is @code{:label}.
@end table

For an example, execute something like the following, and open the resulting file in a browser:
@example
@group
(blueline #P"/tmp/bastow.svg"
(lookup-method-by-title "Bastow Little Bob Minor")
:layout 12
:figures :lead
:place-notation :half)
@end group
@end example

Default values for the keyword arguments to this function can be set by assigning a property list of keywords and values to the variable @code{*blueline-default-parameters*}. @example
@group
(equal
(blueline nil
(lookup-method-by-title "Advent Surprise Major")
:layout nil
:figures t
:place-notation :lead)
(let ((*blueline-default-parameters*
’(:layout nil :figures t :place-notation :lead)))
(blueline nil (lookup-method-by-title "Advent Surprise Major"))))
@result{} t
@end group
@end example

Signals a @code{type-error} if @var{destination} is not a stream, pathname, string with a fill pointer or one of the symbols @code{t} or @code{nil}; if @var{method} is not a @code{method}; if @var{layout} is not non-negative integer, @code{nil} or the keyword @code{:grid}; if @var{hunt-bell} is not a @code{bell}, list of bells, @code{nil} or one one of the keywords @code{:first}, @code{:all} or @code{:working}. if @var{working-bell} is not a @code{bell}, list of bells, or one of the symbols @code{:natural}, @code{:largest} or @code{smallest}; if @var{figures} is not one of the keywords @code{:none}, @code{:head}, @code{:half}, @code{:lead} or @code{:always}; if @var{place-notation} is not one of the keywords @code{:none}, @code{:half}, @code{:lead} or @code{:always}; or if @var{place-bells} is not @code{nil} or one of the keywords @code{:dot} or@code{:label}. Signals a @code{no-place-notation-error} if @var{method} doesn’t have both its stage and place notation set. Can signal various errors if an I/O error occurs trying to write to a stream or create a file.

Package

roan.

Source

method.lisp.

Function: call (place-notation &key from-end offset fraction replace following following-replace)

Creates and returns a @code{call}, which modifies the changes of a lead of a @code{method}. The @var{place-notation} argument is a string of place notation, the changes corresponding to which will be added to or replace changes in a a lead of the @code{method} when applying the @code{code}. The @var{place-notation} may be @code{nil}, in which case no changes are added or replace existing ones. The @var{offset}, a non-negative integer, is the position at which to begin modifying the lead, and is measured from the beginning of the lead if the generalized boolean @var{from-end} is false, and from the end, otherwise. This can be further modifed by @var{fraction} which is multiplied by the lead length; the offset is counted forward or backward from that product. The @code{fraction}, if non-nill, must be a ratio greater than @code{0} and less than @code{1}, whose denominator evenly divides the lead length. The non-negative integer @var{replace} is the number of changes in the lead to be deleted or replaced. It is typically equal to the length of @var{changes}, which results in exact replacement of changes in the lead, but may be greater or less than that length, in which case the resulting lead is of a different length than a plain lead.

If either or both of @var{following} or @var{following-replace} are supplied the call is intended to also apply to the subsequent lead. These operate just like @var{place-notation} and @var{replace}, but on the subsequent lead, and always at the begining of that lead. This use also depends upon the caller of @code{call-apply} making correct use of its second return value.

If @var{replace} is not supplied or is @code{nil} it defaults to the number of changes represented by the @var{place-notation}. If @var{offset} is not supplied or is @code{nil}, it defaults to @code{0} if @var{from-end} is false, and otherwise to the value of @var{replace}, which may itself have been defaulted from the value of @var{place-notation}. The default value of @var{from-end} is @code{t}. The default value of @var{fraction} is @code{nil}. If @var{following} is supplied but @var{following-replace} is not, @var{following-replace} defaults to the number of changes represetned by @var{following}. If @var{following-replace} is supplied but @var{following} is not, @var{following} defaults to @code{nil}.

A @code{parse-error} is signaled if either @var{place-notation} or @var{following} is non-@code{nil} but not interpretable as place notation at the stage of @var{method}. A @code{type-error} is signaled if @var{offset} is supplied and is neither @code{nil} nor a non-negative integer; if @var{replace} is supplied and is neither @code{nil} nor a non-negative integer; @var{fraction} is supplied and is neither @code{nil} nor a ratio between @code{0} and @code{1}, exclusive; or if @var{following-replace} is supplied and is neither @code{nil} nor a non-negative integer.

Package

roan.

Source

method.lisp.

Function: call-application-error (call method message &rest args)
Package

roan.

Source

method.lisp.

Function: call-apply (method &rest calls)

Applies zero or more @var{calls} to a lead of @var{method}. Returns two values, the first a list of @code{row}s constituting the changes of the modified lead and the second @code{nil} or a @code{call}, such that the call should be applied to the succeeding lead. This second value is only non-nil for complex calls that affect two consecutive leads, as are encountered in doubles variations. One or more of the @var{calls} may be @code{nil}, in which case they are ignored, just as if they had not been supplied. If no non-nil @var{calls} are supplied returns a list of the changes constituting a plain lead of @var{method}.

When multiple @var{calls} are supplied the indices of all are computed relative to the length and position within the plain lead, before the application of any others of the calls. For example, a half-lead call that replaces the 7th’s in Cambridge Major continues to replace that change even if an earlier call removes or adds several changes.

Signals a @code{type-error} if @var{method} is not a @code{method} or if any of the @var{calls} are neither a @code{call} nor @code{nil}. Signals a @code{parse-error} if @var{method} does not have its stage or place-notation defined. Signals a @code{call-application-error} in any of the following circumstances: if the stage of @var{method} is such that the place notation or following place notation of one or more of the @var{calls} is inapplicable; if an attempt is made to apply a fractional lead @code{call} where the denominator of the fraction does not evenly divide the lead length; if the @code{call} would be positioned, or replace changes, that lie outside the lead; if a @code{call} with following changes does not replace changes up to the end of the first lead, or an attempt is made to applly two or more @code{call}s with following place notation to the same lead.

Package

roan.

Source

method.lisp.

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.

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 using lower case @samp{x} for cross, upper case letters for 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.

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.

Function: class-name (class)
Package

roan.

Source

method.lisp.

Function: classify-method (method)

Assigns the classification fields of @var{method} to match the classification assigned by the Central Council of Church Bell Ringers @url{https://cccbr.github.io/method_ringing_framework/, Framework for Method Ringing} (FMR) for the place notation contained in that @code{method}, and returns the method. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{no-place-notation-error} if either the stage or place notation of @var{method} are not set. Signals a @code{parse-error} if the value of the place notation field cannot be interpreted as place notation at the stage of @var{method}.
@example
@group
(method-title (classify-method
(method :stage 8 :place-notation "x3x6x5x45,2"))
t)
@result{} "Unnamed Differential Little Surprise Major"
@end group
@end example

Package

roan.

Source

method.lisp.

Function: comparable-method-name (string)

If @var{string} is a suitable name for a method, returns a version appropriate for
comparison with other comparable names, and otherwise returns @code{nil}.

The Central Council of Church Bell Ringers
@url{https://cccbr.github.io/method_ringing_framework/, Framework for Method
Ringing} (FMR), appendix B describes a syntax for method names and their comparisons. This
function both determines whether or not they fit within the syntax described by the FMR,
and, if so, provides a canonical representation for them suitable for comparing whether or
not two apparently different names will be considered the same when describing a method.
This comparable representation is not intended for presentation to end users, but
rather just for comparing names for equivalence.

Signals a @code{type-error} if @var{string} is not a string.
@example
@group
(comparable-method-name "New Cambridge")
@result{} "new cambridge"
(comparable-method-name "London No.3")
@result{} "london no 3"
(comparable-method-name "m@U{00E4}k@U{010D}e@U{0148} E=mc@U{00B2}")
@result{} "makcen e mc2"
(comparable-method-name "Two is Too Many Spaces")
@result{} nil
(comparable-method-name "@U{0395}@U{03BB}@U{03BB}@U{03B7}@U{03BD}@U{03B9}@U{03BA}@U{03AC} is Greek to me") @result{} nil
@end group
@end example

Package

roan.

Source

method.lisp.

Function: copy-method (method)

Returns a new @code{method} whose name and place notation are @code{equal} to those of @var{method}, and with the same classification as @var{method}. Signals a @code{type-error} if @var{method} is not a @code{method}.

Package

roan.

Source

method.lisp.

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

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

Reader: fch-group-elements (instance)
Package

roan.

Source

method.lisp.

Target Slot

elements.

Reader: fch-group-name (instance)
Package

roan.

Source

method.lisp.

Target Slot

name.

Reader: fch-group-parity (instance)
Package

roan.

Source

method.lisp.

Target Slot

parity.

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.

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.

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.

Function: hash-set-adjoin (set &rest elements)

Returns a @code{hash-set} that contains all the elements of @var{set} to which have been added the @var{elements}, or the elements of the @var{list}. As usual duplicate elements are not added, though exactly which of any potential duplicates are retained is undefined. The @code{hash-set-adjoin} and @code{hash-set-adjoin-list-elements} functions do not modify @var{set} but might return it if no changes are needed; that is, the caller cannot depend upon it necessarily being a fresh copy. The @code{hash-set-nadjoin} and @code{hash-set-nadjoin-list-elements} functions modify @var{set} (if one or more of the elements is not already contained therein) and return it. Note that @code{hash-set-[n]adjoin-list-elements} differs from @code{(apply #’hash-set-[n]adjoin ...)} in that the latter can adjoin at most @code{call-arguments-limit} elements. 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.

Function: hash-set-adjoin-list-elements (set list)

===merge: hash-set-adjoin 1

Package

roan.

Source

util.lisp.

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.

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.

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.

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.

Function: hash-set-difference (set &rest more-sets)

Returns a @code{hash-set} containing all the elements of @var{set} that are 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.

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.

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.

Function: hash-set-intersection (set &rest more-sets)

Returns 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} function does not modify @var{set} or any of the @var{more-sets}, but may return any one of them unmodified if appropriate; the caller should not assume a fresh @code{hash-set} is returned. The @code{hash-set-nintersection} function always returns @var{set}, modifying it if necessary; it does not modify any of the @var{more-sets}. Signals a @code{type-error} if @var{set} or any of the @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.

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.

Function: hash-set-nadjoin (set &rest elements)

===merge: hash-set-adjoin 2

Package

roan.

Source

util.lisp.

Function: hash-set-nadjoin-list-elements (set list)

===merge: hash-set-adjoin 3

Package

roan.

Source

util.lisp.

Function: hash-set-ndifference (set &rest more-sets)

===merge: hash-set-difference

Package

roan.

Source

util.lisp.

Function: hash-set-nintersection (set &rest more-sets)

===merge: hash-set-intersection

Package

roan.

Source

util.lisp.

Function: hash-set-nunion (set &rest more-sets)

===merge: hash-set-union

Package

roan.

Source

util.lisp.

Function: hash-set-p (object)
Package

roan.

Source

util.lisp.

Function: hash-set-pop (set &optional error-p empty-value)

Deletes an element from @var{set} and returns it. The particular element chosen to be removed and returned is undefined. If @var{set} is empty returns @var{empty-value} if the generalized Boolean @var{error-p} is false and otherwise signals an error. By default @var{error-p} is true and @var{empty-value} is @code{nil}. Signals a @code{type-error} if @var{set} is not a @code{hash-set}.

Package

roan.

Source

util.lisp.

Function: hash-set-proper-subset-p (subset superset)

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

Package

roan.

Source

util.lisp.

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.

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.

Function: hash-set-union (set &rest more-sets)

Returns a @code{hash-set} containing all the elements that appear in @var{set} or in any of the @var{more-sets}. The @code{hash-set-union} function does not modify @var{set} or any of the @var{more-sets}, but may return any one of them unmodified if appropriate; the caller should not assume a fresh @code{hash-set} is returned. The @code{hash-set-nunion} function always returns @var{set}, modifying it if necessary; it does not modify any of the @var{more-sets}. Signals a @code{type-error} if @var{set} or any of the @var{more-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.

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.

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.

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.

Function: lookup-method-by-title (title &optional errorp)

===merge: lookup-methods 1

Package

roan.

Source

method.lisp.

Function: lookup-method-info (title-or-method key)

Roan’s method library also stores metadata about many of the methods it contains. Each kind of such metadata is described by a keyword, which is passed to this function as @var{key}. The @var{title-or-method} may be a string or a @code{method}. If a string, it is the title of the method about which the metadata is sought. If the metadata indicated by @var{key} is available for the method it is returned; the type of the return value depends upon the kind of metadata sought. If no such metadata is available, including if @var{key} is a not yet supported type of metadata or if @code{title-or-method} does not correspond to any method in the library, @code{nil} is returned.

Currently supported values for @var{key} are
@table @code
@item :first-towerbell-peal
Returns a string describing the first performance of the method on tower bells. No distinction if made between ringing the method on its own or ringing it in spliced.

@item :first-handbell-peal
Returns a string describing the first performance of the method on hand bells. No distinction if made between ringing the method on its own or ringing it in spliced.

@item :complib-id
Returns an integer, which is used to index information about the method on @url{https://complib.org/,Composition Library}. This can also be used to distinguish those methods added to those from the Central Council, as the added methods do not have a @code{:complib-id}, while all those from the Council do.
@end table
Others may be added in future versions of Roan.

Signals a @code{type-error} if @var{title-or-method} is neither a string nor a @code{method}, or if @var{key} is not a keyword.
@example
@group
(lookup-method-info "Advent Surprise Major" :first-towerbell-peal)
@result{} "1988-07-31 Boston, MA (Advent)"
(lookup-method-info
(first (lookup-methods-by-notation "36x56.4.5x5.6x4x5x4x7,8"))
:complib-id)
@result{} 20042
(lookup-method-info "Advent Surprise Major"
:no-such-info)
@result{} nil
@end group
@end example

Package

roan.

Source

method.lisp.

Function: lookup-methods (&key name jump differential little class stage)

===summary===
Roan provides a library of method definitions, derived from the @url{https://cccbr.github.io/methods-library/index.html,Central Council of Church Bell Ringers Methods Library}. These are augmented with a handful of other methods not yet in the CCCBR Library, jump methods and common alternative names for a few
methods (@ref{lookup-method-info}). As delivered with Roan this library is only up to date as of the date a version of Roan was released. However, if a network connection is available, the library can be updated to the most recent version made available by the Council by using @code{update-method-library}. The Council typically updates their library weekly.

The library can be interrogated with the @code{lookup-methods}, @code{lookup-method-by-title} and @code{lookup-methods-by-notation} functions. Additional information such as dates and places of first peals containing the methods is available for some of the methods using @code{lookup-method-info}.
===endsummary===
The @code{lookup-methods} function returns a list of named @code{method}s whose name, classification and/or stage match those provided. If only a subset of these properties are provided, the return list will contain all known methods that have the provided ones.

If @var{name} is provided, it should be a string or @code{nil}, and all the methods returned will have that name. The Central Council of Church Bell Ringers @url{https://cccbr.github.io/method_ringing_framework/, Framework for Method
Ringing} (FMR), appendix C defines the form method names may take, and a mechanism for comparing them that is more complex than simply comparing strings for equality. For example, @code{"London No.3"} and @code{"London no 3"} are considered the same names. The @code{lookup-methods} function uses this mechanism. @xref{comparable-method-name}.

The @var{name} may also contain @samp{*} wildcard characters. Such a wildcard matches a series of zero or more consecutive characters. Since the @samp{*} is not a character allowed in method names by the FMR there is no ambiguity: occurrences of @samp{*} in @var{name} are always wildcard characters. Wildcards are applicable only to @var{name}, and not to any of the other arguments to @code{lookup-methods}.

If @var{stage} is provided, it should be a @code{stage}, that is a small integer. All the methods that are returned will have that stage. While a @code{method} object can have an indeterminate stage, represented by @code{nil}, all the methods returned by @code{lookup-methods} will have a definite stage, and @code{nil} is not an allowed value for the @var{stage} argument.

If @var{class} is provided, it should be @code{nil} or one of the keywords @code{:bob}, @code{:place}, @code{:surprise}, @code{:delight}, @code{:treble-bob}, @code{:treble-place}, @code{:alliance}, @code{:hybrid} or @code{:blank}. With the exception of @code{:blank}, all the methods returned will have the specified class. The value @code{:blank} matches either @code{nil}, meaning no explicit class, or @code{:hybrid}; when writing a method’s title according to the FMR the hybrid class and no class are indistinguishable, since “hybrid” is not included in the title.

If supplied, the generalized booleans @var{little}, @var{differential} and @var{jump} indicate that the returned methods should or should not have these properties. If these parameters are not supplied all otherwise matching methods in the library will be returned without regard to whether or not they have these properties.

If the title of a method is known, it can be found in the library by using @code{lookup-method-by-title}. The @var{title} should be a string. If a @code{method} with that title is in the library, it is returned. Otherwise @code{nil} is returned, unless the generalized Boolean @var{errorp} it true (it is false by default), in which case an error is signaled. In general there should never be two or more different methods in the library with the same title. Matching on the title is done using the FMR’s mechanism for comparing names. Wildcards cannot be used with @code{lookup-method-by-title}.

If the place notation of a method is known, and its name in the library is sought, @code{lookup-methods-by-notation} is available. The @var{notation-or-changes} should be either a string, in which case it viewed as place notation, or a list of @code{rows}, representing changes all of the same stage. The @var{stage} should be a @code{stage}; if not provided or @code{nil} the current value of @code{*default-stage*} is used. If @var{notation-or-changes} is a list of changes, the value of @var{stage} is ignored, the stage of those changes being used instead. Two lists are returned. The first is of methods that have the provided place notation (or corresponding changes). The second is of methods that are rotations of methods with the given place notation. Either or both lists may be empty if no suitable methods are found in the library.

There is no guarantee of what order methods are in the lists returned by @code{lookup-methods} or @code{lookup-methods-by-notation}. Instances of the “same” method returned by different invocations of these functions will typically not be @code{eq}.

A @code{type-error} is signaled if @var{stage} is not a @code{stage} (or, in the case of @code{lookup-methods-by-notation}, @code{nil}); @var{name} is not a string or @code{nil}; @var{notation-or-changes} is neither a string nor a non-empty list of @code{row}s; @var{changes} is not a non-empty list of @code{row}s; or if @var{class} is not one the allowed values. A @code{parse-error} is signaled if @var{notation-or-changes} is a string and is not parseable as place notation at @var{stage}. An @code{error} is signaled if @var{changes} is a list of @code{row}s, but they are not all of stage @var{stage} (or of @code{*default-stage*} if @var{stage} is @code{nil}). A @code{method-library-error} is signaled if the method library file cannot be read or is of the wrong format.
@example
@group
(mapcar #’method-place-notation
(lookup-methods :name "Advent"
:class :surprise
:stage 8))
@result{} ("36x56.4.5x5.6x4x5x4x7,8")
(mapcar #’method-title
(lookup-methods :name "london no 3"
:class :surprise
:stage 10))
@result{} ("London No.3 Surprise Royal")
(method-place-notation
(lookup-method-by-title "Advent Surprise Major"))
@result{} "36x56.4.5x5.6x4x5x4x7,8"
(lookup-methods :name "No such method")
@result{} nil
@end group
@group
(mapcar #’method-title
(lookup-methods :name "Cambridge*"
:class :surprise
:stage 8))
@result{} ("Cambridge Blue Surprise Major"
"Cambridge Surprise Major"
"Cambridgeshire Surprise Major")
@end group
@group
(multiple-value-bind (n r)
(lookup-methods-by-notation "36x56.4.5x5.6x4x5x4x7,8" 8)
(list
(mapcar #’method-title n)
(mapcar #’method-title r)))
@result{} (("Advent Surprise Major") nil)
(multiple-value-bind (n r)
(lookup-methods-by-notation "1.3" 3)
(list
(mapcar #’method-title n)
(mapcar #’method-title r)))
@result{} (("Reverse Original Singles")
("Original Singles"))
(method-place-notation
(lookup-method-by-title "Original Singles"))
@result{} "3.1"
@end group
@end example

Package

roan.

Source

method.lisp.

Function: lookup-methods-by-notation (notation-or-changes &optional stage)

===merge: lookup-methods 2

Package

roan.

Source

method.lisp.

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.

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.

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.

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.

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.

Setf expander for this function

(setf match-counter-handstroke-p).

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.

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.

Reader: match-counter-stage (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

stage.

Function: method (&key name jump differential little class stage place-notation)

Creates a new @code{method} instance, with the specified @var{name}, @var{stage}, @var{classification} and @var{place-notation}.
If @var{stage} is not provided, it defaults to
the current value of @code{*default-stage*}; to create a @code{method} with no stage @code{:stage nil} must be explicitly supplied.

A @code{type-error} is signaled if @var{stage} is supplied and is neither @code{nil} nor a @code{stage}; if either of @var{name} or @var{place-notation} are supplied and are neither @code{nil} nor a string; or if @code{class} is supplied and is neither @code{nil} nor one of the keywords @code{:bob}, @code{:place}, @code{:surprise}, @code{:delight}, @code{:treble-bob}, @code{:alliance}, @code{:treble-place} or @code{:hybrid}. A @code{inconsistent-method-specification-error} is signaled if the various classification details cannot occur together, such as a little principle.

Package

roan.

Source

method.lisp.

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, and only if, two methods are rotations, possibly trivially so, of one another their @code{method-canonical-rotation-key}s will always be @code{equal}. While a string, the value is essentially an opaque type and should generally not be displayed to an end user or otherwise have its structure depended upon, though it can be printed and read back in again. 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.

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.

Function: method-class (method)
Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-class).

Function: method-contains-jump-changes-p (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-p} will still return @code{nil}.

Note that this function reflects the place notation of @var{method} while @code{method-jump-p} reflects the classification stored in the method, and they may not agree.

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-p
(method :place-notation "x3x4x2x3x4x5,2"
:stage 6))
@result{} nil
(method-contains-jump-changes-p
(method :place-notation "x3x(24)x2x(35)x4x5,2"
:stage 6))
@result{} t
(method-contains-jump-changes-p
(method :stage 6))
@result{} nil
(method-contains-jump-changes-p
(method :place-notation "x3x(24)x2x(35)x4x5,2"
:stage nil))
@result{} nil
@end group
@end example

Package

roan.

Source

method.lisp.

Function: method-conventionally-symmetric-p (method)

Returns true if and only if the method has an even lead length and conventional palindromic symmetry with apices at its half-lead and lead-end. Note that this means it is false for methods such as Grandsire. Signals a @code{type-error} if @var{method} is not a @code{method}. Signals a @code{no-place-notation-error} if @var{method}’s stage or place notation are not set. Signals a @code{parse-error} if @var{method}’s place notation cannot be interpreted at its stage.
@example
@group
(method-conventionally-symmetric-p
(lookup-method-by-title "Advent Surprise Major"))
@result{} t
(method-conventionally-symmetric-p
(lookup-method-by-title "Grandsire Caters"))
@result{} nil
@end group
@end example

Package

roan.

Source

method.lisp.

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.

Function: method-differential-p (method)
Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-differential-p).

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.

Function: method-from-title (title &optional place-notation)

Creates a new @code{method} instance, with its name, classification and stage
as specified by @var{title}, and with the given @var{place-notation}.
If the title does not include a stage name, the stage of the result is the current value of @code{*default-stage*}.

Note that it is not possible to distinguish hybrid methods from non-jump principles, nor jump methods with hunt bells from those without, from their titles. By convention, if no hunt bell class is specified in @var{title} a principle, that is a method without hunt bells, is assumed. If in some specific use this is not correct it can be corrected by setting @code{method-class}, and possibly @code{method-little-p}, of the resulting method as desired.

A @code{type-error} is signaled if @var{title} is not a string, or if @var{place-notation} is neither a string nor @code{nil}.
@example
@group
(let ((m (method-from-title "Advent Surprise Major")))
(list (method-title m) (method-class m) (method-stage m)))
@result{} ("Advent" :surprise 8)
@end group
@end example

Package

roan.

Source

method.lisp.

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

Signals 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-from-title "Grandsire Doubles" "3,1.5.1.5.1"))
@result{} (0 1)
@end group
@end example

Package

roan.

Source

method.lisp.

Function: method-jump-p (method)
Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-jump-p).

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-from-title "Cambridge Surprise Minor" "x3x4x2x3x4x5,2"))
@result{} 5
(method-lead-count
(method-from-title "Cromwell Tower Block Surprise Minor" "3x3.4x2x3x4x3,6"))
@result{} 1
(method-lead-count
(method-from-title "Bexx Differential Bob Minor" "x1x1x23,2"))
@result{} 6
@end group
@end example

Package

roan.

Source

method.lisp.

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-from-title "Little Bob Major" "x1x4,2"))
@result{} !16482735
@end group
@end example

Package

roan.

Source

method.lisp.

Function: method-lead-head-code (method)

Returns the lead head code for @var{method}, as a keyword, if its stage and place

notation are set and it has Plain Bob or Grandsire lead ends, and otherwise returns @code{nil}. No methods below minimus are considered to have such lead ends, nor is rounds considered such a lead end. When not @code{nil} the result is a keyword whose name consists of a single letter, possibly followed by a digit.

The CCCBR’s various collections of methods have, for several decades, used succinct codes, typically single letters or, more recently, single letters followed by digits, to denote various lead ends for the methods they contain. While the choices made have in the past varied by collection, in recent decades a consistent set of codes has been used, which is now codified in the Central Council of Church Bell Ringers @url{https://cccbr.github.io/method_ringing_framework/, Framework for Method
Ringing} (FMR), appendix C. While these codes actually describe both a row and a change adjacent to that row, and thus two different rows, the FMR calls them "lead head codes", so that phrasing is also used here.

There is currently (as of July 2019) an issue with the definitions of these codes in the FMR, where those for Grandsire-like methods do not correctly correspond to common practice. For example, most ringers would consider Itchingfield Slow Bob Doubles and Longford Bob Doubles to have the same lead ends. However, the current FMR definition says that the former has ’c’ Grandsire lead ends, and the latter does not. This is currently under discussion for correction in the next revision of the FMR. The @code{method-lead-head-code} function is implemented assuming that this will be corrected in the next revision of the FMR to match common practice. For example, it considers neither Itchingfield Slow Bob nor Longford Bob as having Grandsire lead ends.

It is also worth noting that, for some of the less common cases, the lead end codes defined in the FMR differ from those used in earlier CCCBR collections.

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-by-title "Advent Surprise Major"))
@result{} :h
(method-lead-head-code
(lookup-method-by-title "Zanussi Surprise Maximus"))
@result{} :j2
(method-lead-head-code
(lookup-method-by-title "Sgurr Surprise Royal"))
@result{} :d
(method-lead-head-code
(lookup-method-by-title "Twerton Little Bob Caters"))
@result{} :q2
(method-lead-head-code
(lookup-method-by-title "Grandsire Royal"))
@result{} :p
(method-lead-head-code
(lookup-method-by-title "Double Glasgow Surprise Major"))
@result{} nil
@end group
@end example

Package

roan.

Source

method.lisp.

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-from-title "Cambridge Surprise Minor" "x3x4x2x3x4x5,2"))
@result{} 24
@end group
@end example

Package

roan.

Source

method.lisp.

Function: method-library-details ()

Returns eight values describing the current Roan method libary. All are strings. They are:
@enumerate
@item
A description of the CCCBR Method Library, extracted from the file from which the Roan library was constructed

@item
The date and time the file on the remote server was last modified, according to that server.

@item
The “entity tag” (ETag) of the remote file, as provided by the server. This is an opaque identifier that changes for each version of the remote file. Querying the current Etag is how @code{update-method-library} decides whether or not the Roan method library needs updating.

@item
The URL used to fetch the remote file from which the Roan library was built.

@item
The @var{source-id} provided in the remote file, that is a CCCBR version stamp.

@item
The date the CCCBR library was built, according to the contents of the file downloaded from the remote server. This may or may not be the same as the date the file on the remote server was last modified.

@item
A unique identifier for the current version of the Roan library. This will change whenever the Roan library is rebuilt, even if the resulting contents are unchanged.

@item
The date and time the current version of the Roan library was built.
@end enumerate

Package

roan.

Source

method.lisp.

Function: method-little-p (method)
Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-little-p).

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.

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.

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.

Function: method-stage (method)
Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-stage).

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. Signals a @code{type-error} if @var{method} is not a @code{method}.

The one argument case can be used with @code{setf}, in which case it potentially sets any or all of the name, classification and stage of @var{method}. There is an ambiguity when parsing method titles in that there being no explicit class named can indicate with that the method has no class (principles and pure differentials) or that the class is Hybrid. When parsing titles for @code{setf} an absence of a class name is taken to mean that there is no class. Also, if there is no stage name specified when using @code{setf} with @code{method-title} the stage is set to @code{nil}; @code{*default-stage*} is not consulted.
@example
@group
(method-title (method "Advent" :class :surprise :stage 8))
@result{} "Advent Surprise Major"
(method-title (method :name "Grandsire" :class :bob :stage 9))
@result{} "Grandsire Caters"
(method-title (method :stage 8))
@result{} "Major"
(method-title (method :class :delight :stage 8) t)
@result{} "Unknown Delight Major
(method-title (method :name "Advent" :class :surprise :stage nil))
@result{} "Advent Surprise"
(method-title (method :name "Slinky" :stage 12 :class :place
:little t :differential t))
@result{} "Slinky Differential Little Place Maximimus"
(method-title (method :name "Stedman" :stage 11))
@result{} "Stedman Cinques"
(method-title (method :name "Meson" :class :hybrid
:little t :stage 12))
@result{} "Meson Maximus"
@end group
@end example

Package

roan.

Source

method.lisp.

Setf expander for this function

(setf method-title).

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.

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.

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.

Function: parse-method-title (title)
Package

roan.

Source

method.lisp.

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.

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 can augment the Lisp reader with @samp{!} to read @code{row}s, it can augment 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.

This @samp{#!} syntax can be turned on and off by using @ref{roan-syntax}. By default it is off when Roan is loaded. It is also possible to control this syntax by using @url{https://github.com/melisgl/named-readtables/, Named Readtables}; see @ref{roan-syntax} for further details.
@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.

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.

Function: pattern-parse-error (&optional message &rest args)
Package

roan.

Source

pattern.lisp.

Function: permutation-closure (&rest rows)

Returns a list of distinct rows that can be generated by permuting, repeatedly if necessary, any of the @var{rows} by themselves or any others of the @var{rows}. If the @var{rows} are not all of the same stage, the lower stage ones are converted to the highest stage present before the closure operation is performed. The order of the returned rows is undefined. Signals a @code{type-error} if any of the @var{rows} is not a @code{row}.
@example
@group
(permutation-closure !13425 !1324 !123465)
@result{} (!143265 !142365 !124365 !142356 !143256 !124356
!134265 !132465 !123456 !123465 !132456 !134256)
@end group
@end example

Package

roan.

Source

roan.lisp.

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.

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.

Function: place-notation-error (parsing format-string &rest args)
Package

roan.

Source

roan.lisp.

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.

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.

Function: position-of-bell (bell row)

===merge: bell-at-position

Package

roan.

Source

roan.lisp.

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.

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.

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.

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.

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.

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.

Function: reversed-row (row)

Returns a @code{row} of the same stage as @var{row} with its bells in the reverse order. A @code{type-error} is signaled if @var{row} is not a @code{row}. @example
(reversed-row !32148765) @result{} !56784123
@end example

Package

roan.

Source

roan.lisp.

Function: rounds (&optional stage)

Returns a @code{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.

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.

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.

Function: row-match-error (format &rest args)
Package

roan.

Source

pattern.lisp.

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.

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.

Function: rowp (object)
Package

roan.

Source

roan.lisp.

Function: stage (row)

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

Package

roan.

Source

roan.lisp.

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.

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.

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.

Function: update-method-library (&optional force)

Queries the remote server containing the CCCBR’s Methods Library. If that remote file has changed since the one Roan’s library was built from was downloaded, it fetches the new one and uses it to build an updated Roan method library. If the generalized boolean @var{force} is true it fetches the remote file and rebuilds Roan’s library without regard to whether the remote one has changed. If the library is updated, returns an integer, the number of methods the updated library contains; if the library is not updated because the remote version hasn’t changed returns @code{nil}.

May signal any of a variety of file system or network errors if network access is not available, or unreliable, or if there are other difficulties downloading and processing the remote file.

Package

roan.

Source

method.lisp.

Function: use-roan (&key package syntax modify)

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, shadowing @code{method}, @code{method-name} and @code{class-name}.

If the generalized boolean @var{syntax} is true, the default, it also enables use of Roan’s @samp{!} and @samp{#!} read macros, by calling @ref{roan-syntax} with a true first argument; the value of @var{modify} is passed as a second argument to @ref{roan-syntax}.

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> (rowp ’!13276548)
NIL
MY-PACKAGE> (roan:use-roan)
T
MY-PACKAGE> +maximum-stage+
24
MY-PACKAGE> (rowp ’!13276548)
T
@end group
@end example

Package

roan.

Source

readtables.lisp.

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 minimus. 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 !1243) @result{} 1
(which-plain-bob-lead-head !12345) @result{} nil
@end group
@end example

Package

roan.

Source

roan.lisp.

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.

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.

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.


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

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 Reader: inappropriate-method-error-details (condition)
Package

roan.

Methods
Reader Method: inappropriate-method-error-details ((condition inappropriate-method-error))
Source

method.lisp.

Target Slot

details.

Generic Reader: inappropriate-method-error-method (condition)
Package

roan.

Methods
Reader Method: inappropriate-method-error-method ((condition inappropriate-method-error))
Source

method.lisp.

Target Slot

method.

Generic Reader: method-library-error-description (condition)
Package

roan.

Methods
Reader Method: method-library-error-description ((condition method-library-error))
Source

method.lisp.

Target Slot

description.

Generic Function: method-name (object)
Package

roan.

Methods
Method: method-name (method)
Source

method.lisp.

Reader Method: method-name ((method method))

automatically generated reader method

Source

method.lisp.

Target Slot

name.

Generic Function: (setf method-name) (object)
Package

roan.

Methods
Writer Method: (setf method-name) :before ((method method))
Source

method.lisp.

Target Slot

name.

Method: (setf method-name) ((method method))

automatically generated writer method

Source

method.lisp.

Generic Function: method-place-notation (object)
Package

roan.

Methods
Method: method-place-notation (method)
Source

method.lisp.

Reader Method: method-place-notation ((method method))

automatically generated reader method

Source

method.lisp.

Target Slot

place-notation.

Generic Function: (setf method-place-notation) (object)
Package

roan.

Methods
Writer Method: (setf method-place-notation) :before ((method method))
Source

method.lisp.

Target Slot

place-notation.

Method: (setf method-place-notation) ((method method))

automatically generated writer method

Source

method.lisp.

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.

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.

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.

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.

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.

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.

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)

5.1.7 Standalone methods

Method: make-load-form ((r row) &optional env)
Source

roan.lisp.

Method: print-object ((call call) stream)
Source

method.lisp.

Method: print-object ((fch-group fch-group) stream)
Source

method.lisp.

Method: print-object ((method method) stream)
Source

method.lisp.

Method: print-object ((counter match-counter) stream)
Source

pattern.lisp.

Method: print-object ((object hash-set) stream)
Source

util.lisp.

Method: print-object ((object row) stream)
Source

roan.lisp.

Method: print-object ((entry cache-entry) stream)
Source

util.lisp.

Method: print-object ((cache lru-cache) stream)
Source

util.lisp.


5.1.8 Conditions

Condition: call-application-error

Signaled when an anaomalous condition is detected while trying to
apply a @code{call} to a @code{method}. Contains three potentially useful slots accessible with @code{call-application-error-call}, @code{call-application-error-method} and @code{call-application-error-details}.

Package

roan.

Source

method.lisp.

Direct superclasses

simple-error.

Direct methods
Direct slots
Slot: call
Initargs

:call

Readers

call-application-error-call.

Writers

This slot is read-only.

Slot: method
Initargs

:method

Readers

call-application-error-method.

Writers

This slot is read-only.

Slot: details
Initargs

:details

Readers

call-application-error-details.

Writers

This slot is read-only.

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.

Direct superclasses

error.

Direct methods
Direct slots
Slot: details
Initargs

:details

Readers

inappropriate-method-error-details.

Writers

This slot is read-only.

Slot: method
Initargs

:method

Readers

inappropriate-method-error-method.

Writers

This slot is read-only.

Condition: inconsistent-method-specification-error

Signaled in circumstances when the various classification details provided cannot occur together, such as a little principle.

Package

roan.

Source

method.lisp.

Direct superclasses

simple-error.

Direct methods

no-place-notation-error-method.

Direct slots
Slot: method
Initargs

:method

Readers

no-place-notation-error-method.

Writers

This slot is read-only.

Condition: method-library-error

Signaled when a method library file cannot be read. Contains two potentially useful slots accessible with @code{file-error-pathname} and @code{method-library-error-description}.

Package

roan.

Source

method.lisp.

Direct superclasses

file-error.

Direct methods

method-library-error-description.

Direct slots
Slot: description
Initargs

:description

Readers

method-library-error-description.

Writers

This slot is read-only.

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.

Direct superclasses

error.

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.

Direct superclasses

error.

Direct methods

no-place-notation-error-method.

Direct slots
Slot: method
Initargs

:method

Readers

no-place-notation-error-method.

Writers

This slot is read-only.

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.

Direct superclasses

parse-error.

Direct methods
Direct slots
Slot: message
Initform

(quote nil)

Initargs

:message

Readers

pattern-parse-error-message.

Writers

(setf pattern-parse-error-message).

Slot: pattern
Initform

(quote nil)

Initargs

:pattern

Readers

pattern-parse-error-pattern.

Writers

(setf pattern-parse-error-pattern).

Slot: index
Initform

(quote nil)

Initargs

:index

Readers

pattern-parse-error-index.

Writers

(setf pattern-parse-error-index).

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.

Direct superclasses

simple-error.


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

5.1.9 Structures

Structure: call

===summary===
Roan provides an immutable @code{call} object that describes a change ringing call, such as a bob or single, that modifies a lead of a @code{method}. A @code{call} usually has a fragment of place notation representing changes that are added to the the sequence of changes constituting the lead, typically replacing some existing changes in the lead.

A @code{call} has an offset, which specifies where in the lead the changes are added, replaced or deleted; this offset can be indexed from the beginning or the end of a lead, which frequently allows the same call to be used for similar methods with possibly different lead lengths. It is also possible to index from a postion within the lead rather than the beginning or end by supplying a fraction; again, this allows using, for example, half-lead calls with similar methods with different lead lengths.

Typically a @code{call} replaces exactly as many changes as it supplies. However it is possible to replace none, in which case the @code{call} adds to the lead length; to only replace changes with a zero length sequence of changes, in which case the @code{call} shortens the lead by deleting changes; or even to add more or fewer changes than it replaces.

Typically a call only affects the lead of a method to which is is applied. In exceptional cases, most notably doubles variations, it may also affect the subsequent lead. To support such use a @code{call} may have a following place notation fragment and a following replacement length. Such use is always restricted to being positioned at the beginning of the subsequent lead, and in the main lead the call must replace changes all the way to the end of the lead. Note that by starting the call at the end of the lead this could be simply adding changes, or even doing nothing.

A @code{call} is applied to a lead with the function @code{call-apply}. This can take multiple @code{call}s, all of which are applied to the same lead. They must not, however, overlap. The @code{call-apply} function returns two values. The first is a list of the changes of the lead, modified by the @code{call}(s). The second, if not @code{nil}, is another @code{call} to be applied to the following lead, and is only non-nil when a @code{call} does apply also to the subsequent lead.

Two @code{call}s may be compared with @code{equalp}.

Examples of @code{call}s:
@itemize
@item
The usual bob for Cambridge Surprise is @code{(call "4")}.
@item
The usual single for Grandsire is @code{(call "3.123" :offset 2)}.
@item
The usual bob for Erin Caters is @code{(call "7" :from-end nil)}.
@item
A 58 half-lead bob for Bristol Major is @code{(call "5" :fraction 1/2)}.
@item
A bob in April Day Doubles is @code{(call "3.123" :following "3")}.
@item
A call for surprise that shortens the lead by omitting the first two
blows, so that ringing of the lead commences at the backstroke snap is
@code{(call nil :from-end nil :replace 2)}.
@end itemize
===endsummary===
An immutable object describing a change ringing call, such as a bob or single.

Package

roan.

Source

method.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: place-notation
Type

(or null string)

Readers

call-place-notation.

Writers

This slot is read-only.

Slot: offset
Type

(integer 0)

Initform

0

Readers

call-offset.

Writers

This slot is read-only.

Slot: from-end
Initform

t

Readers

call-from-end.

Writers

This slot is read-only.

Slot: fraction
Type

(or null (rational (0) (1)))

Readers

call-fraction.

Writers

This slot is read-only.

Slot: replace
Package

common-lisp.

Type

(integer 0)

Initform

0

Readers

call-replace.

Writers

This slot is read-only.

Slot: following
Readers

call-following.

Writers

This slot is read-only.

Slot: changes
Type

simple-vector

Initform

#()

Readers

call-changes.

Writers

This slot is read-only.

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 @url{http://www.methods.org.uk/method-collections/xml-zip-files/method%20xml%201.0.pdf, Peter Niblett’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.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: index
Type

integer

Initform

0

Readers

fch-group-index.

Writers

This slot is read-only.

Slot: name
Type

string

Initform

""

Readers

fch-group-name.

Writers

This slot is read-only.

Slot: parity
Type

symbol

Readers

fch-group-parity.

Writers

This slot is read-only.

Slot: elements
Type

list

Readers

fch-group-elements.

Writers

This slot is read-only.

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.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: table
Type

hash-table

Initform

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

Readers

hash-set-table.

Writers

This slot is read-only.

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.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: stage
Initform

roan:*default-stage*

Readers

match-counter-stage.

Writers

This slot is read-only.

Slot: %handstroke-p
Initform

t

Readers

match-counter-%handstroke-p.

Writers

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

Slot: patterns-vector
Initform

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

Readers

match-counter-patterns-vector.

Writers

(setf match-counter-patterns-vector).

Slot: patterns-table
Initform

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

Readers

match-counter-patterns-table.

Writers

This slot is read-only.

Slot: dfas
Readers

match-counter-dfas.

Writers

(setf match-counter-dfas).

Structure: row

===summary===
@cindex immutable
The fundamental units of change 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} can be
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.

This @samp{!} syntax can be turned on and off by using @ref{roan-syntax}. By default it is
off when Roan is loaded. It is also possible to control this syntax by using @url{https://github.com/melisgl/named-readtables/, Named Readtables}; see
@ref{roan-syntax} for further details.

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.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: bells
Type

roan::%bells-vector

Readers

row-bells.

Writers

(setf row-bells).


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

5.1.10 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 what the Central Council of Church Bell Ringers @url{https://cccbr.github.io/method_ringing_framework/, Framework for Method Ringing} (FMR) calls a static method, a method that can be viewed as a fixed sequence of changes, including jump changes; while this includes nearly all methods rung and named to date, it does exclude, for example, Dixonoids. A @code{method} has a name, a stage, classifacation details, and an associated place-notation, though any or all of these may be @code{nil}. In the case of the stage or place notation @code{nil} indicates that the corresponding value is not known; the same is also true if the name is @code{nil}, except for the case of Little Bob, which in the taxonomy of the FMR has no name. The stage, if known, should be a @code{stage}, and the name and place notation, if known, should be strings.

The classification follows the taxonomy in the FMR and consists of a @code{class} and three boolean attributes for jump methods, differential methods and little methods. The @code{class} may be @code{nil}, for principles and pure differentials; one of the keywords @code{:bob}, @code{:place}, @code{:surprise}, @code{:delight}, @code{:treble-bob}, @code{:alliance}, @code{:treble-place} or@code{:hybrid}, naming the corresponding class; or @code{:hunt} indicating a method with one or more hunt bells that does not fall into any of the named classes, which can only apply to jump methods. The classification consists merely of details stored in the @code{method} object, and does not necessary correspond to the actual classification of the method described by the @code{place-notation}, if supplied. The classification can be set to match the place notation by calling @code{classify-method}.

Similarly the name does not necessarily correspond to the name by which the place notation is known, unless the @code{method} has been looked up from a suitable library. @xref{Methods library}.

Because ringing methods and their classes are unrelated to CLOS methods and classes, the @code{roan} package shadows the symbols @code{common-lisp:method}, @code{common-lisp:method-name} and @code{common-lisp:class-name}.
===endsummary===
Describes a change ringing method, typically including its name, stage, classification and place notation.

Package

roan.

Source

method.lisp.

Direct methods
Direct slots
Slot: name
Type

(or string null)

Initargs

:name

Readers

method-name.

Writers

(setf method-name).

Slot: classification
Type

roan::encoded-classification

Initform

0

Initargs

:classification

Readers

%method-classification.

Writers

(setf %method-classification).

Slot: place-notation
Type

(or string null)

Initargs

:place-notation

Readers

method-place-notation.

Writers

(setf method-place-notation).


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

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

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.


5.2 Internals


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

5.2.1 Constants

Constant: +bell-names+
Package

roan.

Source

roan.lisp.

Constant: +blueline-column-spacing+
Package

roan.

Source

method.lisp.

Constant: +blueline-dot-size+
Package

roan.

Source

method.lisp.

Constant: +blueline-figures-size+
Package

roan.

Source

method.lisp.

Constant: +blueline-figures-x-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-figures-y-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-first-hunt-bell-colors+
Package

roan.

Source

method.lisp.

Constant: +blueline-first-hunt-bell-width+
Package

roan.

Source

method.lisp.

Constant: +blueline-horizontal-increment+
Package

roan.

Source

method.lisp.

Constant: +blueline-horizontal-margin+
Package

roan.

Source

method.lisp.

Constant: +blueline-inter-cycle-gap+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-circle-radius+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-circle-x-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-circle-y-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-left-margin+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-right-margin+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-size+
Package

roan.

Source

method.lisp.

Constant: +blueline-labels-vertical-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-no-figure-ratio+
Package

roan.

Source

method.lisp.

Constant: +blueline-place-notation-character-width+
Package

roan.

Source

method.lisp.

Constant: +blueline-place-notation-margin+
Package

roan.

Source

method.lisp.

Constant: +blueline-place-notation-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-place-notation-size+
Package

roan.

Source

method.lisp.

Constant: +blueline-plus-length+
Package

roan.

Source

method.lisp.

Constant: +blueline-vertical-margin+
Package

roan.

Source

method.lisp.

Constant: +blueline-vertical-offset+
Package

roan.

Source

method.lisp.

Constant: +blueline-working-bell-color+
Package

roan.

Source

method.lisp.

Constant: +blueline-working-bell-width+
Package

roan.

Source

method.lisp.

Constant: +call-changes-vector-length+
Package

roan.

Source

method.lisp.

Constant: +change-cache-size+
Package

roan.

Source

roan.lisp.

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

roan.

Source

roan.lisp.

Constant: +class-field+
Package

roan.

Source

method.lisp.

Constant: +class-names+
Package

roan.

Source

method.lisp.

Constant: +classes+
Package

roan.

Source

method.lisp.

Constant: +cross-changes+
Package

roan.

Source

roan.lisp.

Constant: +default-method-libary-size+
Package

roan.

Source

method.lisp.

Constant: +differential-field+
Package

roan.

Source

method.lisp.

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

roan.

Source

roan.lisp.

Constant: +extra-methods+
Package

roan.

Source

method.lisp.

Constant: +huffman-table+
Package

roan.

Source

method.lisp.

Constant: +hunt-changes+
Package

roan.

Source

roan.lisp.

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

roan.

Source

method.lisp.

Constant: +initial-cross-character+
Package

roan.

Source

roan.lisp.

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

roan.

Source

pattern.lisp.

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

roan.

Source

roan.lisp.

Constant: +jump-field+
Package

roan.

Source

method.lisp.

Constant: +lead-head-codes+
Package

roan.

Source

method.lisp.

Constant: +little-field+
Package

roan.

Source

method.lisp.

Constant: +method-library-format-version+
Package

roan.

Source

method.lisp.

Constant: +method-library-magic-string+
Package

roan.

Source

method.lisp.

Constant: +method-name-character-data+
Package

roan.

Source

method.lisp.

Constant: +method-source+
Package

roan.

Source

method.lisp.

Constant: +method-source-entry+
Package

roan.

Source

method.lisp.

Constant: +method-traits-cache-size+
Package

roan.

Source

method.lisp.

Constant: +named-bells+
Package

roan.

Source

roan.lisp.

Constant: +named-stages+
Package

roan.

Source

roan.lisp.

Constant: +path-types+
Package

roan.

Source

method.lisp.

Constant: +pattern-cache-size+
Package

roan.

Source

pattern.lisp.

Constant: +pattern-characters+
Package

roan.

Source

pattern.lisp.

Constant: +pattern-token+*
Package

roan.

Source

pattern.lisp.

Constant: +place-notation-chars+
Package

roan.

Source

roan.lisp.

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

roan.

Source

roan.lisp.

Constant: +rounds-bell-array+
Package

roan.

Source

roan.lisp.

Constant: +row-signature-shift+
Package

roan.

Source

method.lisp.

Constant: +run-token+*
Package

roan.

Source

pattern.lisp.

Constant: +stage-field+
Package

roan.

Source

method.lisp.

Constant: +stage-names+
Package

roan.

Source

roan.lisp.

Constant: +status-ok+
Package

roan.

Source

method.lisp.

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

roan.

Source

method.lisp.

Constant: +suppress-class+
Package

roan.

Source

method.lisp.


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

5.2.2 Special variables

Special Variable: *blueline-figures-lead-head*
Package

roan.

Source

method.lisp.

Special Variable: *blueline-method*
Package

roan.

Source

method.lisp.

Special Variable: *blueline-row-height*
Package

roan.

Source

method.lisp.

Special Variable: *blueline-stream*
Package

roan.

Source

method.lisp.

Special Variable: *change-cache*
Package

roan.

Source

roan.lisp.

Special Variable: *collapsable-whitespace-scanner*
Package

roan.

Source

util.lisp.

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

roan.

Source

util.lisp.

Special Variable: *dfa-stage*
Package

roan.

Source

pattern.lisp.

Special Variable: *dfa-states*
Package

roan.

Source

pattern.lisp.

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

roan.

Source

method.lisp.

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

roan.

Source

method.lisp.

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

roan.

Source

method.lisp.

Special Variable: *last-nfa-id*
Package

roan.

Source

pattern.lisp.

Special Variable: *method-library*
Package

roan.

Source

method.lisp.

Special Variable: *method-traits-cache*
Package

roan.

Source

method.lisp.

Special Variable: *nfa-stage*
Package

roan.

Source

pattern.lisp.

Special Variable: *pattern-cache*
Package

roan.

Source

pattern.lisp.

Special Variable: *pattern-parse-state*
Package

roan.

Source

pattern.lisp.

Special Variable: *previous-readtables*
Package

roan.

Source

readtables.lisp.

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

roan.

Source

method.lisp.

Special Variable: *threading-p*
Package

roan.

Source

util.lisp.

Special Variable: *xml-file*
Package

roan.

Source

method.lisp.

Special Variable: +conventional-symmetry-scanner+
Package

roan.

Source

method.lisp.

Special Variable: +method-title-scanner+
Package

roan.

Source

method.lisp.

Special Variable: +utf-8-external-format+
Package

roan.

Source

util.lisp.


5.2.3 Macros

Macro: %get-call-changes (vector stage)
Package

roan.

Source

method.lisp.

Macro: check-type* (object type)
Package

roan.

Source

util.lisp.

Macro: clause-for-in-hash-set-1 (&key for in-hash-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.

Macro: def-named-row (name (&optional stage-var covered-var minimum-bells) &body body)
Package

roan.

Source

pattern.lisp.

Macro: define-method-boolean ((method-var value-var) (name field) &body extra-actions)
Package

roan.

Source

method.lisp.

Macro: define-method-trait (name (update-fn &optional depends-on) doc-string)
Package

roan.

Source

method.lisp.

Macro: define-thread-local (name &optional initial-value)
Package

roan.

Source

util.lisp.

Macro: deflock (name)
Package

roan.

Source

util.lisp.

Macro: fch-list-f (place)
Package

roan.

Source

method.lisp.

Macro: get-call-changes (call stage)
Package

roan.

Source

method.lisp.

Macro: get-entry (key cache)
Package

roan.

Source

util.lisp.

Macro: logiorf (place &rest numbers)
Package

roan.

Source

pattern.lisp.

Macro: with-bell-property-resolver (&body body)
Package

roan.

Source

roan.lisp.

Macro: with-initial-format-characters (&body body)
Package

roan.

Source

roan.lisp.

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

roan.

Source

util.lisp.

Macro: with-roan-file ((stream filespec &rest options &key external-format &allow-other-keys) &body body)
Package

roan.

Source

util.lisp.

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.


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

5.2.4 Setf expanders

Setf Expander: (setf getcache) (key cache &optional default)
Package

roan.

Source

util.lisp.

Reader

getcache (function).


5.2.5 Ordinary functions

Function: %assemble-row (bells)
Package

roan.

Source

roan.lisp.

Function: %blueline (stream method layout hunt-bell working-bell figures place-notation place-bells)
Package

roan.

Source

method.lisp.

Function: %counts (count)
Package

roan.

Source

pattern.lisp.

Function: %extreme-hash-set (set more-sets test)
Package

roan.

Source

util.lisp.

Function: %fill-bells-vector ()
Package

roan.

Source

roan.lisp.

Function: %get-changes (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-contains-jump-changes-p (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-course-length (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-hunt-bells (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-lead-count (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-lead-head (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-lead-head-code (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-lead-length (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-plain-course (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-plain-lead (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %get-working-bells (method &optional traits)
Package

roan.

Source

method.lisp.

Function: %hash-set-nintersection (set more-sets)
Package

roan.

Source

util.lisp.

Function: %hash-set-nunion (set more-sets)
Package

roan.

Source

util.lisp.

Function: %in-course-p ()
Package

roan.

Source

roan.lisp.

Function: %make-hash-set (table)
Package

roan.

Source

util.lisp.

Function: %make-match-counter (stage)
Package

roan.

Source

pattern.lisp.

Function: %make-row (bells)
Package

roan.

Source

roan.lisp.

Function: %npermute-hash-set (set function)
Package

roan.

Source

roan.lisp.

Function: %parse-change (change stage)
Package

roan.

Source

roan.lisp.

Function: %parse-place-notation (segment stage)
Package

roan.

Source

roan.lisp.

Function: %permute ()
Package

roan.

Source

roan.lisp.

Function: %placesp (bells &rest places)
Package

roan.

Source

roan.lisp.

Function: %roan-syntax (on-off modify)
Package

roan.

Source

readtables.lisp.

Function: %roundsp (bells)
Package

roan.

Source

roan.lisp.

Function: %rows-match-p (dfa row1 row2)
Package

roan.

Source

pattern.lisp.

Function: %tenors-fixed-p (bells starting-at)
Package

roan.

Source

roan.lisp.

Function: %update-changes (method traits)
Package

roan.

Source

method.lisp.

Function: %update-course-length (method traits)
Package

roan.

Source

method.lisp.

Function: %update-lead-count (method traits)
Package

roan.

Source

method.lisp.

Function: %update-lead-head-code (method traits)
Package

roan.

Source

method.lisp.

Function: %update-lead-length (method traits)
Package

roan.

Source

method.lisp.

Function: %update-plain-course (method traits)
Package

roan.

Source

method.lisp.

Function: %update-plain-lead (method traits)
Package

roan.

Source

method.lisp.

Function: %with-lock (lock thunk)
Package

roan.

Source

util.lisp.

Function: %write-place-notation (changes stream stage elide jump-changes)
Package

roan.

Source

roan.lisp.

Function: add-entry (entry cache)
Package

roan.

Source

util.lisp.

Function: add-library-method (vector method &optional place-notation name info)
Package

roan.

Source

method.lisp.

Function: add-transition (source-state destination-state &optional bell)
Package

roan.

Source

pattern.lisp.

Function: advance-token (&optional state)
Package

roan.

Source

pattern.lisp.

Function: bell-list-p (x)
Package

roan.

Source

method.lisp.

Function: blueline-format (string &rest args)
Package

roan.

Source

method.lisp.

Function: build-dfa-state (nfa-states)
Package

roan.

Source

pattern.lisp.

Function: byte-left (bs)
Package

roan.

Source

util.lisp.

Function: cache-count (cache)

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

Package

roan.

Source

util.lisp.

Reader: call-changes (instance)
Package

roan.

Source

method.lisp.

Target Slot

changes.

Reader: call-following (instance)
Package

roan.

Source

method.lisp.

Target Slot

following.

Reader: call-fraction (instance)
Package

roan.

Source

method.lisp.

Target Slot

fraction.

Reader: call-from-end (instance)
Package

roan.

Source

method.lisp.

Target Slot

from-end.

Reader: call-offset (instance)
Package

roan.

Source

method.lisp.

Target Slot

offset.

Reader: call-place-notation (instance)
Package

roan.

Source

method.lisp.

Target Slot

place-notation.

Reader: call-replace (instance)
Package

roan.

Source

method.lisp.

Target Slot

replace.

Function: canonical-rotation (changes)
Package

roan.

Source

method.lisp.

Function: canonical-rotation-key (changes)
Package

roan.

Source

method.lisp.

Function: changes-info (changes)
Package

roan.

Source

roan.lisp.

Function: checked-hash-set-table (set)
Package

roan.

Source

util.lisp.

Function: class-from-name (string)
Package

roan.

Source

method.lisp.

Function: clear-method-traits (method)
Package

roan.

Source

method.lisp.

Function: clrcache (cache)

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

Package

roan.

Source

util.lisp.

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.

Function: comparableize-string (s)
Package

roan.

Source

method.lisp.

Function: compare-rows (row1 row2)
Package

roan.

Source

method.lisp.

Function: convert-xml-method-file (xml-file library-file url etag last-modified)
Package

roan.

Source

method.lisp.

Function: copy-method-library (instance)
Package

roan.

Source

method.lisp.

Function: copy-row (instance)
Package

roan.

Source

roan.lisp.

Function: create-fch-group (name parity &rest elements)
Package

roan.

Source

method.lisp.

Function: cross-sections (lead-length excursion path)
Package

roan.

Source

method.lisp.

Function: current-token (&optional state)
Package

roan.

Source

pattern.lisp.

Function: download-zipped-methods (url)
Package

roan.

Source

method.lisp.

Function: draw-column (x bell starts leads hunts figures place-notation place-bells)
Package

roan.

Source

method.lisp.

Function: draw-dot (x y)
Package

roan.

Source

method.lisp.

Function: draw-figures (x y where holes first)
Package

roan.

Source

method.lisp.

Function: draw-label (start x y)
Package

roan.

Source

method.lisp.

Function: draw-line (bell x y hunt-p leads)
Package

roan.

Source

method.lisp.

Function: draw-place-notation (x y leads half-lead-only)
Package

roan.

Source

method.lisp.

Function: encode-place-notation (notation stage)
Package

roan.

Source

method.lisp.

Function: ensure-valid-bell (bell stage &optional parsing)
Package

roan.

Source

pattern.lisp.

Function: ensure-valid-bell-class (class &optional stage parsing)
Package

roan.

Source

pattern.lisp.

Function: ensure-valid-run (run &optional stage parsing)
Package

roan.

Source

pattern.lisp.

Function: equal-byte-specifiers (bs1 bs2)
Package

roan.

Source

util.lisp.

Function: falseness-groups (method fchs)
Package

roan.

Source

method.lisp.

Reader: fch-group-index (instance)
Package

roan.

Source

method.lisp.

Target Slot

index.

Function: fch-group-p (object)
Package

roan.

Source

method.lisp.

Function: fch-lessp (r1 r2)
Package

roan.

Source

method.lisp.

Function: find-name-prefix (prefix methods)
Package

roan.

Source

method.lisp.

Function: follow-empty-transitions (state table)
Package

roan.

Source

pattern.lisp.

Function: generate-rows-error (changes)
Package

roan.

Source

roan.lisp.

Function: generate-rows-initial-row (initial-row change)
Package

roan.

Source

roan.lisp.

Function: get-accessor-names (slot)
Package

roan.

Source

method.lisp.

Function: get-headers (url)
Package

roan.

Source

method.lisp.

Function: get-method-traits (method &optional create-if-necessary)
Package

roan.

Source

method.lisp.

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.

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.

Function: get-single-element-by-tag-name (node tag &optional error-if-absent)
Package

roan.

Source

method.lisp.

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.

Setf expander for this function

(setf getcache).

Reader: hash-set-table (instance)
Package

roan.

Source

util.lisp.

Target Slot

table.

Function: headers-extract (headers)
Package

roan.

Source

method.lisp.

Function: jump-allowed-path-little-p (method bell)
Package

roan.

Source

method.lisp.

Function: jump-change-error (control &rest arguments)
Package

roan.

Source

roan.lisp.

Function: make-call (&key place-notation offset from-end fraction replace following changes)
Package

roan.

Source

method.lisp.

Function: make-dfa (initial-nfa-state)
Package

roan.

Source

pattern.lisp.

Function: make-dfa-state (&optional final stage)
Package

roan.

Source

pattern.lisp.

Function: make-fch-group (&key index name parity elements)
Package

roan.

Source

method.lisp.

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.

Function: make-match-counter-dfas (counter)
Package

roan.

Source

pattern.lisp.

Function: make-method-library (&key metadata no-name-count methods rotation-keys additional-data)
Package

roan.

Source

method.lisp.

Function: make-method-traits (&key changes contains-jump-changes-p lead-length lead-head lead-count plain-lead plain-course course-length hunt-bells principal-hunt-bells secondary-hunt-bells working-bells classification lead-head-code)
Package

roan.

Source

method.lisp.

Function: make-nfa (tree *nfa-stage* final-token)
Package

roan.

Source

pattern.lisp.

Function: make-nfa-state (&optional stage)
Package

roan.

Source

pattern.lisp.

Function: make-pattern-parse-state (string stage)
Package

roan.

Source

pattern.lisp.

Function: make-row-count (label pattern double-row-p)
Package

roan.

Source

pattern.lisp.

Reader: match-counter-%handstroke-p (instance)
Writer: (setf match-counter-%handstroke-p) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

%handstroke-p.

Reader: match-counter-dfas (instance)
Writer: (setf match-counter-dfas) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

dfas.

Reader: match-counter-patterns-table (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

patterns-table.

Reader: match-counter-patterns-vector (instance)
Writer: (setf match-counter-patterns-vector) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

patterns-vector.

Function: method-details (method)
Package

roan.

Source

method.lisp.

Reader: method-library-additional-data (instance)
Writer: (setf method-library-additional-data) (instance)
Package

roan.

Source

method.lisp.

Target Slot

additional-data.

Function: method-library-etag (file)
Package

roan.

Source

method.lisp.

Reader: method-library-metadata (instance)
Writer: (setf method-library-metadata) (instance)
Package

roan.

Source

method.lisp.

Target Slot

metadata.

Reader: method-library-methods (instance)
Writer: (setf method-library-methods) (instance)
Package

roan.

Source

method.lisp.

Target Slot

methods.

Reader: method-library-no-name-count (instance)
Writer: (setf method-library-no-name-count) (instance)
Package

roan.

Source

method.lisp.

Target Slot

no-name-count.

Function: method-library-p (object)
Package

roan.

Source

method.lisp.

Function: method-library-parse-error (&optional msg &rest args)
Package

roan.

Source

method.lisp.

Reader: method-library-rotation-keys (instance)
Writer: (setf method-library-rotation-keys) (instance)
Package

roan.

Source

method.lisp.

Target Slot

rotation-keys.

Reader: method-traits-changes (instance)
Writer: (setf method-traits-changes) (instance)
Package

roan.

Source

method.lisp.

Target Slot

changes.

Reader: method-traits-classification (instance)
Writer: (setf method-traits-classification) (instance)
Package

roan.

Source

method.lisp.

Target Slot

classification.

Reader: method-traits-contains-jump-changes-p (instance)
Writer: (setf method-traits-contains-jump-changes-p) (instance)
Package

roan.

Source

method.lisp.

Target Slot

contains-jump-changes-p.

Reader: method-traits-course-length (instance)
Writer: (setf method-traits-course-length) (instance)
Package

roan.

Source

method.lisp.

Target Slot

course-length.

Reader: method-traits-hunt-bells (instance)
Writer: (setf method-traits-hunt-bells) (instance)
Package

roan.

Source

method.lisp.

Target Slot

hunt-bells.

Reader: method-traits-lead-count (instance)
Writer: (setf method-traits-lead-count) (instance)
Package

roan.

Source

method.lisp.

Target Slot

lead-count.

Reader: method-traits-lead-head (instance)
Writer: (setf method-traits-lead-head) (instance)
Package

roan.

Source

method.lisp.

Target Slot

lead-head.

Reader: method-traits-lead-head-code (instance)
Writer: (setf method-traits-lead-head-code) (instance)
Package

roan.

Source

method.lisp.

Target Slot

lead-head-code.

Reader: method-traits-lead-length (instance)
Writer: (setf method-traits-lead-length) (instance)
Package

roan.

Source

method.lisp.

Target Slot

lead-length.

Reader: method-traits-plain-course (instance)
Writer: (setf method-traits-plain-course) (instance)
Package

roan.

Source

method.lisp.

Target Slot

plain-course.

Reader: method-traits-plain-lead (instance)
Writer: (setf method-traits-plain-lead) (instance)
Package

roan.

Source

method.lisp.

Target Slot

plain-lead.

Reader: method-traits-principal-hunt-bells (instance)
Writer: (setf method-traits-principal-hunt-bells) (instance)
Package

roan.

Source

method.lisp.

Target Slot

principal-hunt-bells.

Reader: method-traits-secondary-hunt-bells (instance)
Writer: (setf method-traits-secondary-hunt-bells) (instance)
Package

roan.

Source

method.lisp.

Target Slot

secondary-hunt-bells.

Reader: method-traits-working-bells (instance)
Writer: (setf method-traits-working-bells) (instance)
Package

roan.

Source

method.lisp.

Target Slot

working-bells.

Function: move-entry (entry cache)
Package

roan.

Source

util.lisp.

Function: name-recognizers (s)
Package

roan.

Source

method.lisp.

Function: name-spaces-p (s)
Package

roan.

Source

method.lisp.

Function: named-row-definition (stage covered minimum-bells thunk)
Package

roan.

Source

pattern.lisp.

Function: nfa-id (nfa-state)
Package

roan.

Source

pattern.lisp.

Function: nunfold (changes)
Package

roan.

Source

roan.lisp.

Function: parse-alternative ()
Package

roan.

Source

pattern.lisp.

Function: parse-bell-class (string stage)
Package

roan.

Source

pattern.lisp.

Function: parse-disjunction ()
Package

roan.

Source

pattern.lisp.

Function: parse-element ()
Package

roan.

Source

pattern.lisp.

Function: parse-method-id (method)
Package

roan.

Source

method.lisp.

Function: parse-method-library-description (dom)
Package

roan.

Source

method.lisp.

Function: parse-peal (xml tag)
Package

roan.

Source

method.lisp.

Function: parse-prototype (stage properties)
Package

roan.

Source

method.lisp.

Function: parse-run (string stage)
Package

roan.

Source

pattern.lisp.

Function: partition-hunt-bells (target)
Package

roan.

Source

method.lisp.

Function: path-attributes-non-jump (method bell)
Package

roan.

Source

method.lisp.

Function: pattern-parse-state-end-p (&optional state)
Package

roan.

Source

pattern.lisp.

Function: permute-collection-type-error (collection)
Package

roan.

Source

roan.lisp.

Function: plain-class-type (method skip)
Package

roan.

Source

method.lisp.

Function: prin1-hash-set (set stream)
Package

roan.

Source

util.lisp.

Function: publish-trait (thing)
Package

roan.

Source

method.lisp.

Function: putcache (key cache value)
Package

roan.

Source

util.lisp.

Function: read-method-library (&key load-rotations load-additional-data force)
Package

roan.

Source

method.lisp.

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.

Function: remove-entry (entry cache)
Package

roan.

Source

util.lisp.

Function: rotate-cycle (cycle target)
Package

roan.

Source

method.lisp.

Reader: row-bells (instance)
Writer: (setf row-bells) (instance)
Package

roan.

Source

roan.lisp.

Target Slot

bells.

Reader: row-count-backstroke (instance)
Writer: (setf row-count-backstroke) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

backstroke.

Reader: row-count-double-row-p (instance)
Writer: (setf row-count-double-row-p) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

double-row-p.

Reader: row-count-handstroke (instance)
Writer: (setf row-count-handstroke) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

handstroke.

Reader: row-count-label (instance)
Writer: (setf row-count-label) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

label.

Reader: row-count-pattern (instance)
Writer: (setf row-count-pattern) (instance)
Package

roan.

Source

pattern.lisp.

Target Slot

pattern.

Function: row-creation-error (data parse)
Package

roan.

Source

roan.lisp.

Function: row-list-less-p (list1 list2)
Package

roan.

Source

method.lisp.

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.

Function: same-type-p (x y)
Package

roan.

Source

util.lisp.

Function: set-method-class (method class)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-class).

Function: set-method-differential-p (method value)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-differential-p).

Function: set-method-jump-p (method value)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-jump-p).

Function: set-method-little-p (method value)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-little-p).

Function: set-method-stage (method stage)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-stage).

Function: set-method-title (method title)
Package

roan.

Source

method.lisp.

Setf expanders to this function

(setf method-title).

Function: sharp-bang-reader (stream subchar arg)
Package

roan.

Source

roan.lisp.

Function: signature (states)
Package

roan.

Source

pattern.lisp.

Function: sort-fch-set (set)
Package

roan.

Source

method.lisp.

Function: split-palindromic-changes (changes length contains-jump-changes)
Package

roan.

Source

roan.lisp.

Function: test-jump-palindrome (changes n)
Package

roan.

Source

roan.lisp.

Function: test-ordinary-palindrome (changes n)
Package

roan.

Source

roan.lisp.

Function: text (node)
Package

roan.

Source

method.lisp.

Function: thread-call (name &rest args)
Package

roan.

Source

util.lisp.

Function: total-bells (stage covered)
Package

roan.

Source

pattern.lisp.

Function: treble-dodging-class-type (method cross-sections)
Package

roan.

Source

method.lisp.

Function: unzip-xml-file (zipfile)
Package

roan.

Source

method.lisp.

Function: which-lead-head (bells next-fn)
Package

roan.

Source

roan.lisp.


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

5.2.6 Generic functions

Generic Function: %method-classification (object)
Package

roan.

Methods
Method: %method-classification (method)
Source

method.lisp.

Reader Method: %method-classification ((method method))

automatically generated reader method

Source

method.lisp.

Target Slot

classification.

Generic Writer: (setf %method-classification) (object)
Package

roan.

Methods
Writer Method: (setf %method-classification) ((method method))

automatically generated writer method

Source

method.lisp.

Target Slot

classification.

Generic Function: build-nfa (thing from-state &optional args)
Package

roan.

Source

pattern.lisp.

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 Reader: cache-entry-table (object)
Package

roan.

Methods
Reader Method: cache-entry-table ((lru-cache lru-cache))

automatically generated reader method

Source

util.lisp.

Target Slot

table.

Generic Reader: cache-size (object)
Package

roan.

Methods
Reader Method: cache-size ((lru-cache lru-cache))

automatically generated reader method

Source

util.lisp.

Target Slot

size.

Generic Reader: call-application-error-call (condition)
Package

roan.

Methods
Reader Method: call-application-error-call ((condition call-application-error))
Source

method.lisp.

Target Slot

call.

Generic Reader: call-application-error-details (condition)
Package

roan.

Methods
Reader Method: call-application-error-details ((condition call-application-error))
Source

method.lisp.

Target Slot

details.

Generic Reader: call-application-error-method (condition)
Package

roan.

Methods
Reader Method: call-application-error-method ((condition call-application-error))
Source

method.lisp.

Target Slot

method.

Generic Reader: empty-transition (object)
Package

roan.

Methods
Reader Method: empty-transition ((nfa-state nfa-state))

automatically generated reader method

Source

pattern.lisp.

Target Slot

empty-transition.

Generic Writer: (setf empty-transition) (object)
Package

roan.

Methods
Writer Method: (setf empty-transition) ((nfa-state nfa-state))

automatically generated writer method

Source

pattern.lisp.

Target Slot

empty-transition.

Generic Reader: entry-key (object)
Package

roan.

Methods
Reader Method: entry-key ((cache-entry cache-entry))

automatically generated reader method

Source

util.lisp.

Target Slot

key.

Generic Writer: (setf entry-key) (object)
Package

roan.

Methods
Writer Method: (setf entry-key) ((cache-entry cache-entry))

automatically generated writer method

Source

util.lisp.

Target Slot

key.

Generic Reader: entry-value (object)
Package

roan.

Methods
Reader Method: entry-value ((cache-entry cache-entry))

automatically generated reader method

Source

util.lisp.

Target Slot

value.

Generic Writer: (setf entry-value) (object)
Package

roan.

Methods
Writer Method: (setf entry-value) ((cache-entry cache-entry))

automatically generated writer method

Source

util.lisp.

Target Slot

value.

Generic Function: format-pattern-element (tree stream &optional args context)
Package

roan.

Source

pattern.lisp.

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 Reader: get-final (object)
Package

roan.

Methods
Reader Method: get-final ((dfa-state dfa-state))

automatically generated reader method

Source

pattern.lisp.

Target Slot

final.

Reader Method: get-final ((nfa-state nfa-state))

automatically generated reader method

Source

pattern.lisp.

Target Slot

final.

Generic Reader: newest-entry (object)
Package

roan.

Methods
Reader Method: newest-entry ((lru-cache lru-cache))

automatically generated reader method

Source

util.lisp.

Target Slot

newest.

Generic Writer: (setf newest-entry) (object)
Package

roan.

Methods
Writer Method: (setf newest-entry) ((lru-cache lru-cache))

automatically generated writer method

Source

util.lisp.

Target Slot

newest.

Generic Reader: next-entry (object)
Package

roan.

Methods
Reader Method: next-entry ((cache-entry cache-entry))

automatically generated reader method

Source

util.lisp.

Target Slot

next.

Generic Writer: (setf next-entry) (object)
Package

roan.

Methods
Writer Method: (setf next-entry) ((cache-entry cache-entry))

automatically generated writer method

Source

util.lisp.

Target Slot

next.

Generic Reader: no-place-notation-error-method (condition)
Package

roan.

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

method.lisp.

Target Slot

method.

Reader Method: no-place-notation-error-method ((condition inconsistent-method-specification-error))
Source

method.lisp.

Target Slot

method.

Generic Reader: oldest-entry (object)
Package

roan.

Methods
Reader Method: oldest-entry ((lru-cache lru-cache))

automatically generated reader method

Source

util.lisp.

Target Slot

oldest.

Generic Writer: (setf oldest-entry) (object)
Package

roan.

Methods
Writer Method: (setf oldest-entry) ((lru-cache lru-cache))

automatically generated writer method

Source

util.lisp.

Target Slot

oldest.

Generic Reader: pattern-parse-error-index (condition)
Generic Writer: (setf pattern-parse-error-index) (condition)
Package

roan.

Methods
Reader Method: pattern-parse-error-index ((condition pattern-parse-error))
Writer Method: (setf pattern-parse-error-index) ((condition pattern-parse-error))
Source

pattern.lisp.

Target Slot

index.

Generic Reader: pattern-parse-error-message (condition)
Generic Writer: (setf pattern-parse-error-message) (condition)
Package

roan.

Methods
Reader Method: pattern-parse-error-message ((condition pattern-parse-error))
Writer Method: (setf pattern-parse-error-message) ((condition pattern-parse-error))
Source

pattern.lisp.

Target Slot

message.

Generic Reader: pattern-parse-error-pattern (condition)
Generic Writer: (setf pattern-parse-error-pattern) (condition)
Package

roan.

Methods
Reader Method: pattern-parse-error-pattern ((condition pattern-parse-error))
Writer Method: (setf pattern-parse-error-pattern) ((condition pattern-parse-error))
Source

pattern.lisp.

Target Slot

pattern.

Generic Reader: previous-entry (object)
Package

roan.

Methods
Reader Method: previous-entry ((cache-entry cache-entry))

automatically generated reader method

Source

util.lisp.

Target Slot

previous.

Generic Writer: (setf previous-entry) (object)
Package

roan.

Methods
Writer Method: (setf previous-entry) ((cache-entry cache-entry))

automatically generated writer method

Source

util.lisp.

Target Slot

previous.

Generic Writer: set-final (new-value object)
Package

roan.

Methods
Writer Method: set-final ((new-value nfa-state) nfa-state)

automatically generated writer method

Source

pattern.lisp.

Target Slot

final.

Generic Reader: transitions (object)
Package

roan.

Methods
Reader Method: transitions ((dfa-state dfa-state))

automatically generated reader method

Source

pattern.lisp.

Target Slot

transitions.

Reader Method: transitions ((nfa-state nfa-state))

automatically generated reader method

Source

pattern.lisp.

Target Slot

transitions.


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

5.2.7 Conditions

Condition: jump-change-error
Package

roan.

Source

roan.lisp.

Direct superclasses

simple-error.

Condition: row-creation-error
Package

roan.

Source

roan.lisp.

Direct superclasses

simple-error.

Direct subclasses

row-creation-parse-error.

Condition: row-creation-parse-error
Package

roan.

Source

roan.lisp.

Direct superclasses
Condition: simple-package-error
Package

roan.

Source

readtables.lisp.

Direct superclasses
  • package-error.
  • simple-error.

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

5.2.8 Structures

Structure: method-library
Package

roan.

Source

method.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: metadata
Readers

method-library-metadata.

Writers

(setf method-library-metadata).

Slot: no-name-count
Readers

method-library-no-name-count.

Writers

(setf method-library-no-name-count).

Slot: methods
Initform

(make-array roan::+default-method-libary-size+ :adjustable t :fill-pointer 0)

Readers

method-library-methods.

Writers

(setf method-library-methods).

Slot: rotation-keys
Readers

method-library-rotation-keys.

Writers

(setf method-library-rotation-keys).

Slot: additional-data
Readers

method-library-additional-data.

Writers

(setf method-library-additional-data).

Structure: method-traits
Package

roan.

Source

method.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: changes
Readers

method-traits-changes.

Writers

(setf method-traits-changes).

Slot: contains-jump-changes-p
Readers

method-traits-contains-jump-changes-p.

Writers

(setf method-traits-contains-jump-changes-p).

Slot: lead-length
Readers

method-traits-lead-length.

Writers

(setf method-traits-lead-length).

Slot: lead-head
Readers

method-traits-lead-head.

Writers

(setf method-traits-lead-head).

Slot: lead-count
Readers

method-traits-lead-count.

Writers

(setf method-traits-lead-count).

Slot: plain-lead
Readers

method-traits-plain-lead.

Writers

(setf method-traits-plain-lead).

Slot: plain-course
Readers

method-traits-plain-course.

Writers

(setf method-traits-plain-course).

Slot: course-length
Readers

method-traits-course-length.

Writers

(setf method-traits-course-length).

Slot: hunt-bells
Readers

method-traits-hunt-bells.

Writers

(setf method-traits-hunt-bells).

Slot: principal-hunt-bells
Readers

method-traits-principal-hunt-bells.

Writers

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

Slot: secondary-hunt-bells
Readers

method-traits-secondary-hunt-bells.

Writers

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

Slot: working-bells
Readers

method-traits-working-bells.

Writers

(setf method-traits-working-bells).

Slot: classification
Readers

method-traits-classification.

Writers

(setf method-traits-classification).

Slot: lead-head-code
Readers

method-traits-lead-head-code.

Writers

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

Structure: row-count
Package

roan.

Source

pattern.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: label
Readers

row-count-label.

Writers

(setf row-count-label).

Slot: pattern
Readers

row-count-pattern.

Writers

(setf row-count-pattern).

Slot: double-row-p
Readers

row-count-double-row-p.

Writers

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

Slot: handstroke
Initform

0

Readers

row-count-handstroke.

Writers

(setf row-count-handstroke).

Slot: backstroke
Initform

0

Readers

row-count-backstroke.

Writers

(setf row-count-backstroke).


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

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

Direct methods
Direct slots
Slot: key
Readers

entry-key.

Writers

(setf entry-key).

Slot: value
Readers

entry-value.

Writers

(setf entry-value).

Slot: previous
Type

(or roan::cache-entry null)

Readers

previous-entry.

Writers

(setf previous-entry).

Slot: next
Package

iterate.

Type

(or roan::cache-entry null)

Readers

next-entry.

Writers

(setf next-entry).

Class: dfa-state
Package

roan.

Source

pattern.lisp.

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions.

Writers

This slot is read-only.

Slot: final
Type

(quote list)

Initargs

:final

Readers

get-final.

Writers

This slot is read-only.

Class: lru-cache

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

Package

roan.

Source

util.lisp.

Direct methods
Direct slots
Slot: size
Type

(integer 1 *)

Initargs

:size

Readers

cache-size.

Writers

This slot is read-only.

Slot: table
Type

roan::hash

Initargs

:table

Readers

cache-entry-table.

Writers

This slot is read-only.

Slot: newest
Type

(or roan::cache-entry null)

Readers

newest-entry.

Writers

(setf newest-entry).

Slot: oldest
Type

(or roan::cache-entry null)

Readers

oldest-entry.

Writers

(setf oldest-entry).

Class: nfa-state
Package

roan.

Source

pattern.lisp.

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions.

Writers

This slot is read-only.

Slot: empty-transition
Type

(quote list)

Initform

(quote nil)

Readers

empty-transition.

Writers

(setf empty-transition).

Slot: final
Readers

get-final.

Writers

set-final.

Slot: id
Class: pattern-parse-state
Package

roan.

Source

pattern.lisp.

Direct slots
Slot: string
Package

common-lisp.

Initargs

:string

Slot: stage
Initargs

:stage

Slot: index
Initform

0

Slot: token
Slot: token-end
Initform

0


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

5.2.10 Types

Type: %bells-vector ()
Package

roan.

Source

roan.lisp.

Type: encoded-classification ()
Package

roan.

Source

method.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

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

%
%assemble-row: Private ordinary functions
%blueline: Private ordinary functions
%counts: Private ordinary functions
%extreme-hash-set: Private ordinary functions
%fill-bells-vector: Private ordinary functions
%get-call-changes: Private macros
%get-changes: Private ordinary functions
%get-contains-jump-changes-p: Private ordinary functions
%get-course-length: Private ordinary functions
%get-hunt-bells: Private ordinary functions
%get-lead-count: Private ordinary functions
%get-lead-head: Private ordinary functions
%get-lead-head-code: Private ordinary functions
%get-lead-length: Private ordinary functions
%get-plain-course: Private ordinary functions
%get-plain-lead: Private ordinary functions
%get-working-bells: Private ordinary functions
%hash-set-nintersection: Private ordinary functions
%hash-set-nunion: Private ordinary functions
%in-course-p: Private ordinary functions
%make-hash-set: Private ordinary functions
%make-match-counter: Private ordinary functions
%make-row: Private ordinary functions
%method-classification: Private generic functions
%method-classification: Private generic functions
%method-classification: Private generic functions
%npermute-hash-set: Private ordinary functions
%parse-change: Private ordinary functions
%parse-place-notation: Private ordinary functions
%permute: Private ordinary functions
%placesp: Private ordinary functions
%roan-syntax: Private ordinary functions
%roundsp: Private ordinary functions
%rows-match-p: Private ordinary functions
%tenors-fixed-p: Private ordinary functions
%update-changes: Private ordinary functions
%update-course-length: Private ordinary functions
%update-lead-count: Private ordinary functions
%update-lead-head-code: Private ordinary functions
%update-lead-length: Private ordinary functions
%update-plain-course: Private ordinary functions
%update-plain-lead: Private ordinary functions
%with-lock: Private ordinary functions
%write-place-notation: Private ordinary functions

(
(setf %method-classification): Private generic functions
(setf %method-classification): Private generic functions
(setf empty-transition): Private generic functions
(setf empty-transition): Private generic functions
(setf entry-key): Private generic functions
(setf entry-key): Private generic functions
(setf entry-value): Private generic functions
(setf entry-value): Private generic functions
(setf getcache): Private setf expanders
(setf match-counter-%handstroke-p): Private ordinary functions
(setf match-counter-dfas): Private ordinary functions
(setf match-counter-handstroke-p): Public setf expanders
(setf match-counter-patterns-vector): Private ordinary functions
(setf method-class): Public setf expanders
(setf method-differential-p): Public setf expanders
(setf method-jump-p): Public setf expanders
(setf method-library-additional-data): Private ordinary functions
(setf method-library-metadata): Private ordinary functions
(setf method-library-methods): Private ordinary functions
(setf method-library-no-name-count): Private ordinary functions
(setf method-library-rotation-keys): Private ordinary functions
(setf method-little-p): Public setf expanders
(setf method-name): Public generic functions
(setf method-name): Public generic functions
(setf method-name): Public generic functions
(setf method-place-notation): Public generic functions
(setf method-place-notation): Public generic functions
(setf method-place-notation): Public generic functions
(setf method-stage): Public setf expanders
(setf method-title): Public setf expanders
(setf method-traits-changes): Private ordinary functions
(setf method-traits-classification): Private ordinary functions
(setf method-traits-contains-jump-changes-p): Private ordinary functions
(setf method-traits-course-length): Private ordinary functions
(setf method-traits-hunt-bells): Private ordinary functions
(setf method-traits-lead-count): Private ordinary functions
(setf method-traits-lead-head): Private ordinary functions
(setf method-traits-lead-head-code): Private ordinary functions
(setf method-traits-lead-length): Private ordinary functions
(setf method-traits-plain-course): Private ordinary functions
(setf method-traits-plain-lead): Private ordinary functions
(setf method-traits-principal-hunt-bells): Private ordinary functions
(setf method-traits-secondary-hunt-bells): Private ordinary functions
(setf method-traits-working-bells): Private ordinary functions
(setf newest-entry): Private generic functions
(setf newest-entry): Private generic functions
(setf next-entry): Private generic functions
(setf next-entry): Private generic functions
(setf oldest-entry): Private generic functions
(setf oldest-entry): Private generic functions
(setf pattern-parse-error-index): Private generic functions
(setf pattern-parse-error-index): Private generic functions
(setf pattern-parse-error-message): Private generic functions
(setf pattern-parse-error-message): Private generic functions
(setf pattern-parse-error-pattern): Private generic functions
(setf pattern-parse-error-pattern): Private generic functions
(setf previous-entry): Private generic functions
(setf previous-entry): Private generic functions
(setf row-bells): Private ordinary functions
(setf row-count-backstroke): Private ordinary functions
(setf row-count-double-row-p): Private ordinary functions
(setf row-count-handstroke): Private ordinary functions
(setf row-count-label): Private ordinary functions
(setf row-count-pattern): Private ordinary functions

A
add-entry: Private ordinary functions
add-library-method: Private ordinary functions
add-pattern: Public ordinary functions
add-patterns: Public ordinary functions
add-transition: Private ordinary functions
advance-token: Private ordinary functions
alter-stage: Public ordinary functions

B
bell-at-position: Public ordinary functions
bell-from-name: Public ordinary functions
bell-list-p: Private ordinary functions
bell-name: Public ordinary functions
bells-list: Public ordinary functions
bells-vector: Public ordinary functions
blueline: Public ordinary functions
blueline-format: Private ordinary functions
build-dfa-state: Private ordinary functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
build-nfa: Private generic functions
byte-left: Private ordinary functions

C
cache-count: Private ordinary functions
cache-entry-table: Private generic functions
cache-entry-table: Private generic functions
cache-size: Private generic functions
cache-size: Private generic functions
call: Public ordinary functions
call-application-error: Public ordinary functions
call-application-error-call: Private generic functions
call-application-error-call: Private generic functions
call-application-error-details: Private generic functions
call-application-error-details: Private generic functions
call-application-error-method: Private generic functions
call-application-error-method: Private generic functions
call-apply: Public ordinary functions
call-changes: Private ordinary functions
call-following: Private ordinary functions
call-fraction: Private ordinary functions
call-from-end: Private ordinary functions
call-offset: Private ordinary functions
call-place-notation: Private ordinary functions
call-replace: Private ordinary functions
canonical-rotation: Private ordinary functions
canonical-rotation-key: Private ordinary functions
canonicalize-method-place-notation: Public ordinary functions
canonicalize-place-notation: Public ordinary functions
changep: Public ordinary functions
changes-info: Private ordinary functions
check-type*: Private macros
checked-hash-set-table: Private ordinary functions
class-from-name: Private ordinary functions
class-name: Public ordinary functions
classify-method: Public ordinary functions
clause-for-in-hash-set-1: Private macros
clear-method-traits: Private ordinary functions
clrcache: Private ordinary functions
collapse-whitespace: Private ordinary functions
comparable-method-name: Public ordinary functions
comparableize-string: Private ordinary functions
compare-rows: Private ordinary functions
convert-xml-method-file: Private ordinary functions
copy-method: Public ordinary functions
copy-method-library: Private ordinary functions
copy-row: Private ordinary functions
create-fch-group: Private ordinary functions
cross-sections: Private ordinary functions
current-token: Private ordinary functions
cycles: Public ordinary functions

D
def-named-row: Private macros
define-method-boolean: Private macros
define-method-trait: Private macros
define-thread-local: Private macros
deflock: Private macros
do-hash-set: Public macros
download-zipped-methods: Private ordinary functions
draw-column: Private ordinary functions
draw-dot: Private ordinary functions
draw-figures: Private ordinary functions
draw-label: Private ordinary functions
draw-line: Private ordinary functions
draw-place-notation: Private ordinary functions

E
empty-transition: Private generic functions
empty-transition: Private generic functions
encode-place-notation: Private ordinary functions
ensure-valid-bell: Private ordinary functions
ensure-valid-bell-class: Private ordinary functions
ensure-valid-run: Private ordinary functions
entry-key: Private generic functions
entry-key: Private generic functions
entry-value: Private generic functions
entry-value: Private generic functions
equal-byte-specifiers: Private ordinary functions

F
falseness-groups: Private ordinary functions
fch-group: Public ordinary functions
fch-group-elements: Public ordinary functions
fch-group-index: Private ordinary functions
fch-group-name: Public ordinary functions
fch-group-p: Private ordinary functions
fch-group-parity: Public ordinary functions
fch-groups-string: Public ordinary functions
fch-lessp: Private ordinary functions
fch-list-f: Private macros
find-name-prefix: Private ordinary functions
follow-empty-transitions: Private ordinary functions
format-pattern: Public ordinary functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
format-pattern-element: Private generic functions
Function, %assemble-row: Private ordinary functions
Function, %blueline: Private ordinary functions
Function, %counts: Private ordinary functions
Function, %extreme-hash-set: Private ordinary functions
Function, %fill-bells-vector: Private ordinary functions
Function, %get-changes: Private ordinary functions
Function, %get-contains-jump-changes-p: Private ordinary functions
Function, %get-course-length: Private ordinary functions
Function, %get-hunt-bells: Private ordinary functions
Function, %get-lead-count: Private ordinary functions
Function, %get-lead-head: Private ordinary functions
Function, %get-lead-head-code: Private ordinary functions
Function, %get-lead-length: Private ordinary functions
Function, %get-plain-course: Private ordinary functions
Function, %get-plain-lead: Private ordinary functions
Function, %get-working-bells: Private ordinary functions
Function, %hash-set-nintersection: Private ordinary functions
Function, %hash-set-nunion: Private ordinary functions
Function, %in-course-p: Private ordinary functions
Function, %make-hash-set: Private ordinary functions
Function, %make-match-counter: Private ordinary functions
Function, %make-row: Private ordinary functions
Function, %npermute-hash-set: Private ordinary functions
Function, %parse-change: Private ordinary functions
Function, %parse-place-notation: Private ordinary functions
Function, %permute: Private ordinary functions
Function, %placesp: Private ordinary functions
Function, %roan-syntax: Private ordinary functions
Function, %roundsp: Private ordinary functions
Function, %rows-match-p: Private ordinary functions
Function, %tenors-fixed-p: Private ordinary functions
Function, %update-changes: Private ordinary functions
Function, %update-course-length: Private ordinary functions
Function, %update-lead-count: Private ordinary functions
Function, %update-lead-head-code: Private ordinary functions
Function, %update-lead-length: Private ordinary functions
Function, %update-plain-course: Private ordinary functions
Function, %update-plain-lead: Private ordinary functions
Function, %with-lock: Private ordinary functions
Function, %write-place-notation: Private ordinary functions
Function, (setf match-counter-%handstroke-p): Private ordinary functions
Function, (setf match-counter-dfas): Private ordinary functions
Function, (setf match-counter-patterns-vector): Private ordinary functions
Function, (setf method-library-additional-data): Private ordinary functions
Function, (setf method-library-metadata): Private ordinary functions
Function, (setf method-library-methods): Private ordinary functions
Function, (setf method-library-no-name-count): Private ordinary functions
Function, (setf method-library-rotation-keys): Private ordinary functions
Function, (setf method-traits-changes): Private ordinary functions
Function, (setf method-traits-classification): Private ordinary functions
Function, (setf method-traits-contains-jump-changes-p): Private ordinary functions
Function, (setf method-traits-course-length): Private ordinary functions
Function, (setf method-traits-hunt-bells): Private ordinary functions
Function, (setf method-traits-lead-count): Private ordinary functions
Function, (setf method-traits-lead-head): Private ordinary functions
Function, (setf method-traits-lead-head-code): Private ordinary functions
Function, (setf method-traits-lead-length): Private ordinary functions
Function, (setf method-traits-plain-course): Private ordinary functions
Function, (setf method-traits-plain-lead): Private ordinary functions
Function, (setf method-traits-principal-hunt-bells): Private ordinary functions
Function, (setf method-traits-secondary-hunt-bells): Private ordinary functions
Function, (setf method-traits-working-bells): Private ordinary functions
Function, (setf row-bells): Private ordinary functions
Function, (setf row-count-backstroke): Private ordinary functions
Function, (setf row-count-double-row-p): Private ordinary functions
Function, (setf row-count-handstroke): Private ordinary functions
Function, (setf row-count-label): Private ordinary functions
Function, (setf row-count-pattern): Private ordinary functions
Function, add-entry: Private ordinary functions
Function, add-library-method: Private ordinary functions
Function, add-pattern: Public ordinary functions
Function, add-patterns: Public ordinary functions
Function, add-transition: Private ordinary functions
Function, advance-token: Private ordinary functions
Function, alter-stage: Public ordinary functions
Function, bell-at-position: Public ordinary functions
Function, bell-from-name: Public ordinary functions
Function, bell-list-p: Private ordinary functions
Function, bell-name: Public ordinary functions
Function, bells-list: Public ordinary functions
Function, bells-vector: Public ordinary functions
Function, blueline: Public ordinary functions
Function, blueline-format: Private ordinary functions
Function, build-dfa-state: Private ordinary functions
Function, byte-left: Private ordinary functions
Function, cache-count: Private ordinary functions
Function, call: Public ordinary functions
Function, call-application-error: Public ordinary functions
Function, call-apply: Public ordinary functions
Function, call-changes: Private ordinary functions
Function, call-following: Private ordinary functions
Function, call-fraction: Private ordinary functions
Function, call-from-end: Private ordinary functions
Function, call-offset: Private ordinary functions
Function, call-place-notation: Private ordinary functions
Function, call-replace: Private ordinary functions
Function, canonical-rotation: Private ordinary functions
Function, canonical-rotation-key: Private ordinary functions
Function, canonicalize-method-place-notation: Public ordinary functions
Function, canonicalize-place-notation: Public ordinary functions
Function, changep: Public ordinary functions
Function, changes-info: Private ordinary functions
Function, checked-hash-set-table: Private ordinary functions
Function, class-from-name: Private ordinary functions
Function, class-name: Public ordinary functions
Function, classify-method: Public ordinary functions
Function, clear-method-traits: Private ordinary functions
Function, clrcache: Private ordinary functions
Function, collapse-whitespace: Private ordinary functions
Function, comparable-method-name: Public ordinary functions
Function, comparableize-string: Private ordinary functions
Function, compare-rows: Private ordinary functions
Function, convert-xml-method-file: Private ordinary functions
Function, copy-method: Public ordinary functions
Function, copy-method-library: Private ordinary functions
Function, copy-row: Private ordinary functions
Function, create-fch-group: Private ordinary functions
Function, cross-sections: Private ordinary functions
Function, current-token: Private ordinary functions
Function, cycles: Public ordinary functions
Function, download-zipped-methods: Private ordinary functions
Function, draw-column: Private ordinary functions
Function, draw-dot: Private ordinary functions
Function, draw-figures: Private ordinary functions
Function, draw-label: Private ordinary functions
Function, draw-line: Private ordinary functions
Function, draw-place-notation: Private ordinary functions
Function, encode-place-notation: Private ordinary functions
Function, ensure-valid-bell: Private ordinary functions
Function, ensure-valid-bell-class: Private ordinary functions
Function, ensure-valid-run: Private ordinary functions
Function, equal-byte-specifiers: Private ordinary functions
Function, falseness-groups: Private ordinary functions
Function, fch-group: Public ordinary functions
Function, fch-group-elements: Public ordinary functions
Function, fch-group-index: Private ordinary functions
Function, fch-group-name: Public ordinary functions
Function, fch-group-p: Private ordinary functions
Function, fch-group-parity: Public ordinary functions
Function, fch-groups-string: Public ordinary functions
Function, fch-lessp: Private ordinary functions
Function, find-name-prefix: Private ordinary functions
Function, follow-empty-transitions: Private ordinary functions
Function, format-pattern: Public ordinary functions
Function, generate-rows-error: Private ordinary functions
Function, generate-rows-initial-row: Private ordinary functions
Function, get-accessor-names: Private ordinary functions
Function, get-headers: Private ordinary functions
Function, get-method-traits: Private ordinary functions
Function, get-newest-key: Private ordinary functions
Function, get-newest-value: Private ordinary functions
Function, get-single-element-by-tag-name: Private ordinary functions
Function, getcache: Private ordinary functions
Function, hash-set: Public ordinary functions
Function, hash-set-adjoin: Public ordinary functions
Function, hash-set-adjoin-list-elements: Public ordinary functions
Function, hash-set-clear: Public ordinary functions
Function, hash-set-copy: Public ordinary functions
Function, hash-set-count: Public ordinary functions
Function, hash-set-delete: Public ordinary functions
Function, hash-set-difference: Public ordinary functions
Function, hash-set-elements: Public ordinary functions
Function, hash-set-empty-p: Public ordinary functions
Function, hash-set-intersection: Public ordinary functions
Function, hash-set-member: Public ordinary functions
Function, hash-set-nadjoin: Public ordinary functions
Function, hash-set-nadjoin-list-elements: Public ordinary functions
Function, hash-set-ndifference: Public ordinary functions
Function, hash-set-nintersection: Public ordinary functions
Function, hash-set-nunion: Public ordinary functions
Function, hash-set-p: Public ordinary functions
Function, hash-set-pop: Public ordinary functions
Function, hash-set-proper-subset-p: Public ordinary functions
Function, hash-set-remove: Public ordinary functions
Function, hash-set-subset-p: Public ordinary functions
Function, hash-set-table: Private ordinary functions
Function, hash-set-union: Public ordinary functions
Function, headers-extract: Private ordinary functions
Function, in-course-p: Public ordinary functions
Function, inverse: Public ordinary functions
Function, involutionp: Public ordinary functions
Function, jump-allowed-path-little-p: Private ordinary functions
Function, jump-change-error: Private ordinary functions
Function, lookup-method-by-title: Public ordinary functions
Function, lookup-method-info: Public ordinary functions
Function, lookup-methods: Public ordinary functions
Function, lookup-methods-by-notation: Public ordinary functions
Function, make-call: Private ordinary functions
Function, make-dfa: Private ordinary functions
Function, make-dfa-state: Private ordinary functions
Function, make-fch-group: Private ordinary functions
Function, make-hash-set: Public ordinary functions
Function, make-lru-cache: Private ordinary functions
Function, make-match-counter: Public ordinary functions
Function, make-match-counter-dfas: Private ordinary functions
Function, make-method-library: Private ordinary functions
Function, make-method-traits: Private ordinary functions
Function, make-nfa: Private ordinary functions
Function, make-nfa-state: Private ordinary functions
Function, make-pattern-parse-state: Private ordinary functions
Function, make-row-count: Private ordinary functions
Function, map-hash-set: Public ordinary functions
Function, match-counter-%handstroke-p: Private ordinary functions
Function, match-counter-counts: Public ordinary functions
Function, match-counter-dfas: Private ordinary functions
Function, match-counter-handstroke-p: Public ordinary functions
Function, match-counter-labels: Public ordinary functions
Function, match-counter-pattern: Public ordinary functions
Function, match-counter-patterns-table: Private ordinary functions
Function, match-counter-patterns-vector: Private ordinary functions
Function, match-counter-stage: Public ordinary functions
Function, method: Public ordinary functions
Function, method-canonical-rotation-key: Public ordinary functions
Function, method-changes: Public ordinary functions
Function, method-class: Public ordinary functions
Function, method-contains-jump-changes-p: Public ordinary functions
Function, method-conventionally-symmetric-p: Public ordinary functions
Function, method-course-length: Public ordinary functions
Function, method-details: Private ordinary functions
Function, method-differential-p: Public ordinary functions
Function, method-falseness: Public ordinary functions
Function, method-from-title: Public ordinary functions
Function, method-hunt-bells: Public ordinary functions
Function, method-jump-p: Public ordinary functions
Function, method-lead-count: Public ordinary functions
Function, method-lead-head: Public ordinary functions
Function, method-lead-head-code: Public ordinary functions
Function, method-lead-length: Public ordinary functions
Function, method-library-additional-data: Private ordinary functions
Function, method-library-details: Public ordinary functions
Function, method-library-etag: Private ordinary functions
Function, method-library-metadata: Private ordinary functions
Function, method-library-methods: Private ordinary functions
Function, method-library-no-name-count: Private ordinary functions
Function, method-library-p: Private ordinary functions
Function, method-library-parse-error: Private ordinary functions
Function, method-library-rotation-keys: Private ordinary functions
Function, method-little-p: Public ordinary functions
Function, method-plain-course: Public ordinary functions
Function, method-plain-lead: Public ordinary functions
Function, method-rotations-p: Public ordinary functions
Function, method-stage: Public ordinary functions
Function, method-title: Public ordinary functions
Function, method-traits-changes: Private ordinary functions
Function, method-traits-classification: Private ordinary functions
Function, method-traits-contains-jump-changes-p: Private ordinary functions
Function, method-traits-course-length: Private ordinary functions
Function, method-traits-hunt-bells: Private ordinary functions
Function, method-traits-lead-count: Private ordinary functions
Function, method-traits-lead-head: Private ordinary functions
Function, method-traits-lead-head-code: Private ordinary functions
Function, method-traits-lead-length: Private ordinary functions
Function, method-traits-plain-course: Private ordinary functions
Function, method-traits-plain-lead: Private ordinary functions
Function, method-traits-principal-hunt-bells: Private ordinary functions
Function, method-traits-secondary-hunt-bells: Private ordinary functions
Function, method-traits-working-bells: Private ordinary functions
Function, method-true-plain-course-p: Public ordinary functions
Function, method-working-bells: Public ordinary functions
Function, move-entry: Private ordinary functions
Function, name-recognizers: Private ordinary functions
Function, name-spaces-p: Private ordinary functions
Function, named-row-definition: Private ordinary functions
Function, nfa-id: Private ordinary functions
Function, nunfold: Private ordinary functions
Function, order: Public ordinary functions
Function, parse-alternative: Private ordinary functions
Function, parse-bell-class: Private ordinary functions
Function, parse-disjunction: Private ordinary functions
Function, parse-element: Private ordinary functions
Function, parse-method-id: Private ordinary functions
Function, parse-method-library-description: Private ordinary functions
Function, parse-method-title: Public ordinary functions
Function, parse-pattern: Public ordinary functions
Function, parse-peal: Private ordinary functions
Function, parse-place-notation: Public ordinary functions
Function, parse-prototype: Private ordinary functions
Function, parse-row: Public ordinary functions
Function, parse-run: Private ordinary functions
Function, partition-hunt-bells: Private ordinary functions
Function, path-attributes-non-jump: Private ordinary functions
Function, pattern-parse-error: Public ordinary functions
Function, pattern-parse-state-end-p: Private ordinary functions
Function, permutation-closure: Public ordinary functions
Function, permute: Public ordinary functions
Function, permute-by-inverse: Public ordinary functions
Function, permute-collection-type-error: Private ordinary functions
Function, place-notation-error: Public ordinary functions
Function, place-notation-string: Public ordinary functions
Function, placesp: Public ordinary functions
Function, plain-class-type: Private ordinary functions
Function, position-of-bell: Public ordinary functions
Function, prin1-hash-set: Private ordinary functions
Function, publish-trait: Private ordinary functions
Function, putcache: Private ordinary functions
Function, read-method-library: Private ordinary functions
Function, read-place-notation: Public ordinary functions
Function, read-row: Public ordinary functions
Function, record-matches: Public ordinary functions
Function, remcache: Private ordinary functions
Function, remove-all-patterns: Public ordinary functions
Function, remove-entry: Private ordinary functions
Function, remove-pattern: Public ordinary functions
Function, reset-match-counter: Public ordinary functions
Function, reversed-row: Public ordinary functions
Function, rotate-cycle: Private ordinary functions
Function, rounds: Public ordinary functions
Function, roundsp: Public ordinary functions
Function, row: Public ordinary functions
Function, row-bells: Private ordinary functions
Function, row-count-backstroke: Private ordinary functions
Function, row-count-double-row-p: Private ordinary functions
Function, row-count-handstroke: Private ordinary functions
Function, row-count-label: Private ordinary functions
Function, row-count-pattern: Private ordinary functions
Function, row-creation-error: Private ordinary functions
Function, row-list-less-p: Private ordinary functions
Function, row-match-error: Public ordinary functions
Function, row-match-p: Public ordinary functions
Function, row-string: Public ordinary functions
Function, rowp: Public ordinary functions
Function, rows-distinct-p: Private ordinary functions
Function, same-type-p: Private ordinary functions
Function, set-method-class: Private ordinary functions
Function, set-method-differential-p: Private ordinary functions
Function, set-method-jump-p: Private ordinary functions
Function, set-method-little-p: Private ordinary functions
Function, set-method-stage: Private ordinary functions
Function, set-method-title: Private ordinary functions
Function, sharp-bang-reader: Private ordinary functions
Function, signature: Private ordinary functions
Function, sort-fch-set: Private ordinary functions
Function, split-palindromic-changes: Private ordinary functions
Function, stage: Public ordinary functions
Function, stage-from-name: Public ordinary functions
Function, stage-name: Public ordinary functions
Function, tenors-fixed-p: Public ordinary functions
Function, test-jump-palindrome: Private ordinary functions
Function, test-ordinary-palindrome: Private ordinary functions
Function, text: Private ordinary functions
Function, thread-call: Private ordinary functions
Function, total-bells: Private ordinary functions
Function, treble-dodging-class-type: Private ordinary functions
Function, unzip-xml-file: Private ordinary functions
Function, update-method-library: Public ordinary functions
Function, use-roan: Public ordinary functions
Function, which-grandsire-lead-head: Public ordinary functions
Function, which-lead-head: Private ordinary functions
Function, which-plain-bob-lead-head: Public ordinary functions
Function, write-place-notation: Public ordinary functions
Function, write-row: Public ordinary functions

G
generate-rows: Public generic functions
generate-rows: Public generic functions
generate-rows: Public generic functions
generate-rows: Public generic functions
generate-rows-error: Private ordinary functions
generate-rows-initial-row: Private ordinary functions
Generic Function, %method-classification: Private generic functions
Generic Function, (setf %method-classification): Private generic functions
Generic Function, (setf empty-transition): Private generic functions
Generic Function, (setf entry-key): Private generic functions
Generic Function, (setf entry-value): Private generic functions
Generic Function, (setf method-name): Public generic functions
Generic Function, (setf method-place-notation): Public generic functions
Generic Function, (setf newest-entry): Private generic functions
Generic Function, (setf next-entry): Private generic functions
Generic Function, (setf oldest-entry): Private generic functions
Generic Function, (setf pattern-parse-error-index): Private generic functions
Generic Function, (setf pattern-parse-error-message): Private generic functions
Generic Function, (setf pattern-parse-error-pattern): Private generic functions
Generic Function, (setf previous-entry): Private generic functions
Generic Function, build-nfa: Private generic functions
Generic Function, cache-entry-table: Private generic functions
Generic Function, cache-size: Private generic functions
Generic Function, call-application-error-call: Private generic functions
Generic Function, call-application-error-details: Private generic functions
Generic Function, call-application-error-method: Private generic functions
Generic Function, empty-transition: Private generic functions
Generic Function, entry-key: Private generic functions
Generic Function, entry-value: Private generic functions
Generic Function, format-pattern-element: Private generic functions
Generic Function, generate-rows: Public generic functions
Generic Function, get-final: Private generic functions
Generic Function, inappropriate-method-error-details: Public generic functions
Generic Function, inappropriate-method-error-method: Public generic functions
Generic Function, method-library-error-description: Public generic functions
Generic Function, method-name: Public generic functions
Generic Function, method-place-notation: Public generic functions
Generic Function, named-row-pattern: Public generic functions
Generic Function, newest-entry: Private generic functions
Generic Function, next-entry: Private generic functions
Generic Function, ngenerate-rows: Public generic functions
Generic Function, no-place-notation-error-method: Private generic functions
Generic Function, npermute-by-collection: Public generic functions
Generic Function, npermute-collection: Public generic functions
Generic Function, oldest-entry: Private generic functions
Generic Function, pattern-parse-error-index: Private generic functions
Generic Function, pattern-parse-error-message: Private generic functions
Generic Function, pattern-parse-error-pattern: Private generic functions
Generic Function, permute-by-collection: Public generic functions
Generic Function, permute-collection: Public generic functions
Generic Function, previous-entry: Private generic functions
Generic Function, set-final: Private generic functions
Generic Function, transitions: Private generic functions
get-accessor-names: Private ordinary functions
get-call-changes: Private macros
get-entry: Private macros
get-final: Private generic functions
get-final: Private generic functions
get-final: Private generic functions
get-headers: Private ordinary functions
get-method-traits: Private ordinary functions
get-newest-key: Private ordinary functions
get-newest-value: Private ordinary functions
get-single-element-by-tag-name: Private ordinary functions
getcache: Private ordinary functions

H
hash-set: Public ordinary functions
hash-set-adjoin: Public ordinary functions
hash-set-adjoin-list-elements: Public ordinary functions
hash-set-clear: Public ordinary functions
hash-set-copy: Public ordinary functions
hash-set-count: Public ordinary functions
hash-set-delete: Public ordinary functions
hash-set-difference: Public ordinary functions
hash-set-elements: Public ordinary functions
hash-set-empty-p: Public ordinary functions
hash-set-intersection: Public ordinary functions
hash-set-member: Public ordinary functions
hash-set-nadjoin: Public ordinary functions
hash-set-nadjoin-list-elements: Public ordinary functions
hash-set-ndifference: Public ordinary functions
hash-set-nintersection: Public ordinary functions
hash-set-nunion: Public ordinary functions
hash-set-p: Public ordinary functions
hash-set-pop: Public ordinary functions
hash-set-proper-subset-p: Public ordinary functions
hash-set-remove: Public ordinary functions
hash-set-subset-p: Public ordinary functions
hash-set-table: Private ordinary functions
hash-set-union: Public ordinary functions
headers-extract: Private ordinary functions

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

J
jump-allowed-path-little-p: Private ordinary functions
jump-change-error: Private ordinary functions

L
logiorf: Private macros
lookup-method-by-title: Public ordinary functions
lookup-method-info: Public ordinary functions
lookup-methods: Public ordinary functions
lookup-methods-by-notation: Public ordinary functions

M
Macro, %get-call-changes: Private macros
Macro, check-type*: Private macros
Macro, clause-for-in-hash-set-1: Private macros
Macro, def-named-row: Private macros
Macro, define-method-boolean: Private macros
Macro, define-method-trait: Private macros
Macro, define-thread-local: Private macros
Macro, deflock: Private macros
Macro, do-hash-set: Public macros
Macro, fch-list-f: Private macros
Macro, get-call-changes: Private macros
Macro, get-entry: Private macros
Macro, logiorf: Private macros
Macro, permutef: Public macros
Macro, roan-syntax: Public macros
Macro, with-bell-property-resolver: Private macros
Macro, with-initial-format-characters: Private macros
Macro, with-lock: Private macros
Macro, with-roan-file: Private macros
Macro, with-warnings-muffled: Private macros
make-call: Private ordinary functions
make-dfa: Private ordinary functions
make-dfa-state: Private ordinary functions
make-fch-group: Private ordinary functions
make-hash-set: Public ordinary functions
make-load-form: Public standalone methods
make-lru-cache: Private ordinary functions
make-match-counter: Public ordinary functions
make-match-counter-dfas: Private ordinary functions
make-method-library: Private ordinary functions
make-method-traits: Private ordinary functions
make-nfa: Private ordinary functions
make-nfa-state: Private ordinary functions
make-pattern-parse-state: Private ordinary functions
make-row-count: Private ordinary functions
map-hash-set: Public ordinary functions
match-counter-%handstroke-p: Private ordinary functions
match-counter-counts: Public ordinary functions
match-counter-dfas: Private ordinary functions
match-counter-handstroke-p: Public ordinary functions
match-counter-labels: Public ordinary functions
match-counter-pattern: Public ordinary functions
match-counter-patterns-table: Private ordinary functions
match-counter-patterns-vector: Private ordinary functions
match-counter-stage: Public ordinary functions
method: Public ordinary functions
Method, %method-classification: Private generic functions
Method, %method-classification: Private generic functions
Method, (setf %method-classification): Private generic functions
Method, (setf empty-transition): Private generic functions
Method, (setf entry-key): Private generic functions
Method, (setf entry-value): Private generic functions
Method, (setf method-name): Public generic functions
Method, (setf method-name): Public generic functions
Method, (setf method-place-notation): Public generic functions
Method, (setf method-place-notation): Public generic functions
Method, (setf newest-entry): Private generic functions
Method, (setf next-entry): Private generic functions
Method, (setf oldest-entry): Private generic functions
Method, (setf pattern-parse-error-index): Private generic functions
Method, (setf pattern-parse-error-message): Private generic functions
Method, (setf pattern-parse-error-pattern): Private generic functions
Method, (setf previous-entry): Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, build-nfa: Private generic functions
Method, cache-entry-table: Private generic functions
Method, cache-size: Private generic functions
Method, call-application-error-call: Private generic functions
Method, call-application-error-details: Private generic functions
Method, call-application-error-method: Private generic functions
Method, empty-transition: Private generic functions
Method, entry-key: Private generic functions
Method, entry-value: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, format-pattern-element: Private generic functions
Method, generate-rows: Public generic functions
Method, generate-rows: Public generic functions
Method, generate-rows: Public generic functions
Method, get-final: Private generic functions
Method, get-final: Private generic functions
Method, inappropriate-method-error-details: Public generic functions
Method, inappropriate-method-error-method: Public generic functions
Method, make-load-form: Public standalone methods
Method, method-library-error-description: Public generic functions
Method, method-name: Public generic functions
Method, method-name: Public generic functions
Method, method-place-notation: Public generic functions
Method, method-place-notation: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, named-row-pattern: Public generic functions
Method, newest-entry: Private generic functions
Method, next-entry: Private generic functions
Method, ngenerate-rows: Public generic functions
Method, ngenerate-rows: Public generic functions
Method, ngenerate-rows: Public generic functions
Method, no-place-notation-error-method: Private generic functions
Method, no-place-notation-error-method: Private generic functions
Method, npermute-by-collection: Public generic functions
Method, npermute-by-collection: Public generic functions
Method, npermute-by-collection: Public generic functions
Method, npermute-by-collection: Public generic functions
Method, npermute-collection: Public generic functions
Method, npermute-collection: Public generic functions
Method, npermute-collection: Public generic functions
Method, npermute-collection: Public generic functions
Method, oldest-entry: Private generic functions
Method, pattern-parse-error-index: Private generic functions
Method, pattern-parse-error-message: Private generic functions
Method, pattern-parse-error-pattern: Private generic functions
Method, permute-by-collection: Public generic functions
Method, permute-by-collection: Public generic functions
Method, permute-by-collection: Public generic functions
Method, permute-by-collection: Public generic functions
Method, permute-collection: Public generic functions
Method, permute-collection: Public generic functions
Method, permute-collection: Public generic functions
Method, permute-collection: Public generic functions
Method, previous-entry: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, set-final: Private generic functions
Method, transitions: Private generic functions
Method, transitions: Private generic functions
method-canonical-rotation-key: Public ordinary functions
method-changes: Public ordinary functions
method-class: Public ordinary functions
method-contains-jump-changes-p: Public ordinary functions
method-conventionally-symmetric-p: Public ordinary functions
method-course-length: Public ordinary functions
method-details: Private ordinary functions
method-differential-p: Public ordinary functions
method-falseness: Public ordinary functions
method-from-title: Public ordinary functions
method-hunt-bells: Public ordinary functions
method-jump-p: Public ordinary functions
method-lead-count: Public ordinary functions
method-lead-head: Public ordinary functions
method-lead-head-code: Public ordinary functions
method-lead-length: Public ordinary functions
method-library-additional-data: Private ordinary functions
method-library-details: Public ordinary functions
method-library-error-description: Public generic functions
method-library-error-description: Public generic functions
method-library-etag: Private ordinary functions
method-library-metadata: Private ordinary functions
method-library-methods: Private ordinary functions
method-library-no-name-count: Private ordinary functions
method-library-p: Private ordinary functions
method-library-parse-error: Private ordinary functions
method-library-rotation-keys: Private ordinary functions
method-little-p: Public ordinary functions
method-name: Public generic functions
method-name: Public generic functions
method-name: Public generic functions
method-place-notation: Public generic functions
method-place-notation: Public generic functions
method-place-notation: Public generic functions
method-plain-course: Public ordinary functions
method-plain-lead: Public ordinary functions
method-rotations-p: Public ordinary functions
method-stage: Public ordinary functions
method-title: Public ordinary functions
method-traits-changes: Private ordinary functions
method-traits-classification: Private ordinary functions
method-traits-contains-jump-changes-p: Private ordinary functions
method-traits-course-length: Private ordinary functions
method-traits-hunt-bells: Private ordinary functions
method-traits-lead-count: Private ordinary functions
method-traits-lead-head: Private ordinary functions
method-traits-lead-head-code: Private ordinary functions
method-traits-lead-length: Private ordinary functions
method-traits-plain-course: Private ordinary functions
method-traits-plain-lead: Private ordinary functions
method-traits-principal-hunt-bells: Private ordinary functions
method-traits-secondary-hunt-bells: Private ordinary functions
method-traits-working-bells: Private ordinary functions
method-true-plain-course-p: Public ordinary functions
method-working-bells: Public ordinary functions
move-entry: Private ordinary functions

N
name-recognizers: Private ordinary functions
name-spaces-p: Private ordinary functions
named-row-definition: Private ordinary functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
named-row-pattern: Public generic functions
newest-entry: Private generic functions
newest-entry: Private generic functions
next-entry: Private generic functions
next-entry: Private generic functions
nfa-id: Private ordinary functions
ngenerate-rows: Public generic functions
ngenerate-rows: Public generic functions
ngenerate-rows: Public generic functions
ngenerate-rows: Public generic functions
no-place-notation-error-method: Private generic functions
no-place-notation-error-method: Private generic functions
no-place-notation-error-method: Private generic functions
npermute-by-collection: Public generic functions
npermute-by-collection: Public generic functions
npermute-by-collection: Public generic functions
npermute-by-collection: Public generic functions
npermute-by-collection: Public generic functions
npermute-collection: Public generic functions
npermute-collection: Public generic functions
npermute-collection: Public generic functions
npermute-collection: Public generic functions
npermute-collection: Public generic functions
nunfold: Private ordinary functions

O
oldest-entry: Private generic functions
oldest-entry: Private generic functions
order: Public ordinary functions

P
parse-alternative: Private ordinary functions
parse-bell-class: Private ordinary functions
parse-disjunction: Private ordinary functions
parse-element: Private ordinary functions
parse-method-id: Private ordinary functions
parse-method-library-description: Private ordinary functions
parse-method-title: Public ordinary functions
parse-pattern: Public ordinary functions
parse-peal: Private ordinary functions
parse-place-notation: Public ordinary functions
parse-prototype: Private ordinary functions
parse-row: Public ordinary functions
parse-run: Private ordinary functions
partition-hunt-bells: Private ordinary functions
path-attributes-non-jump: Private ordinary functions
pattern-parse-error: Public ordinary functions
pattern-parse-error-index: Private generic functions
pattern-parse-error-index: Private generic functions
pattern-parse-error-message: Private generic functions
pattern-parse-error-message: Private generic functions
pattern-parse-error-pattern: Private generic functions
pattern-parse-error-pattern: Private generic functions
pattern-parse-state-end-p: Private ordinary functions
permutation-closure: Public ordinary functions
permute: Public ordinary functions
permute-by-collection: Public generic functions
permute-by-collection: Public generic functions
permute-by-collection: Public generic functions
permute-by-collection: Public generic functions
permute-by-collection: Public generic functions
permute-by-inverse: Public ordinary functions
permute-collection: Public generic functions
permute-collection: Public generic functions
permute-collection: Public generic functions
permute-collection: Public generic functions
permute-collection: Public generic functions
permute-collection-type-error: Private ordinary functions
permutef: Public macros
place-notation-error: Public ordinary functions
place-notation-string: Public ordinary functions
placesp: Public ordinary functions
plain-class-type: Private ordinary functions
position-of-bell: Public ordinary functions
previous-entry: Private generic functions
previous-entry: Private generic functions
prin1-hash-set: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
publish-trait: Private ordinary functions
putcache: Private ordinary functions

R
read-method-library: Private ordinary functions
read-place-notation: Public ordinary functions
read-row: Public ordinary functions
record-matches: Public ordinary functions
remcache: Private ordinary functions
remove-all-patterns: Public ordinary functions
remove-entry: Private ordinary functions
remove-pattern: Public ordinary functions
reset-match-counter: Public ordinary functions
reversed-row: Public ordinary functions
roan-syntax: Public macros
rotate-cycle: Private ordinary functions
rounds: Public ordinary functions
roundsp: Public ordinary functions
row: Public ordinary functions
row-bells: Private ordinary functions
row-count-backstroke: Private ordinary functions
row-count-double-row-p: Private ordinary functions
row-count-handstroke: Private ordinary functions
row-count-label: Private ordinary functions
row-count-pattern: Private ordinary functions
row-creation-error: Private ordinary functions
row-list-less-p: Private ordinary functions
row-match-error: Public ordinary functions
row-match-p: Public ordinary functions
row-string: Public ordinary functions
rowp: Public ordinary functions
rows-distinct-p: Private ordinary functions

S
same-type-p: Private ordinary functions
set-final: Private generic functions
set-final: Private generic functions
set-method-class: Private ordinary functions
set-method-differential-p: Private ordinary functions
set-method-jump-p: Private ordinary functions
set-method-little-p: Private ordinary functions
set-method-stage: Private ordinary functions
set-method-title: Private ordinary functions
Setf Expander, (setf getcache): Private setf expanders
Setf Expander, (setf match-counter-handstroke-p): Public setf expanders
Setf Expander, (setf method-class): Public setf expanders
Setf Expander, (setf method-differential-p): Public setf expanders
Setf Expander, (setf method-jump-p): Public setf expanders
Setf Expander, (setf method-little-p): Public setf expanders
Setf Expander, (setf method-stage): Public setf expanders
Setf Expander, (setf method-title): Public setf expanders
sharp-bang-reader: Private ordinary functions
signature: Private ordinary functions
sort-fch-set: Private ordinary functions
split-palindromic-changes: Private ordinary functions
stage: Public ordinary functions
stage-from-name: Public ordinary functions
stage-name: Public ordinary functions

T
tenors-fixed-p: Public ordinary functions
test-jump-palindrome: Private ordinary functions
test-ordinary-palindrome: Private ordinary functions
text: Private ordinary functions
thread-call: Private ordinary functions
total-bells: Private ordinary functions
transitions: Private generic functions
transitions: Private generic functions
transitions: Private generic functions
treble-dodging-class-type: Private ordinary functions

U
unzip-xml-file: Private ordinary functions
update-method-library: Public ordinary functions
use-roan: Public ordinary functions

W
which-grandsire-lead-head: Public ordinary functions
which-lead-head: Private ordinary functions
which-plain-bob-lead-head: Public ordinary functions
with-bell-property-resolver: Private macros
with-initial-format-characters: Private macros
with-lock: Private macros
with-roan-file: Private macros
with-warnings-muffled: Private macros
write-place-notation: Public ordinary functions
write-row: Public ordinary 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   R   S   T   V   W  
<
Index Entry  Section

%
%handstroke-p: Public structures

*
*blueline-default-parameters*: Public special variables
*blueline-figures-lead-head*: Private special variables
*blueline-method*: Private special variables
*blueline-row-height*: Private special variables
*blueline-stream*: Private special variables
*change-cache*: Private special variables
*collapsable-whitespace-scanner*: Private special variables
*contains-collapsable-whitespace-scanner*: Private special variables
*cross-character*: Public special variables
*default-stage*: Public special variables
*dfa-stage*: Private special variables
*dfa-states*: Private special variables
*fch-groups-by-course-head*: Private special variables
*fch-groups-by-name*: Private special variables
*last-fch-group-index*: Private special variables
*last-nfa-id*: Private special variables
*method-library*: Private special variables
*method-library-path*: Public special variables
*method-traits-cache*: Private special variables
*nfa-stage*: Private special variables
*pattern-cache*: Private special variables
*pattern-parse-state*: Private special variables
*previous-readtables*: Private special variables
*print-bells-upper-case*: Public special variables
*rows-distinct-p-hash-table*: Private special variables
*threading-p*: Private special variables
*xml-file*: Private special variables

+
+bell-names+: Private constants
+blueline-column-spacing+: Private constants
+blueline-dot-size+: Private constants
+blueline-figures-size+: Private constants
+blueline-figures-x-offset+: Private constants
+blueline-figures-y-offset+: Private constants
+blueline-first-hunt-bell-colors+: Private constants
+blueline-first-hunt-bell-width+: Private constants
+blueline-horizontal-increment+: Private constants
+blueline-horizontal-margin+: Private constants
+blueline-inter-cycle-gap+: Private constants
+blueline-labels-circle-radius+: Private constants
+blueline-labels-circle-x-offset+: Private constants
+blueline-labels-circle-y-offset+: Private constants
+blueline-labels-left-margin+: Private constants
+blueline-labels-right-margin+: Private constants
+blueline-labels-size+: Private constants
+blueline-labels-vertical-offset+: Private constants
+blueline-no-figure-ratio+: Private constants
+blueline-place-notation-character-width+: Private constants
+blueline-place-notation-margin+: Private constants
+blueline-place-notation-offset+: Private constants
+blueline-place-notation-size+: Private constants
+blueline-plus-length+: Private constants
+blueline-vertical-margin+: Private constants
+blueline-vertical-offset+: Private constants
+blueline-working-bell-color+: Private constants
+blueline-working-bell-width+: Private constants
+call-changes-vector-length+: Private constants
+change-cache-size+: Private constants
+char-code-array-length+: Private constants
+class-field+: Private constants
+class-names+: Private constants
+classes+: Private constants
+conventional-symmetry-scanner+: Private special variables
+cross-changes+: Private constants
+default-method-libary-size+: Private constants
+differential-field+: Private constants
+extended-place-notation-scanner+*: Private constants
+extra-methods+: Private constants
+huffman-table+: Private constants
+hunt-changes+: Private constants
+incidence-initial-hash-set-size+: Private constants
+initial-cross-character+: Private constants
+initial-match-counter-size+: Private constants
+initial-print-bells-upper-case+: Private constants
+jump-field+: Private constants
+lead-head-codes+: Private constants
+little-field+: Private constants
+maximum-stage+: Public constants
+method-library-format-version+: Private constants
+method-library-magic-string+: Private constants
+method-name-character-data+: Private constants
+method-source+: Private constants
+method-source-entry+: Private constants
+method-title-scanner+: Private special variables
+method-traits-cache-size+: Private constants
+minimum-stage+: Public constants
+named-bells+: Private constants
+named-stages+: Private constants
+path-types+: Private constants
+pattern-cache-size+: Private constants
+pattern-characters+: Private constants
+pattern-token+*: Private constants
+place-notation-chars+: Private constants
+place-notation-fragment-scanner+: Private constants
+rounds-bell-array+: Private constants
+row-signature-shift+: Private constants
+run-token+*: Private constants
+stage-field+: Private constants
+stage-names+: Private constants
+status-ok+: Private constants
+summary-initial-hash-set-size+: