The roan Reference Manual

Table of Contents

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

The roan Reference Manual

This is the roan Reference Manual, version 9.0.20, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 12:08:40 2020 GMT+0.


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

1 Introduction

Roan

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

Roan provides

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

Installing Roan

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

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

Note that Quicklisp creates a new distribution about once a month, so there may be a log 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.


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

2 Systems

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


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

2.1 roan

Author

Don Morrison <dfm@ringing.org>

License

MIT

Description

A library to support change ringing applications

Version

9.0.20

Dependencies
Source

roan.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 roan.asd

Location

roan.asd

Systems

roan (system)


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

3.1.2 roan/package.lisp

Parent

roan (system)

Location

package.lisp

Packages

roan


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

3.1.3 roan/readtables.lisp

Dependency

package.lisp (file)

Parent

roan (system)

Location

readtables.lisp

Exported Definitions
Internal Definitions

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

3.1.4 roan/util.lisp

Dependency

package.lisp (file)

Parent

roan (system)

Location

util.lisp

Exported Definitions
Internal Definitions

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

3.1.5 roan/roan.lisp

Dependencies
Parent

roan (system)

Location

roan.lisp

Exported Definitions
Internal Definitions

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

3.1.6 roan/pattern.lisp

Dependencies
Parent

roan (system)

Location

pattern.lisp

Exported Definitions
Internal Definitions

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

3.1.7 roan/method.lisp

Dependencies
Parent

roan (system)

Location

method.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 roan

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

Alternatively all the external symbols of the @code{roan} package can be imported into a package with @code{use-package}, or the @code{:use} option to @code{defpackage}. There is the slight complication, however, that the @code{roan} package shadows the symbols @code{method}, @code{method-name} 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 one 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 (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Constants

Constant: +maximum-stage+

The largest number of bells supported, 24.

Package

roan

Source

roan.lisp (file)

Constant: +minimum-stage+

The smallest number of bells supported, 2.

Package

roan

Source

roan.lisp (file)


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

5.1.2 Special variables

Special Variable: *blueline-default-parameters*
Package

roan

Source

method.lisp (file)

Special Variable: *cross-character*

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

Package

roan

Source

roan.lisp (file)

Special Variable: *default-stage*

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

Package

roan

Source

roan.lisp (file)

Special Variable: *method-library-path*
Package

roan

Source

method.lisp (file)

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

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

Package

roan

Source

roan.lisp (file)


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

5.1.3 Macros

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

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

Package

roan

Source

util.lisp (file)

Macro: hash-set-deletef PLACE &rest ELEMENTS

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

Package

roan

Source

util.lisp (file)

Macro: hash-set-nadjoinf PLACE &rest ELEMENTS

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

Package

roan

Source

util.lisp (file)

Macro: permutef PLACE &rest CHANGES

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

Package

roan

Source

roan.lisp (file)

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


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

5.1.4 Functions

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

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

Package

roan

Source

pattern.lisp (file)

Function: add-patterns COUNTER LISTS

===merge: add-pattern

Package

roan

Source

pattern.lisp (file)

Function: alter-stage ROW &optional NEW-STAGE

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

Package

roan

Source

roan.lisp (file)

Function: bell-at-position ROW POSITION

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

Package

roan

Source

roan.lisp (file)

Function: bell-from-name CHAR

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

Package

roan

Source

roan.lisp (file)

Function: bell-name BELL &optional UPPER-CASE

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

Package

roan

Source

roan.lisp (file)

Function: bells-list ROW

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

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

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

Package

roan

Source

roan.lisp (file)

Function: bells-vector ROW &optional VECTOR

===merge: bells-list

Package

roan

Source

roan.lisp (file)

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

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, the changes corresponding to which will add 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 add 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 (file)

Function: call-application-error CALL METHOD MESSAGE &rest ARGS
Package

roan

Source

method.lisp (file)

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

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

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

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

Package

roan

Source

method.lisp (file)

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

===lambda: (string-or-changes &key stage comma elide cross upper-case allow-jump-changes) Returns a string representing the place notation in a canonical form. If @var{string-or-changes} is a string it should be parseable as place notation at @var{stage}, which defaults to the current value of @code{*default-stage*}, and otherwise it should be a list of @code{row}s, all of the same stage. Unless overridden by the other keyword arguments, which have the same effects as for @code{write-place-notation}, the canonical form is a compact one 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 (file)

Function: changep ROW

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

Package

roan

Source

roan.lisp (file)

Function: class-name CLASS
Package

roan

Source

method.lisp (file)

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

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

Function: copy-row INSTANCE
Package

roan

Source

roan.lisp (file)

Function: cycles ROW

Returns a list of lists of bells. Each of the sublists is the orbit of all of its elements in @var{row}. One cycles are included. Thus, if @var{row} is a lead head, all the sublists of length one are hunt bells, all the rest being working bells; if there are two or more sublists of length greater than one the corresponding method is 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 (file)

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

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

If @var{item} is a @code{row} the @code{fch-group} that contains that row among its elements is returned. If it is not at an even stage, major or above, or if it is at an even stage royal or above but with any of the bells 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 (file)

Function: fch-group-elements INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-name INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-parity INSTANCE
Package

roan

Source

method.lisp (file)

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

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

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

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

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

Package

roan

Source

method.lisp (file)

Function: format-pattern TREE &optional UPPER-CASE

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

Package

roan

Source

pattern.lisp (file)

Function: hash-set &rest INITIAL-ELEMENTS

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

Package

roan

Source

util.lisp (file)

Function: hash-set-adjoin SET &rest ELEMENTS

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

Package

roan

Source

util.lisp (file)

Function: hash-set-clear SET

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

Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

Function: hash-set-count SET

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

Package

roan

Source

util.lisp (file)

Function: hash-set-delete SET &rest ELEMENTS

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

Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

Function: hash-set-elements SET

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

Package

roan

Source

util.lisp (file)

Function: hash-set-empty-p SET

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

Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

Function: hash-set-member ITEM SET

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

Package

roan

Source

util.lisp (file)

Function: hash-set-nadjoin SET &rest ELEMENTS

===merge: hash-set-adjoin

Package

roan

Source

util.lisp (file)

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

===merge: hash-set-difference

Package

roan

Source

util.lisp (file)

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

===merge: hash-set-intersection

Package

roan

Source

util.lisp (file)

Function: hash-set-nunion &rest SETS

===merge: hash-set-union

Package

roan

Source

util.lisp (file)

Function: hash-set-p OBJECT
Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

Function: hash-set-remove SET &rest ELEMENTS

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

Package

roan

Source

util.lisp (file)

Function: hash-set-subset-p SUBSET SUPERSET

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

Package

roan

Source

util.lisp (file)

Function: hash-set-union &rest SETS

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

Package

roan

Source

util.lisp (file)

Function: in-course-p ROW

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

Package

roan

Source

roan.lisp (file)

Function: inverse ()

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

Package

roan

Source

roan.lisp (file)

Function: involutionp ROW

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

Package

roan

Source

roan.lisp (file)

Function: lookup-method-by-title TITLE

===merge: lookup-methods 1

Package

roan

Source

method.lisp (file)

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

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

Function: lookup-methods-by-notation NOTATION-OR-CHANGES &optional STAGE

===merge: lookup-methods 2

Package

roan

Source

method.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

Function: make-match-counter &optional STAGE

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

Package

roan

Source

pattern.lisp (file)

Function: map-hash-set FUNCTION SET

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

Package

roan

Source

util.lisp (file)

Function: match-counter-counts COUNTER &optional LABEL

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

Package

roan

Source

pattern.lisp (file)

Function: match-counter-handstroke-p COUNTER

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

Package

roan

Source

pattern.lisp (file)

Setf Expander

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

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

roan

Source

pattern.lisp (file)

Reader

match-counter-handstroke-p (function)

Function: match-counter-labels COUNTER

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

Package

roan

Source

pattern.lisp (file)

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

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

Package

roan

Source

pattern.lisp (file)

Function: match-counter-stage INSTANCE
Package

roan

Source

pattern.lisp (file)

Function: method &key 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 (file)

Function: method-canonical-rotation-key METHOD

If @var{method} has its stage and place notation set returns a string uniquely identifying, using @code{equal}, the changes of a lead of this method, invariant under rotation. That is, if, 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 (file)

Function: method-changes METHOD

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

Package

roan

Source

method.lisp (file)

Function: method-class METHOD
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-class) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-class (function)

