Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-algebraic-data-type Reference Manual, version 1.2.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:56:25 2018 GMT+0.
| • Introduction: | What cl-algebraic-data-type is all about | |
| • Systems: | The systems documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
by Robert Smith
CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic data types in a similar spirit to Haskell or Standard ML, as well as for operating on them.
We can define ADTs using defdata:
(adt:defdata maybe
(just t)
nothing)
which will define a new type maybe, with a unary constructor just,
and a nullary constructor nothing. The t represents the data type
of that field.
> (just 5)
#.(JUST 5)
> nothing
#.NOTHING
Note that the #. are printed so that they can be read back. This
allows them to be used literally in quoted lists, for example.
> '(#.(just 1) #.nothing)
(#.(JUST 1) #.NOTHING)
> (typep (first *) 'maybe)
T
If this is annoying to you, you can set the variable
adt:*print-adt-readably* to nil.
We can define our own version of a list via
(adt:defdata liszt
(kons t liszt)
knil)
which defines the binary constructor kons and the nullary constructor
knil.
> (kons 1 (kons 2 knil))
#.(KONS 1 #.(KONS 2 #.KNIL))
At the end we will define kar and kdr.
For efficiency, we might specify the types more exactly. For a point
type that supports rectangular and polar coordinates, which is also
mutable, we might have:
(adt:defdata (point :mutable t)
(rectangular float float)
(polar float float))
The :mutable option signifies that the data is mutable.
When we have constructed a value, we can extract data out of it using match:
> (let ((pt (rectangular 1.0 2.0)))
(adt:match point pt
((rectangular x y) (+ x y))
((polar _ _) nil)))
3.0
If we did not include the polar case, we would get a warning.
> (let ((pt (rectangular 1.0 2.0)))
(adt:match point pt
((rectangular x y) (+ x y))))
; caught WARNING:
; Non-exhaustive match. Missing cases: (POLAR)
3.0
We can also specify a fall-through:
> (let ((pt (rectangular 1.0 2.0)))
(adt:match point pt
((rectangular x y) (+ x y))
(_ nil)))
3.0
Since point is mutable, we can efficiently modify its fields using
set-data.
> (defun mirror-point! (pt)
(adt:with-data (rectangular x y) pt
(adt:set-data pt (rectangular y x))))
> (let ((pt (rectangular 1.0 2.0)))
(mirror-point! pt)
(adt:match point pt
((rectangular x y) (format t "point is (~A, ~A)" x y))
(_ nil))
will print point is (2.0, 1.0).
See examples.txt for examples.
Q. How do we define kar and kdr for liszt?
A. Easy.
(defun kar (l)
(adt:match liszt l
((kons a _) a)
(knil knil)))
(defun kdr (l)
(adt:match liszt l
((kons _ b) b)
(knil knil)))
Q. Can I get the constructors dynamically for a particular ADT?
A. Yes. You can get the constructors and associated arity by
calling the get-constructors function, which will return a list of
(<constructor> <arity>) pairs. For example, given the liszt
example above, we have
> (adt:get-constructors 'liszt)
((KONS 2) (KNIL 0))
T
The second value t represents the fact that the ADT is known and
exists.
Q. I have an ADT defined, and I'd like to extend it with another ADT. How can I do that?
A. You can define a new ADT which includes another one. For example, consider the following Boolean ADT.
(adt:defdata bool
true
false)
Suppose you wanted to extend this to have a "fuzzy" option, a
probability between true and false, specifically a real between 0
and 1 exclusive. We can create a fuzzy-bool which includes the
bool type, as well as a unary fuzzy constructor. This is done by
the :include option to defdata.
(adt:defdata (fuzzy-bool :include bool)
(fuzzy (real (0) (1))))
Note that true and false are constructors for both bool and
fuzzy-bool, as we can see with get-constructors.
> (adt:get-constructors 'bool)
((TRUE 0) (FALSE 0))
T
> (adt:get-constructors 'fuzzy-bool)
((TRUE 0) (FALSE 0) (FUZZY 1))
T
Q. Can we do parametric ADTs like I can in Haskell?
A. There is no support for it because Lisp doesn't have any useful notion of definable parametric types that aren't aliases of another existing parametric type.
Q. Why doesn't deeper pattern matching work?
A. It's not implemented, but it could be implemented for fields which are themselves algebraic data types. Patches welcome!
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cl-algebraic-data-type system: |
Robert Smith <robert@stylewarning.com>
BSD 3-clause
A library for algebraic data types.
1.2.0
cl-algebraic-data-type.asd (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files: | ||
| • Other files: |
Next: Other files, Previous: Files, Up: Files [Contents][Index]
Next: The cl-algebraic-data-type/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-algebraic-data-type.asd
cl-algebraic-data-type (system)
Next: The cl-algebraic-data-type/utilities<dot>lisp file, Previous: The cl-algebraic-data-type<dot>asd file, Up: Lisp files [Contents][Index]
license.txt (file)
cl-algebraic-data-type (system)
package.lisp
Next: The cl-algebraic-data-type/defdata<dot>lisp file, Previous: The cl-algebraic-data-type/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
cl-algebraic-data-type (system)
utilities.lisp
Next: The cl-algebraic-data-type/match<dot>lisp file, Previous: The cl-algebraic-data-type/utilities<dot>lisp file, Up: Lisp files [Contents][Index]
utilities.lisp (file)
cl-algebraic-data-type (system)
defdata.lisp
Previous: The cl-algebraic-data-type/defdata<dot>lisp file, Up: Lisp files [Contents][Index]
defdata.lisp (file)
cl-algebraic-data-type (system)
match.lisp
match (macro)
duplicates (function)
Previous: Lisp files, Up: Files [Contents][Index]
| • The cl-algebraic-data-type/license.txt file: |
Previous: Other files, Up: Other files [Contents][Index]
cl-algebraic-data-type (system)
LICENSE.txt
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The cl-algebraic-data-type package: |
A package for defining algebraic data types.
package.lisp (file)
adt
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions: | ||
| • Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported special variables: | ||
| • Exported macros: | ||
| • Exported functions: | ||
| • Exported structures: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Print preceding #. when printing ADT values.
defdata.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Define a new ADT. ADT-name has the following grammar:
ADT-NAME := <symbol>
| (<symbol> <options>*)
There is no difference between specifying it as a symbol or as a
singleton list. There are two possible options, specified as a
property list:
* :MUTABLE {T, NIL} (default: NIL): Specifies whether the fields
of the type are mutable, allowing the use of SET-DATA.
* :INCLUDE <adt-type>: Specifies whether another defined ADT
should be inherited.
Constructors is a list of clauses with the following grammar:
<clause> := <symbol>
| (<symbol> <type-specifier>*)
Each clause defines a constructor for the ADT. Nullary constructors will define constants and all other constructors will define functions.
defdata.lisp (file)
Perform pattern matching on OBJ with (adt-type) ADT.
Each clause must have the following syntax:
<var> := <symbol> | ’_’
<lhs> := ’_’
| (<symbol> <var>*)
<clause> := (<lhs> <lisp code>)
The symbol ’_’ denotes a wildcard, as well as a fallthough.
Note that pattern matching is only shallow (patterns are one-level deep).
match.lisp (file)
Mutate the fields of the ADT value OBJ whose constructor is NAME and whose updated values are NEW-VALUES based on order. If the symbol ’_’ is used as a value, that field is not updated. Trailing ’_’ may be omitted.
defdata.lisp (file)
Destructure the ADT value OBJ, whose constructor is NAME. VARS must be symbol which will be bound, or they must be the symbol ’_’, which means the value will not be bound.
defdata.lisp (file)
Next: Exported structures, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Is TYPE a known algebraic data type?
utilities.lisp (file)
Is the value VALUE that of some algebraic data type?
utilities.lisp (file)
Get the constructors and their arity for the adt ADT. Two values will be returned:
1. If the ADT exists, then a list of pairs
(CONSTRUCTOR-SYMBOL ARITY).
If the ARITY is zero, then the CONSTRUCTOR-SYMBOL is a value as opposed to a function.
2. T if the ADT exists, NIL otherwise. This mimics the behavior of GETHASH.
utilities.lisp (file)
Previous: Exported functions, Up: Exported definitions [Contents][Index]
Abstract type for all algebraic data types, primarily used to identify such types.
utilities.lisp (file)
structure-object (structure)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables: | ||
| • Internal macros: | ||
| • Internal functions: |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
utilities.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
utilities.lisp (file)
Previous: Internal macros, Up: Internal definitions [Contents][Index]
match.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index: | ||
| • Function index: | ||
| • Variable index: | ||
| • Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C F L O |
|---|
| Jump to: | C F L O |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | A D E F G I M P S U W |
|---|
| Jump to: | A D E F G I M P S U W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
S |
|---|
| Jump to: | *
S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | A C P S |
|---|
| Jump to: | A C P S |
|---|