chickadee » checks

Rationale

Pre- and postconditions made easy --------------------------------- This egg implements some routines, which are outsourced from simple-exceptions. In particular macros << and >>, which accept an argument or result, checks it against zero or more predicates and returns it in case of success unchanged. Otherwise it prints a meaningful error message, showing i.a. the offending predicate and the argument's or result's name. Some are implemented as macros instead of procedures, because I didn't want an extra parameter with the argument's or result's name. Procedure versions of those macros are given as well. In reimplementing those routines, I changed the syntax a bit, so be careful, if you used the equally named routines from simple-expressions.

The precondition and postcondition checks are denoted with some consecutive symbols < and > respectively. There are macro and procedure versions, the latter denoted with a trailing % and needing an additional parameter, the name of the value to be checked. All those routines work the same, they differ only in the error message, they produce in case some predicate returns #f. The routines named with three symbols < or > differ from those with two only by an additional parameter naming the location of the checks.

API

checker

checker sym .. ok? ....procedure

creates a checker routine, i.e. a unuary procedure, which returns its argument unchanged, provided it passes all ok? tests. If not, an error is generated with location sym, whose default is 'checker.

checker?

checker? xprprocedure

type predicate.

assert*

(assert* loc xpr . xprs)syntax

checks, if its arguments xpr . xprs are not #f.

named-lambda

(named-lambda (name . args) xpr . xprs)syntax

can be used in place of lambda, possibly improving error messages

<<<

(<<< loc arg arg? ...)syntax

Precondition test. Check a procedure argument, arg, against each predicate arg? ... in sequence and pass it to the procedure in case of success. loc names the location in the error message.

<<

(<< arg arg? ...)syntax

Precondition test. Check a procedure argument, arg, against each predicate arg? ... in sequence and pass it to the procedure in case of success.

>>>

(>>> loc result result? ...)syntax

Postcondition test. Check a return value of a function, result, against each predicate result? ...in sequence and return it in case of success. loc names the location in case of error.

>>

(>> result result? ...)syntax

Postcondition test. Check a return value of a function, result, against each predicate result? ...in sequence and return it in case of success.

<<<%

<<<% loc arg-name arg #!rest testsprocedure

Precondition test. Procedure version of <<<, arg needs to be named.

<<%

<<% arg-name arg #!rest testsprocedure

Precondition test. Procedure version of <<, arg needs to be named.

>>>%

>>>% loc result-name result #!rest testsprocedure

Postcondition test. Procedure version of >>>, result needs to be named.

>>%

>>% result-name result #!rest testsprocedure

Postcondition test. Procedure version of <<, result needs to be named.

true?

true? xprprocedure

always true

false?

false? xprprocedure

always false

checks

checksprocedure

checks symprocedure

with sym: documentation of exported symbol without sym: list of exported symbols

Examples

(import checks)

(checker? checkit)
;-> #t

(checker? checkme)
;-> #t

(checker? string?)
;-> #f

(checkit 5)
;-> 5

(checkme 5)
;-> 5

(condition-case (checkme -1) ((exn) #f))
;-> #f

(condition-case ((checker 'bar string?) 5) ((exn) #f))
;-> #f

(assert* 'x (integer? x))
;-> #t

(assert* 'x (integer? x) (odd? x))
;-> #t

(condition-case (assert* 'x (integer? x) (even? x)) ((exn assert) #f))
;-> #f

x
;-> 5

(>> x)
;-> 5

(<< x)
;-> 5

(>> x integer? odd?)
;-> 5

(>>% 'x x integer? odd?)
;-> 5

(<< x integer? odd?)
;-> 5

(<<% 'x x integer? odd?)
;-> 5

(<<< 'loc x integer? odd?)
;-> 5

(>>> 'loc x integer? odd?)
;-> 5

(<<<% 'loc 'x x integer? odd?)
;-> 5

(>>>% 'loc 'x x integer? odd?)
;-> 5

(condition-case (<<% 'x x integer? even?) ((exn argument) #f))
;-> #f

(condition-case (<<<% 'loc 'x x integer? even?) ((exn argument) #f))
;-> #f

(condition-case (>> x integer? even?) ((exn result) #f))
;-> #f

(<< ((lambda () #f)) boolean?)
;-> #f

((named-lambda (! n) (if (zero? n) 1 (* n (! (- n 1))))) 5)
;-> 120

Requirements

simple-exceptions

Last update

Feb 13, 2021

Author

Juergen Lorenz

Repository

This egg is hosted on the CHICKEN Subversion repository:

https://anonymous@code.call-cc.org/svn/chicken-eggs/release/5/checks

If you want to check out the source code repository of this egg and you are not familiar with Subversion, see this page.

License

Copyright (c) 2014-2021, Juergen Lorenz All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Version history

1.4

checkers added

1.3

dependency on simple-exceptions added

1.2

code cleaned

1.1.0

documentation of named-lambda fixed

1.1

procedure versions added

1.0

extracted and modified from simple-exceptions