Writer

set-method-class (function)

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

Function: method-course-length METHOD

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

Package

roan

Source

method.lisp (file)

Function: method-differential-p METHOD
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-differential-p) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-differential-p (function)

Writer

set-method-differential-p (function)

Function: method-falseness METHOD

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

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

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

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

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

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

Package

roan

Source

method.lisp (file)

Function: method-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 (file)

Function: method-hunt-bells METHOD

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

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

Function: method-jump-p METHOD
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-jump-p) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-jump-p (function)

Writer

set-method-jump-p (function)

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

Function: method-lead-head METHOD

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

Package

roan

Source

method.lisp (file)

Function: method-lead-head-code METHOD

Returns the lead head code for @var{method}, 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 (file)

Function: method-lead-length METHOD

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

Package

roan

Source

method.lisp (file)

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

Function: method-little-p METHOD
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-little-p) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-little-p (function)

Writer

set-method-little-p (function)

Function: method-plain-course METHOD

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

Package

roan

Source

method.lisp (file)

Function: method-plain-lead METHOD

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

Package

roan

Source

method.lisp (file)

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

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

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

Package

roan

Source

method.lisp (file)

Function: method-stage METHOD
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-stage) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-stage (function)

Writer

set-method-stage (function)

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

Setf Expander

(setf method-title) (setf expander)

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

roan

Source

method.lisp (file)

Reader

method-title (function)

Writer

set-method-title (function)

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

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

Package

roan

Source

method.lisp (file)

Function: method-working-bells METHOD

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

Package

roan

Source

method.lisp (file)

Function: order ROW

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

Package

roan

Source

roan.lisp (file)

Function: parse-method-title TITLE
Package

roan

Source

method.lisp (file)

Function: parse-pattern PATTERN &optional STAGE

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

Package

roan

Source

pattern.lisp (file)

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

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

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

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

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

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

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

Just as Roan 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 (file)

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

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

Package

roan

Source

roan.lisp (file)

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

roan

Source

pattern.lisp (file)

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

Function: permute ()

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

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

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

Package

roan

Source

roan.lisp (file)

Function: permute-by-inverse ()

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

Package

roan

Source

roan.lisp (file)

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

roan

Source

roan.lisp (file)

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

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

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

Package

roan

Source

roan.lisp (file)

Function: placesp ROW &rest PLACES

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

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

Package

roan

Source

roan.lisp (file)

Function: position-of-bell BELL ROW

===merge: bell-at-position

Package

roan

Source

roan.lisp (file)

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

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

Package

roan

Source

roan.lisp (file)

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

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

Package

roan

Source

roan.lisp (file)

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

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

Package

roan

Source

pattern.lisp (file)

Function: remove-all-patterns COUNTER

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

Package

roan

Source

pattern.lisp (file)

Function: remove-pattern COUNTER LABEL

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

Package

roan

Source

pattern.lisp (file)

Function: reset-match-counter COUNTER

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

Package

roan

Source

pattern.lisp (file)

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

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

Function: roundsp ROW

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

Package

roan

Source

roan.lisp (file)

Function: row &rest BELLS

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

Package

roan

Source

roan.lisp (file)

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

roan

Source

pattern.lisp (file)

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

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

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

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

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

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

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

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

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

Package

roan

Source

pattern.lisp (file)

Function: row-string ROW &optional UPPER-CASE

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

Package

roan

Source

roan.lisp (file)

Function: rowp OBJECT
Package

