Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the matrix-case Reference Manual, version 0.0.7, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 11:43:22 2020 GMT+0.
| • Introduction | What matrix-case 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 |
Control flow macros which writing nested CASE easily.
No such feature.
Hard to read/write.
Some pattern match library may provides same feature. But it is too much strong.
(matrix-typecase (:a :b)
((null null) :never)
((keyword keyword) :yes))
=> :YES
Integrated to popular utilities libraries. (e.g. alexandria)
Public domain
SBCL
TODO
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The matrix-case system |
Shinichi Sato
Public domain
Control flow macros which writing nested CASE easily.
0.0.7
matrix-case.asd (file)
matrix-case.lisp (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
| • The matrix-case.asd file | ||
| • The matrix-case/matrix-case.lisp file |
Next: The matrix-case/matrix-case․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
matrix-case.asd
matrix-case (system)
Previous: The matrix-case․asd file, Up: Lisp files [Contents][Index]
matrix-case (system)
matrix-case.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The matrix-case package |
matrix-case.lisp (file)
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 macros |
Previous: Exported definitions, Up: Exported definitions [Contents][Index]
# MATRIX-CASE, MATRIX-ECASE, MATRIX-CCASE
## [Macro] MATRIX-CASE MATRIX-ECASE MATRIX-CCASE
# Description: Like CL:CASE, but represents nested case.
“‘lisp
#?(op (0 1 2)
((0 0 0) :no)
((0 1 1) :no)
((0 1 2) :yes)
(otherwise :never))
=> :YES
“‘
“‘lisp
#?(matrix-case (0 1)
(((0 2 4 6 8) (1 3 5 7 9)) :yes)
(((0 2 4 6 8) (0 2 4 6 8)) :no)
(((1 3 5 7 9) (0 2 4 6 8)) :no))
=> :YES
“‘
### syntax
(MATRIX-CASE (&rest keyform) &body clause\*)
=> result
### Arguments and Values:
# keyform := a form; evaluated to produce a test-key.
# clause := ((test-key*) body)
test-key := an object produced by evaluating keyform.
body := an implicit PROGN.
# result := the values returned by the body in the matching clause.
# Affected By: none
# Side-Effects: none
# Notes:
# Exceptional-Situations:
matrix-case.lisp (file)
# MATRIX-CASE, MATRIX-ECASE, MATRIX-CCASE
## [Macro] MATRIX-CASE MATRIX-ECASE MATRIX-CCASE
# Description: Like CL:CASE, but represents nested case.
“‘lisp
#?(op (0 1 2)
((0 0 0) :no)
((0 1 1) :no)
((0 1 2) :yes)
(otherwise :never))
=> :YES
“‘
“‘lisp
#?(matrix-case (0 1)
(((0 2 4 6 8) (1 3 5 7 9)) :yes)
(((0 2 4 6 8) (0 2 4 6 8)) :no)
(((1 3 5 7 9) (0 2 4 6 8)) :no))
=> :YES
“‘
### syntax
(MATRIX-CASE (&rest keyform) &body clause\*)
=> result
### Arguments and Values:
# keyform := a form; evaluated to produce a test-key.
# clause := ((test-key*) body)
test-key := an object produced by evaluating keyform.
body := an implicit PROGN.
# result := the values returned by the body in the matching clause.
# Affected By: none
# Side-Effects: none
# Notes:
# Exceptional-Situations:
matrix-case.lisp (file)
# MATRIX-ETYPECASE, MATRIX-CTYPECASE
#### When any clause satisfies, an ERROR is signaled.
“‘lisp
#?(op (0)
((symbol) :never))
:signals ERROR
“‘
matrix-case.lisp (file)
# MATRIX-CASE, MATRIX-ECASE, MATRIX-CCASE
## [Macro] MATRIX-CASE MATRIX-ECASE MATRIX-CCASE
# Description: Like CL:CASE, but represents nested case.
“‘lisp
#?(op (0 1 2)
((0 0 0) :no)
((0 1 1) :no)
((0 1 2) :yes)
(otherwise :never))
=> :YES
“‘
“‘lisp
#?(matrix-case (0 1)
(((0 2 4 6 8) (1 3 5 7 9)) :yes)
(((0 2 4 6 8) (0 2 4 6 8)) :no)
(((1 3 5 7 9) (0 2 4 6 8)) :no))
=> :YES
“‘
### syntax
(MATRIX-CASE (&rest keyform) &body clause\*)
=> result
### Arguments and Values:
# keyform := a form; evaluated to produce a test-key.
# clause := ((test-key*) body)
test-key := an object produced by evaluating keyform.
body := an implicit PROGN.
# result := the values returned by the body in the matching clause.
# Affected By: none
# Side-Effects: none
# Notes:
# Exceptional-Situations:
matrix-case.lisp (file)
# MATRIX-ETYPECASE, MATRIX-CTYPECASE
#### When any clause satisfies, an ERROR is signaled.
“‘lisp
#?(op (0)
((symbol) :never))
:signals ERROR
“‘
matrix-case.lisp (file)
# MATRIX-TYPECASE, MATRIX-ETYPECASE, MATRIX-CTYPECASE
## [Macro] MATRIX-TYPECASE MATRIX-ETYPECASE MATRIX-CTYPECASE
# Description: Like CL:TYPECASE, but represents nested typecases.
“‘lisp
#?(let((a 0))
(op(a ’key)
((symbol integer):never)
((integer symbol):yes!)
(otherwise :no!)))
=> :YES!
“‘
#### Only one cluase’s body will be evaluated.
“‘lisp
#?(op (0 ’sym 1)
((symbol symbol symbol) (princ :sss))
((symbol symbol integer) (princ :ssi))
((symbol integer symbol) (princ :sis))
((symbol integer integer) (princ :sii))
((integer symbol integer) (princ :yes))
((integer symbol symbol) (princ :iss))
((integer integer integer) (princ :iii))
((integer integer symbol) (princ :iis))
(otherwise (princ :otherwise)))
:outputs "YES"
“‘
#### Of course, we can use compound type specifier.
“‘lisp
#?(op (0)
(((and integer (eql 1))) :no)
(((member 0 2 4 6 8)) :yes))
=> :YES
“‘
#### T as wildcard
“‘lisp
#?(op ("hoge" 0)
((t symbol) :no)
((t fixnum) :yes)
((string string) :no))
=> :yes
“‘
#### NOTE! wildcard is treated as last resort.
“‘lisp
#?(op ("1" "2")
((t string) :no)
((string string) :yes))
=> :yes
“‘
“‘lisp
#?(op ("1" "2")
((string t) :no)
((string string) :yes))
=> :yes
“‘
#### NOTE! Each clause is tested left to right order.
“‘lisp
#?(op (:a :b)
((null null) :no)
((atom atom) :yes))
=> :yes
“‘
### syntax
(MATRIX-TYPECASE targets &body clauses)
=> result
### Arguments and Values:
# targets := (target*)
target := one lisp form
#### every TARGET forms are evaluated only once.
“‘lisp
#?(op ((princ 0) (princ 1))
((symbol symbol) :no)
((integer symbol) :no)
((symbol integer) :no)
(otherwise :no))
:outputs "01"
“‘
# clauses := ((typespecifier+) &body body)
typespecifier := see hyperspec
body := implicit PROGN
# result := T
# Affected By: none
# Side-Effects: none
# Notes:
#### Empty TARGETS is valid but, in such case CLAUSES must empty.
#### Such form evaluated to be NIL by macro expansion.
“‘lisp
#?(op () ())
=> NIL
“‘
“‘lisp
#?(op () ())
:expanded-to NIL
“‘
“‘lisp
#?(op ())
=> NIL
“‘
“‘lisp
#?(op ())
:expanded-to NIL
“‘
“‘lisp
#?(op)
:signals ERROR
“‘
#### ECL/16.1.3 specific issue.
“‘lisp
#?(flet ((doit ()
(op (’(elt))
((atom) :atom)
(otherwise :other))))
(doit))
=> :other
“‘
# Exceptional-Situations:
#### when TARGETS length and each TYPE-SPECIFIERS length is different,
#### an error is signaled.
“‘lisp
#?(op (0)
((symbol integer) :error))
:signals ERROR
“‘
“‘lisp
#?(op (0 :hoge)
((integer) :error))
:signals ERROR
“‘
#### others
# MATRIX-TYPECASE
#### Default return value is NIL.
“‘lisp
#?(matrix-typecase (0)
((symbol) :no))
=> NIL
“‘
#### Expanded examples.
“‘lisp
#?(matrix-typecase (0)
((integer) :yes)
(otherwise :no))
:expanded-to (let ((var 0))
(typecase var
(integer :yes)
(t :no)))
“‘
“‘lisp
#?(matrix-typecase (0 ’sym)
((symbol integer) :no)
((integer symbol) :yes)
(otherwise :never))
:expanded-to (let ((var1 0))
(typecase var1
(symbol (let ((var2 ’sym))
(typecase var2
(integer :no)
(t :never))))
(integer (let ((var3 ’sym))
(typecase var3
(symbol :yes)
(t :never))))
(t :never)))
“‘
matrix-case.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal macros | ||
| • Internal functions |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
matrix-case.lisp (file)
Previous: Internal macros, Up: Internal definitions [Contents][Index]
matrix-case.lisp (file)
matrix-case.lisp (file)
matrix-case.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: | F L M |
|---|
| Jump to: | F L M |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | C D F I M |
|---|
| Jump to: | C D F I M |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | M P S |
|---|
| Index Entry | Section | ||
|---|---|---|---|
| | |||
| M | |||
matrix-case: | The matrix-case system | ||
matrix-case: | The matrix-case package | ||
| | |||
| P | |||
Package, matrix-case: | The matrix-case package | ||
| | |||
| S | |||
System, matrix-case: | The matrix-case system | ||
| | |||
| Jump to: | M P S |
|---|