~nytpu/dbc-scheme

586b717ab97dfe406787c8657289cf40536e601d — nytpu 1 year, 9 months ago
update documentation

2 files changed, 20 insertions(+), 19 deletions(-)

M contracts.scm
M contracts.sld

M contracts.scm => contracts.scm +13 -18
@@ 19,13 19,6 @@
l1 l2))

-;; Transform a series of expressions into a list of \scheme{quote}d
-;; expressions.
-(define-syntax quotify
-  (syntax-rules ()
-    ((_ q ...)
-     (list (quote q) ...))))
-
;; \scheme{verify-contracts} will verify that a series of expressions returns
;; true, otherwise raising an exception with the quoted representation of the
;; expression that failed.

@@ 38,8 31,7 @@
;;     them return true.
;;   }
;;   \item{
-;;     Given a series of thunk expressions, verify that all of them return
-;;     true.
+;;     Given a series of expressions, verify that all of them return true.
;;   }
;; ]
(define-syntax verify-contracts

@@ 50,28 42,28 @@
(let ((return r))
(if (execute-contracts (list (delay (c1 return))
(delay (c2 return)) ...)
-                              (quotify c1 c2 ...)
+                              (list (quote c1) (quote c2) ...)
"postcondition assertion violation"
return)
return
#f)))
((_ c1 c2 ...)
(execute-contracts (list (delay c1) (delay c2) ...)
-                        (quotify c1 c2 ...)
+                        (list (quote c1) (quote c2) ...)
"precondition assertion violation"))))

;;> Define a lambda expression as with \scheme{lambda}, however add
;;> precondition and/or postcondition contracts.
;;>
;;> Given a \scheme{(pre contracts ...)}, where \var{contracts ...} is zero
-;;> or more thunk expressions, evaluate each thunk sequentially in the same
-;;> scope as the function body.  If a thunk returns \scheme{#f}, then raise
+;;> or more expressions, evaluate each thunk sequentially in the same scope
+;;> as the function body.  If an expression returns \scheme{#f}, then raise
;;> an exception noting a precondition violation with the irritants being the
-;;> (\scheme{quote}d) thunk that failed.
+;;> (\scheme{quote}d) expression that failed.
;;>
;;> Given a \scheme{(post contracts ...)}, where \var{contracts ...} is zero
;;> or more predicate functions taking a single argument, evaluate each
-;;> expression sequentially given the return value of the function; in the
+;;> contract sequentially given the return value of the function; in the
;;> same scope as the function body and after the function has completed
;;> evaluation.  If a predicate returns \scheme{#f}, then raise an exception
;;> noting a postcondition violation with the irritants being the expression

@@ 82,11 74,14 @@
;;> fails.  As such, it is recommended to have contracts sorted from most
;;> general to most specific.
;;>
+;;> A continuation captured within the function will include the
+;;> postcondition checks.
+;;>
;;> \bold{Example:}
;;>
;;> \schemeblock{
+;;>     (lambda-contract lists
;;>       (pre (every list? lists)
;;>            (>= (length lists) 2)
;;>            (apply = (map length lists)))

@@ 126,7 121,7 @@
(lambda formals e1 e2 ...))))

;;> Define a top-level function binding as with \scheme{define}'s "defun"
-;;> syntax, however use \scheme{lambda-contract} instead of a regular lambda.
+;;> syntax, with the addition of precondition and/or postcondition contracts.
;;>
;;> The semantics of the pre- and post-conditions is equivalent to
;;> \scheme{define-lambda.}

@@ 142,7 137,7 @@
;;>           (lambda (ret) (= (length ret) (length (car lists)))))
;;>     (apply map + lists))
;;> }
-;;> The above is equivalent to:
+;;> is equivalent to:
;;> \schemeblock{
;;>     (lambda-contract lists


M contracts.sld => contracts.sld +7 -1
@@ 4,7 4,13 @@

-;;> TODO
+;;> Design-by-Contracts for R7RS Scheme.
+;;>