roan

Source

roan.lisp (file)

Function: stage ROW

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

Package

roan

Source

roan.lisp (file)

Function: stage-from-name NAME

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

Package

roan

Source

roan.lisp (file)

Function: stage-name STAGE

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

Package

roan

Source

roan.lisp (file)

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

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

Package

roan

Source

roan.lisp (file)

Function: update-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 (file)

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

Function: which-grandsire-lead-head ROW

If @var{row} is a lead head of a plain course of Grandsire at its stage returns a positive integer identifying which lead head it is; returns @code{nil} if @var{row} is not a Grandsire lead head. If @var{row} is the first lead head of a plain course of Grandsire @code{1} is returned, if the second @code{2}, etc. For the purposes of this function rounds is not a Grandsire lead head, nor is any row below 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 (file)

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

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

Package

roan

Source

roan.lisp (file)

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

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

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

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

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

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

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

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

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

Package

roan

Source

roan.lisp (file)

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

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

Package

roan

Source

roan.lisp (file)


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

5.1.5 Generic functions

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

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

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

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

Package

roan

Source

roan.lisp (file)

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

roan

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

method.lisp (file)

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

roan

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

method.lisp (file)

Generic Function: method-library-error-description CONDITION
Package

roan

Methods
Method: method-library-error-description (CONDITION method-library-error)
Source

method.lisp (file)

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

roan

Methods
Method: method-name METHOD
Source

method.lisp (file)

Method: method-name (METHOD method)

automatically generated reader method

Source

method.lisp (file)

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

automatically generated writer method

Source

method.lisp (file)

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

method.lisp (file)

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

roan

Methods
Method: method-place-notation METHOD
Source

method.lisp (file)

Method: method-place-notation (METHOD method)

automatically generated reader method

Source

method.lisp (file)

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

automatically generated writer method

Source

method.lisp (file)

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

method.lisp (file)

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

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

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

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

Package

roan

Source

pattern.lisp (file)

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

===merge: generate-rows

Package

roan

Source

roan.lisp (file)

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

===merge: permute-collection 3

Package

roan

Source

roan.lisp (file)

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

===merge: permute-collection 2

Package

roan

Source

roan.lisp (file)

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

===merge: permute-collection 1

Package

roan

Source

roan.lisp (file)

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

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

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

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

Package

roan

Source

roan.lisp (file)

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

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

5.1.6 Conditions

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

Direct superclasses

simple-error (condition)

Direct methods
Direct slots
Slot: call
Initargs

:call

Readers

call-application-error-call (generic function)

Slot: method
Initargs

:method

Readers

call-application-error-method (generic function)

Slot: details
Initargs

:details

Readers

call-application-error-details (generic function)

Condition: inappropriate-method-error ()

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

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: details
Initargs

:details

Readers

inappropriate-method-error-details (generic function)

Slot: method
Initargs

:method

Readers

inappropriate-method-error-method (generic function)

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

Direct superclasses

simple-error (condition)

Direct methods

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

Direct slots
Slot: method
Initargs

:method

Readers

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

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

Direct superclasses

file-error (condition)

Direct methods

method-library-error-description (method)

Direct slots
Slot: description
Initargs

:description

Readers

method-library-error-description (generic function)

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

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

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Condition: no-place-notation-error ()

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

Package

roan

Source

method.lisp (file)

Direct superclasses

error (condition)

Direct methods

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

Direct slots
Slot: method
Initargs

:method

Readers

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

Condition: pattern-parse-error ()

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

Package

roan

Source

pattern.lisp (file)

Direct superclasses

parse-error (condition)

Direct methods
Direct slots
Slot: message
Initargs

:message

Initform

(quote nil)

Readers

pattern-parse-error-message (generic function)

Writers

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

Slot: pattern
Initargs

:pattern

Initform

(quote nil)

Readers

pattern-parse-error-pattern (generic function)

Writers

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

Slot: index
Initargs

:index

Initform

(quote nil)

Readers

pattern-parse-error-index (generic function)

Writers

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

Condition: row-match-error ()

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

Package

roan

Source

pattern.lisp (file)

Direct superclasses

simple-error (condition)


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

5.1.7 Structures

Structure: 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 set 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 Triples 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 (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: place-notation
Type

(or null string)

Readers

call-place-notation (function)

Writers

(setf call-place-notation) (function)

Slot: offset
Type

(integer 0)

Initform

0

Readers

call-offset (function)

Writers

(setf call-offset) (function)

Slot: from-end
Initform

t

Readers

call-from-end (function)

Writers

(setf call-from-end) (function)

Slot: fraction
Type

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

Readers

call-fraction (function)

Writers

(setf call-fraction) (function)

Slot: replace
Type

(integer 0)

Initform

0

Readers

call-replace (function)

Writers

(setf call-replace) (function)

Slot: following
Readers

call-following (function)

Writers

(setf call-following) (function)

Slot: changes
Type

simple-vector

Initform

#()

Readers

call-changes (function)

Writers

(setf call-changes) (function)

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

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: index
Type

integer

Initform

0

Readers

fch-group-index (function)

Writers

(setf fch-group-index) (function)

Slot: name
Type

string

Initform

""

Readers

fch-group-name (function)

Writers

(setf fch-group-name) (function)

Slot: parity
Type

symbol

Readers

fch-group-parity (function)

Writers

(setf fch-group-parity) (function)

Slot: elements
Type

list

Readers

fch-group-elements (function)

Writers

(setf fch-group-elements) (function)

Structure: hash-set ()

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

Package

roan

Source

util.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: table
Type

hash-table

Initform

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

Readers

hash-set-table (function)

Writers

(setf hash-set-table) (function)

Structure: match-counter ()

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

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

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

Package

roan

Source

pattern.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: stage
Initform

roan:*default-stage*

Readers

match-counter-stage (function)

Writers

(setf match-counter-stage) (function)

Slot: %handstroke-p
Initform

t

Readers

match-counter-%handstroke-p (function)

Writers

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

Slot: patterns-vector
Initform

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

Readers

match-counter-patterns-vector (function)

Writers

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

Slot: patterns-table
Initform

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

Readers

match-counter-patterns-table (function)

Writers

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

Slot: dfas
Readers

match-counter-dfas (function)

Writers

(setf match-counter-dfas) (function)

Structure: row ()

===summary===
@cindex immutable
The fundamental units of 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 (file)

Direct superclasses

structure-object (structure)

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

roan::%bells-vector

Readers

row-bells (function)

Writers

(setf row-bells) (function)


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

5.1.8 Classes

Class: method ()

===summary===
Roan provides the @code{method} type to describe change ringing methods, not to be confused with CLOS methods. A @code{method} can only describe 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 (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Type

(or string null)

Initargs

:name

Readers

method-name (generic function)

Writers

(setf method-name) (generic function)

Slot: classification
Type

roan::encoded-classification

Initargs

:classification

Initform

0

Readers

%method-classification (generic function)

Writers

(setf %method-classification) (generic function)

Slot: place-notation
Type

(or string null)

Initargs

:place-notation

Readers

method-place-notation (generic function)

Writers

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


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

5.1.9 Types

Type: bell ()

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

Package

roan

Source

roan.lisp (file)

Type: stage ()

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

Package

roan

Source

roan.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Constants

Constant: +bell-names+
Package

roan

Source

roan.lisp (file)

Constant: +blueline-column-spacing+
Package

roan

Source

method.lisp (file)

Constant: +blueline-dot-size+
Package

roan

Source

method.lisp (file)

Constant: +blueline-figures-size+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +blueline-horizontal-increment+
Package

roan

Source

method.lisp (file)

Constant: +blueline-horizontal-margin+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +blueline-labels-size+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +blueline-plus-length+
Package

roan

Source

method.lisp (file)

Constant: +blueline-vertical-margin+
Package

roan

Source

method.lisp (file)

Constant: +blueline-vertical-offset+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +change-cache-size+
Package

roan

Source

roan.lisp (file)

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

roan

Source

roan.lisp (file)

Constant: +class-field+
Package

roan

Source

method.lisp (file)

Constant: +class-names+
Package

roan

Source

method.lisp (file)

Constant: +classes+
Package

roan

Source

method.lisp (file)

Constant: +cross-changes+
Package

roan

Source

roan.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +differential-field+
Package

roan

Source

method.lisp (file)

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

roan

Source

roan.lisp (file)

Constant: +extra-methods+
Package

roan

Source

method.lisp (file)

Constant: +huffman-table+
Package

roan

Source

method.lisp (file)

Constant: +hunt-changes+
Package

roan

Source

roan.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +initial-cross-character+
Package

roan

Source

roan.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

roan.lisp (file)

Constant: +jump-field+
Package

roan

Source

method.lisp (file)

Constant: +lead-head-codes+
Package

roan

Source

method.lisp (file)

Constant: +little-field+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +method-source+
Package

roan

Source

method.lisp (file)

Constant: +method-source-entry+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +named-bells+
Package

roan

Source

roan.lisp (file)

Constant: +named-stages+
Package

roan

Source

roan.lisp (file)

Constant: +path-types+
Package

roan

Source

method.lisp (file)

Constant: +pattern-cache-size+
Package

roan

Source

pattern.lisp (file)

Constant: +pattern-characters+
Package

roan

Source

pattern.lisp (file)

Constant: +pattern-token+*
Package

roan

Source

pattern.lisp (file)

Constant: +place-notation-chars+
Package

roan

Source

roan.lisp (file)

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

roan

Source

roan.lisp (file)

Constant: +rounds-bell-array+
Package

roan

Source

roan.lisp (file)

Constant: +row-signature-shift+
Package

roan

Source

method.lisp (file)

Constant: +run-token+*
Package

roan

Source

pattern.lisp (file)

Constant: +stage-field+
Package

roan

Source

method.lisp (file)

Constant: +stage-names+
Package

roan

Source

roan.lisp (file)

Constant: +status-ok+
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Constant: +suppress-class+
Package

roan

Source

method.lisp (file)


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

5.2.2 Special variables

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

roan

Source

method.lisp (file)

Special Variable: *blueline-method*
Package

roan

Source

method.lisp (file)

Special Variable: *blueline-row-height*
Package

roan

Source

method.lisp (file)

Special Variable: *blueline-stream*
Package

roan

Source

method.lisp (file)

Special Variable: *change-cache*
Package

roan

Source

roan.lisp (file)

Special Variable: *collapsable-whitespace-scanner*
Package

roan

Source

util.lisp (file)

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

roan

Source

util.lisp (file)

Special Variable: *dfa-stage*
Package

roan

Source

pattern.lisp (file)

Special Variable: *dfa-states*
Package

roan

Source

pattern.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Special Variable: *last-nfa-id*
Package

roan

Source

pattern.lisp (file)

Special Variable: *method-library*
Package

roan

Source

method.lisp (file)

Special Variable: *method-traits-cache*
Package

roan

Source

method.lisp (file)

Special Variable: *nfa-stage*
Package

roan

Source

pattern.lisp (file)

Special Variable: *pattern-cache*
Package

roan

Source

pattern.lisp (file)

Special Variable: *pattern-parse-state*
Package

roan

Source

pattern.lisp (file)

Special Variable: *previous-readtables*
Package

roan

Source

readtables.lisp (file)

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

roan

Source

method.lisp (file)

Special Variable: *threading-p*
Package

roan

Source

util.lisp (file)

Special Variable: *xml-file*
Package

roan

Source

method.lisp (file)

Special Variable: +method-title-scanner+
Package

roan

Source

method.lisp (file)

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

roan

Source

util.lisp (file)


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

5.2.3 Macros

Macro: %get-call-changes VECTOR STAGE
Package

roan

Source

method.lisp (file)

Macro: check-type* OBJECT TYPE
Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)

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

roan

Source

pattern.lisp (file)

Macro: define-method-boolean (METHOD-VAR VALUE-VAR) (NAME FIELD) &body EXTRA-ACTIONS
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

util.lisp (file)

Macro: deflock NAME
Package

roan

Source

util.lisp (file)

Macro: fch-list-f PLACE
Package

roan

Source

method.lisp (file)

Macro: get-call-changes CALL STAGE
Package

roan

Source

method.lisp (file)

Macro: get-entry KEY CACHE
Package

roan

Source

util.lisp (file)

Macro: logiorf PLACE &rest NUMBERS
Package

roan

Source

pattern.lisp (file)

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

roan

Source

roan.lisp (file)

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

roan

Source

roan.lisp (file)

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

roan

Source

util.lisp (file)

Macro: with-roan-file (STREAM FILESPEC &rest OPTIONS &key EXTERNAL-FORMAT &allow-other-keys) &body BODY
Package

roan

Source

util.lisp (file)

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

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

Package

roan

Source

util.lisp (file)


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

5.2.4 Functions

Function: %assemble-row BELLS
Package

roan

Source

roan.lisp (file)

Function: %blueline STREAM METHOD LAYOUT HUNT-BELL WORKING-BELL FIGURES PLACE-NOTATION PLACE-BELLS
Package

roan

Source

method.lisp (file)

Function: %counts COUNT
Package

roan

Source

pattern.lisp (file)

Function: %extreme-hash-set SETS TEST
Package

roan

Source

util.lisp (file)

Function: %fill-bells-vector ()
Package

roan

Source

roan.lisp (file)

Function: %get-changes METHOD &optional TRAITS
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Function: %hash-set-intersection SETS COPY
Package

roan

Source

util.lisp (file)

Function: %hash-set-union SETS COPY
Package

roan

Source

util.lisp (file)

Function: %in-course-p ()
Package

roan

Source

roan.lisp (file)

Function: %make-hash-set TABLE
Package

roan

Source

util.lisp (file)

Function: %make-match-counter STAGE
Package

roan

Source

pattern.lisp (file)

Function: %make-row BELLS
Package

roan

Source

roan.lisp (file)

Function: %npermute-hash-set SET FUNCTION
Package

roan

Source

roan.lisp (file)

Function: %parse-change CHANGE STAGE
Package

roan

Source

roan.lisp (file)

Function: %parse-place-notation SEGMENT STAGE
Package

roan

Source

roan.lisp (file)

Function: %permute ()
Package

roan

Source

roan.lisp (file)

Function: %placesp BELLS &rest PLACES
Package

roan

Source

roan.lisp (file)

Function: %roan-syntax ON-OFF MODIFY
Package

roan

Source

readtables.lisp (file)

Function: %roundsp BELLS
Package

roan

Source

roan.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

roan.lisp (file)

Function: %update-changes METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-course-length METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-lead-count METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-lead-head-code METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-lead-length METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-plain-course METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %update-plain-lead METHOD TRAITS
Package

roan

Source

method.lisp (file)

Function: %with-lock LOCK THUNK
Package

roan

Source

util.lisp (file)

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

roan

Source

roan.lisp (file)

Function: add-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: add-library-method VECTOR METHOD &optional PLACE-NOTATION NAME INFO
Package

roan

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: advance-token &optional STATE
Package

roan

Source

pattern.lisp (file)

Function: bell-list-p X
Package

roan

Source

method.lisp (file)

Function: blueline-format STRING &rest ARGS
Package

roan

Source

method.lisp (file)

Function: build-dfa-state NFA-STATES
Package

roan

Source

pattern.lisp (file)

Function: byte-left BS
Package

roan

Source

util.lisp (file)

Function: cache-count CACHE

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

Package

roan

Source

util.lisp (file)

Function: call-changes INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-following INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-fraction INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-from-end INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-offset INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-place-notation INSTANCE
Package

roan

Source

method.lisp (file)

Function: call-replace INSTANCE
Package

roan

Source

method.lisp (file)

Function: canonical-rotation CHANGES
Package

roan

Source

method.lisp (file)

Function: canonical-rotation-key CHANGES
Package

roan

Source

method.lisp (file)

Function: changes-info CHANGES
Package

roan

Source

roan.lisp (file)

Function: checked-hash-set-table SET
Package

roan

Source

util.lisp (file)

Function: class-from-name STRING
Package

roan

Source

method.lisp (file)

Function: clear-method-traits METHOD
Package

roan

Source

method.lisp (file)

Function: clrcache CACHE

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

Package

roan

Source

util.lisp (file)

Function: collapse-whitespace S

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

Package

roan

Source

util.lisp (file)

Function: comparableize-string S
Package

roan

Source

method.lisp (file)

Function: compare-rows ROW1 ROW2
Package

roan

Source

method.lisp (file)

Function: convert-xml-method-file XML-FILE LIBRARY-FILE URL ETAG LAST-MODIFIED
Package

roan

Source

method.lisp (file)

Function: copy-method METHOD
Package

roan

Source

method.lisp (file)

Function: copy-method-library INSTANCE
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Function: cross-sections LEAD-LENGTH EXCURSION PATH
Package

roan

Source

method.lisp (file)

Function: current-token &optional STATE
Package

roan

Source

pattern.lisp (file)

Function: download-zipped-methods URL
Package

roan

Source

method.lisp (file)

Function: draw-column X BELL STARTS LEADS HUNTS FIGURES PLACE-NOTATION PLACE-BELLS
Package

roan

Source

method.lisp (file)

Function: draw-dot X Y
Package

roan

Source

method.lisp (file)

Function: draw-figures X Y WHERE HOLES FIRST
Package

roan

Source

method.lisp (file)

Function: draw-label START X Y
Package

roan

Source

method.lisp (file)

Function: draw-line BELL X Y HUNT-P LEADS
Package

roan

Source

method.lisp (file)

Function: draw-place-notation X Y LEADS HALF-LEAD-ONLY
Package

roan

Source

method.lisp (file)

Function: encode-place-notation NOTATION STAGE
Package

roan

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: equal-byte-specifiers BS1 BS2
Package

roan

Source

util.lisp (file)

Function: falseness-groups METHOD FCHS
Package

roan

Source

method.lisp (file)

Function: fch-group-index INSTANCE
Package

roan

Source

method.lisp (file)

Function: fch-group-p OBJECT
Package

roan

Source

method.lisp (file)

Function: fch-lessp R1 R2
Package

roan

Source

method.lisp (file)

Function: find-name-prefix PREFIX METHODS
Package

roan

Source

method.lisp (file)

Function: follow-empty-transitions STATE TABLE
Package

roan

Source

pattern.lisp (file)

Function: generate-rows-error CHANGES
Package

roan

Source

roan.lisp (file)

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

roan

Source

roan.lisp (file)

Function: get-accessor-names SLOT
Package

roan

Source

method.lisp (file)

Function: get-headers URL
Package

roan

Source

method.lisp (file)

Function: get-method-traits METHOD &optional CREATE-IF-NECESSARY
Package

roan

Source

method.lisp (file)

Function: get-newest-key CACHE &optional DEFAULT

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

Package

roan

Source

util.lisp (file)

Function: get-newest-value CACHE &optional DEFAULT

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

Package

roan

Source

util.lisp (file)

Function: get-single-element-by-tag-name NODE TAG &optional ERROR-IF-ABSENT
Package

roan

Source

method.lisp (file)

Function: getcache KEY CACHE &optional DEFAULT

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

Package

roan

Source

util.lisp (file)

Setf Expander

(setf getcache) (setf expander)

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

roan

Source

util.lisp (file)

Reader

getcache (function)

Function: hash-set-table INSTANCE
Package

roan

Source

util.lisp (file)

Function: headers-extract HEADERS
Package

roan

Source

method.lisp (file)

Function: jump-allowed-path-little-p METHOD BELL
Package

roan

Source

method.lisp (file)

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

roan

Source

roan.lisp (file)

Function: make-call &key (PLACE-NOTATION PLACE-NOTATION) (OFFSET OFFSET) (FROM-END FROM-END) (FRACTION FRACTION) (REPLACE REPLACE) (FOLLOWING FOLLOWING) (CHANGES CHANGES)
Package

roan

Source

method.lisp (file)

Function: make-dfa INITIAL-NFA-STATE
Package

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

method.lisp (file)

Function: make-lru-cache SIZE &key TEST

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

Package

roan

Source

util.lisp (file)

Function: make-match-counter-dfas COUNTER
Package

roan

Source

pattern.lisp (file)

Function: make-method-library &key (METADATA METADATA) (NO-NAME-COUNT NO-NAME-COUNT) (METHODS METHODS) (ROTATION-KEYS ROTATION-KEYS) (ADDITIONAL-DATA ADDITIONAL-DATA)
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: make-nfa-state &optional STAGE
Package

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: match-counter-patterns-table INSTANCE
Package

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: method-details METHOD
Package

roan

Source

method.lisp (file)

Function: method-library-additional-data INSTANCE
Function: (setf method-library-additional-data) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-library-etag FILE
Package

roan

Source

method.lisp (file)

Function: method-library-metadata INSTANCE
Function: (setf method-library-metadata) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-library-methods INSTANCE
Function: (setf method-library-methods) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-library-no-name-count INSTANCE
Function: (setf method-library-no-name-count) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

Function: method-library-p OBJECT
Package

roan

Source

method.lisp (file)

Function: method-library-parse-error &optional MSG &rest ARGS
Package

roan

Source

method.lisp (file)

Function: method-library-rotation-keys INSTANCE
Function: (setf method-library-rotation-keys) VALUE INSTANCE
Package

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

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

roan

Source

method.lisp (file)

Function: move-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: name-recognizers S
Package

roan

Source

method.lisp (file)

Function: name-spaces-p S
Package

roan

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: nfa-id NFA-STATE
Package

roan

Source

pattern.lisp (file)

Function: nunfold CHANGES
Package

roan

Source

roan.lisp (file)

Function: parse-alternative ()
Package

roan

Source

pattern.lisp (file)

Function: parse-bell-class STRING STAGE
Package

roan

Source

pattern.lisp (file)

Function: parse-disjunction ()
Package

roan

Source

pattern.lisp (file)

Function: parse-element ()
Package

roan

Source

pattern.lisp (file)

Function: parse-method-id METHOD
Package

roan

Source

method.lisp (file)

Function: parse-method-library-description DOM
Package

roan

Source

method.lisp (file)

Function: parse-peal XML TAG
Package

roan

Source

method.lisp (file)

Function: parse-prototype STAGE PROPERTIES
Package

roan

Source

method.lisp (file)

Function: parse-run STRING STAGE
Package

roan

Source

pattern.lisp (file)

Function: partition-hunt-bells TARGET
Package

roan

Source

method.lisp (file)

Function: path-attributes-non-jump METHOD BELL
Package

roan

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: permute-collection-type-error COLLECTION
Package

roan

Source

roan.lisp (file)

Function: plain-class-type METHOD SKIP
Package

roan

Source

method.lisp (file)

Function: prin1-hash-set SET STREAM
Package

roan

Source

util.lisp (file)

Function: publish-trait THING
Package

roan

Source

method.lisp (file)

Function: putcache KEY CACHE VALUE
Package

roan

Source

util.lisp (file)

Function: read-method-library &key LOAD-ROTATIONS LOAD-ADDITIONAL-DATA FORCE
Package

roan

Source

method.lisp (file)

Function: remcache KEY CACHE

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

Package

roan

Source

util.lisp (file)

Function: remove-entry ENTRY CACHE
Package

roan

Source

util.lisp (file)

Function: rotate-cycle CYCLE TARGET
Package

roan

Source

method.lisp (file)

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

roan

Source

roan.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

Source

pattern.lisp (file)

Function: row-creation-error DATA PARSE
Package

roan

Source

roan.lisp (file)

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

roan

Source

method.lisp (file)

Function: rows-distinct-p ROWS

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

Package

roan

Source

method.lisp (file)

Function: same-type-p X Y
Package

roan

Source

util.lisp (file)

Function: set-method-class METHOD CLASS
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-class) (setf expander)

Function: set-method-differential-p METHOD VALUE
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-differential-p) (setf expander)

Function: set-method-jump-p METHOD VALUE
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-jump-p) (setf expander)

Function: set-method-little-p METHOD VALUE
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-little-p) (setf expander)

Function: set-method-stage METHOD STAGE
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-stage) (setf expander)

Function: set-method-title METHOD TITLE
Package

roan

Source

method.lisp (file)

Setf Expander

(setf method-title) (setf expander)

Function: sharp-bang-reader STREAM SUBCHAR ARG
Package

roan

Source

roan.lisp (file)

Function: signature STATES
Package

roan

Source

pattern.lisp (file)

Function: sort-fch-set SET
Package

roan

Source

method.lisp (file)

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

roan

Source

roan.lisp (file)

Function: test-jump-palindrome CHANGES N
Package

roan

Source

roan.lisp (file)

Function: test-ordinary-palindrome CHANGES N
Package

roan

Source

roan.lisp (file)

Function: text NODE
Package

roan

Source

method.lisp (file)

Function: thread-call NAME &rest ARGS
Package

roan

Source

util.lisp (file)

Function: total-bells STAGE COVERED
Package

roan

Source

pattern.lisp (file)

Function: treble-dodging-class-type METHOD CROSS-SECTIONS
Package

roan

Source

method.lisp (file)

Function: unzip-xml-file ZIPFILE
Package

roan

Source

method.lisp (file)

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

roan

Source

roan.lisp (file)


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

5.2.5 Generic functions

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

roan

Methods
Method: %method-classification METHOD
Source

method.lisp (file)

Method: %method-classification (METHOD method)

automatically generated reader method

Source

method.lisp (file)

Method: (setf %method-classification) NEW-VALUE (METHOD method)

automatically generated writer method

Source

method.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

Generic Function: cache-size OBJECT
Package

roan

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

automatically generated reader method

Source

util.lisp (file)

Generic Function: call-application-error-call CONDITION
Package

roan

Methods
Method: call-application-error-call (CONDITION call-application-error)
Source

method.lisp (file)

Generic Function: call-application-error-details CONDITION
Package

roan

Methods
Method: call-application-error-details (CONDITION call-application-error)
Source

method.lisp (file)

Generic Function: call-application-error-method CONDITION
Package

roan

Methods
Method: call-application-error-method (CONDITION call-application-error)
Source

method.lisp (file)

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

roan

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

automatically generated reader method

Source

pattern.lisp (file)

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

automatically generated writer method

Source

pattern.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

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

roan

Source

pattern.lisp (file)

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

roan

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

automatically generated reader method

Source

pattern.lisp (file)

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

automatically generated reader method

Source

pattern.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

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

roan

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

method.lisp (file)

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

method.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

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

roan

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

pattern.lisp (file)

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

roan

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

pattern.lisp (file)

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

roan

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

pattern.lisp (file)

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

roan

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

automatically generated reader method

Source

util.lisp (file)

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

automatically generated writer method

Source

util.lisp (file)

Generic Function: set-final NEW-VALUE OBJECT
Package

roan

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

automatically generated writer method

Source

pattern.lisp (file)

Generic Function: transitions OBJECT
Package

roan

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

automatically generated reader method

Source

pattern.lisp (file)

Method: transitions (NFA-STATE nfa-state)

automatically generated reader method

Source

pattern.lisp (file)


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

5.2.6 Conditions

Condition: jump-change-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses

simple-error (condition)

Condition: row-creation-error ()
Package

roan

Source

roan.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses

row-creation-parse-error (condition)

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

roan

Source

roan.lisp (file)

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

roan

Source

readtables.lisp (file)

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

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

5.2.7 Structures

Structure: method-library ()
Package

roan

Source

method.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: metadata
Readers

method-library-metadata (function)

Writers

(setf method-library-metadata) (function)

Slot: no-name-count
Readers

method-library-no-name-count (function)

Writers

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

Slot: methods
Initform

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

Readers

method-library-methods (function)

Writers

(setf method-library-methods) (function)

Slot: rotation-keys
Readers

method-library-rotation-keys (function)

Writers

(setf method-library-rotation-keys) (function)

Slot: additional-data
Readers

method-library-additional-data (function)

Writers

(setf method-library-additional-data) (function)

Structure: method-traits ()
Package

roan

Source

method.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: changes
Readers

method-traits-changes (function)

Writers

(setf method-traits-changes) (function)

Slot: contains-jump-changes-p
Readers

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

Writers

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

Slot: lead-length
Readers

method-traits-lead-length (function)

Writers

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

Slot: lead-head
Readers

method-traits-lead-head (function)

Writers

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

Slot: lead-count
Readers

method-traits-lead-count (function)

Writers

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

Slot: plain-lead
Readers

method-traits-plain-lead (function)

Writers

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

Slot: plain-course
Readers

method-traits-plain-course (function)

Writers

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

Slot: course-length
Readers

method-traits-course-length (function)

Writers

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

Slot: hunt-bells
Readers

method-traits-hunt-bells (function)

Writers

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

Slot: principal-hunt-bells
Readers

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

Writers

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

Slot: secondary-hunt-bells
Readers

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

Writers

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

Slot: working-bells
Readers

method-traits-working-bells (function)

Writers

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

Slot: classification
Readers

method-traits-classification (function)

Writers

(setf method-traits-classification) (function)

Slot: lead-head-code
Readers

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

Writers

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

Structure: row-count ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: label
Readers

row-count-label (function)

Writers

(setf row-count-label) (function)

Slot: pattern
Readers

row-count-pattern (function)

Writers

(setf row-count-pattern) (function)

Slot: double-row-p
Readers

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

Writers

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

Slot: handstroke
Initform

0

Readers

row-count-handstroke (function)

Writers

(setf row-count-handstroke) (function)

Slot: backstroke
Initform

0

Readers

row-count-backstroke (function)

Writers

(setf row-count-backstroke) (function)


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

5.2.8 Classes

Class: cache-entry ()

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

Package

roan

Source

util.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: key
Readers

entry-key (generic function)

Writers

(setf entry-key) (generic function)

Slot: value
Readers

entry-value (generic function)

Writers

(setf entry-value) (generic function)

Slot: previous
Type

(or roan::cache-entry null)

Readers

previous-entry (generic function)

Writers

(setf previous-entry) (generic function)

Slot: next
Type

(or roan::cache-entry null)

Readers

next-entry (generic function)

Writers

(setf next-entry) (generic function)

Class: dfa-state ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions (generic function)

Slot: final
Type

(quote list)

Initargs

:final

Readers

get-final (generic function)

Class: lru-cache ()

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

Package

roan

Source

util.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: size
Type

(integer 1 *)

Initargs

:size

Readers

cache-size (generic function)

Slot: table
Type

roan::hash

Initargs

:table

Readers

cache-entry-table (generic function)

Slot: newest
Type

(or roan::cache-entry null)

Readers

newest-entry (generic function)

Writers

(setf newest-entry) (generic function)

Slot: oldest
Type

(or roan::cache-entry null)

Readers

oldest-entry (generic function)

Writers

(setf oldest-entry) (generic function)

Class: nfa-state ()
Package

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: transitions
Type

(quote simple-vector)

Initargs

:transitions

Readers

transitions (generic function)

Slot: empty-transition
Type

(quote list)

Initform

(quote nil)

Readers

empty-transition (generic function)

Writers

(setf empty-transition) (generic function)

Slot: final
Readers

get-final (generic function)

Writers

set-final (generic function)

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

roan

Source

pattern.lisp (file)

Direct superclasses

standard-object (class)

Direct slots
Slot: string
Initargs

:string

Slot: stage
Initargs

:stage

Slot: index
Initform

0

Slot: token
Slot: token-end
Initform

0


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

5.2.9 Types

Type: %bells-vector ()
Package

roan

Source

roan.lisp (file)

Type: encoded-classification ()
Package

roan

Source

method.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   R  
Index Entry  Section

F
File, Lisp, roan.asd: The roan․asd file
File, Lisp, roan/method.lisp: The roan/method․lisp file
File, Lisp, roan/package.lisp: The roan/package․lisp file
File, Lisp, roan/pattern.lisp: The roan/pattern․lisp file
File, Lisp, roan/readtables.lisp: The roan/readtables․lisp file
File, Lisp, roan/roan.lisp: The roan/roan․lisp file
File, Lisp, roan/util.lisp: The roan/util․lisp file

L
Lisp File, roan.asd: The roan․asd file
Lisp File, roan/method.lisp: The roan/method․lisp file
Lisp File, roan/package.lisp: The roan/package․lisp file
Lisp File, roan/pattern.lisp: The roan/pattern․lisp file
Lisp File, roan/readtables.lisp: The roan/readtables․lisp file
Lisp File, roan/roan.lisp: The roan/roan․lisp file
Lisp File, roan/util.lisp: The roan/util․lisp file

R
roan.asd: The roan․asd file
roan/method.lisp: The roan/method․lisp file
roan/package.lisp: The roan/package․lisp file
roan/pattern.lisp: The roan/pattern․lisp file
roan/readtables.lisp: The roan/readtables․lisp file
roan/roan.lisp: The roan/roan․lisp file
roan/util.lisp: The roan/util․lisp file

Jump to:   F   L   R  

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

A.2 Functions

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

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

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

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

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

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

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

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

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

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

H
hash-set: Exported functions
hash-set-adjoin: Exported functions
hash-set-clear: Exported functions
hash-set-copy: Exported functions
hash-set-count: Exported functions
hash-set-delete: Exported functions
hash-set-deletef: Exported macros
hash-set-difference: Exported functions
hash-set-elements: Exported functions
hash-set-empty-p: Exported functions
hash-set-intersection: Exported functions
hash-set-member: Exported functions
hash-set-nadjoin: Exported functions
hash-set-nadjoinf: Exported macros
hash-set-ndifference: Exported functions
hash-set-nintersection: Exported functions
hash-set-nunion: Exported functions
hash-set-p: Exported functions
hash-set-proper-subset-p: Exported functions
hash-set-remove: Exported functions
hash-set-subset-p: Exported functions
hash-set-table: Internal functions
hash-set-union: Exported functions
headers-extract: Internal functions

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

J
jump-allowed-path-little-p: Internal functions
jump-change-error: Internal functions

L
logiorf: Internal macros
lookup-method-by-title: Exported functions
lookup-method-info: Exported functions
lookup-methods: Exported functions
lookup-methods-by-notation: Exported functions

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

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

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

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

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

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

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

U
unzip-xml-file: Internal functions
update-method-library: Exported functions
use-roan: Exported functions

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

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

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

A.3 Variables

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

%
%handstroke-p: Exported structures

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

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

A
additional-data: Internal structures

B
backstroke: Internal structures
bells: Exported structures

C
call: Exported conditions
changes: Exported structures
changes: Internal structures
classification: Exported classes
classification: Internal structures
Constant, +bell-names+: Internal constants
Constant, +blueline-column-spacing+: Internal constants
Constant, +blueline-dot-size+: Internal constants
Constant, +blueline-figures-size+: Internal constants
Constant, +blueline-figures-x-offset+: Internal constants
Constant, +blueline-figures-y-offset+: Internal constants
Constant, +blueline-first-hunt-bell-colors+: Internal constants
Constant, +blueline-first-hunt-bell-width+: Internal constants