Add Argument Contracts to a Racket Function

Problem and useful takeaway

A Racket procedure that receives a string where it expects a number may propagate the bad value through several calculations before failing, or worse, return an incorrect result without any error. The useful takeaway is to declare a contract at the function boundary so invalid arguments raise exn:fail:contract immediately, with a message that names the offending argument and the expected contract.

Prerequisites

• Racket installed, with racket and raco on PATH.
• A source file that begins with #lang racket.
• A text editor to modify the file.

Procedure: add a contract to a function

1. Open geometry.rkt (replace with your file name) and add (require racket/contract) after the language line.
2. Change define to define/contract.
3. Write a function contract with ->: list domain contracts for the arguments, then the range contract for the result.
4. Save the file and load it in racket.

A flat contract such as positive? accepts a value and returns #t or #f. The -> combinator builds a function contract: every argument must satisfy its domain contract, and the result must satisfy the range contract.

#lang racket
(require racket/contract)

(define/contract (circle-area radius)
  (-> positive? real?)
  (* pi radius radius))

Expect these results when you interact with the loaded module:

• (circle-area 3) returns a number.
• (circle-area -1) raises exn:fail:contract because -1 fails positive?.
• (circle-area "three") raises exn:fail:contract because a string is not a real number.

Expected checks

1. Run racket geometry.rkt in the directory that contains the file. Required permissions are read access to the file and execute access to the Racket binary.
2. Call the function with a valid argument and confirm it returns a numeric result, not an exception.
3. Call the function with an invalid argument and confirm an exception is raised instead of a wrong number.
4. Wrap a risky call in with-handlers for exn:fail:contract and confirm the handler runs instead of an uncaught exception.

(with-handlers ([exn:fail:contract
                 (lambda (exc)
                   (displayln "Contract violation caught:")
                   (displayln (exn-message exc)))])
  (circle-area -1))

Recovery options

• Catch violations at the boundary with with-handlers when input comes from users or external files.
• Relax the contract: replace positive? with real? if zero should be accepted.
• Temporarily remove the contract during debugging by changing define/contract back to define and removing (require racket/contract) if it is no longer used. Restore the contract before sharing or committing the code.

Limitations and practical verification

• Contracts add runtime overhead on every crossed boundary. Avoid wrapping functions inside tight numeric loops unless the validation cost is acceptable.
• Internal recursive calls can bypass the wrapper. If a contracted function calls itself by its internal name, recursive calls skip the contract. Call through the public binding or contract the recursive helper separately.
• Contract messages can expose argument values. Do not apply contracts that log or display secrets in production contexts.
• Exact exception wording may vary by Racket release. Test for the exn:fail:contract exception class rather than a specific message string.

Practical verification: load the module, call (circle-area 1) and confirm it returns pi. Then call (circle-area -1) and confirm the exception class is exn:fail:contract. If no exception appears, the contract wrapper was not applied or the call bypassed it.

Rollback

Adding a contract changes runtime behavior. To roll back, edit the source file, replace define/contract with define, remove (require racket/contract) if no other contract remains, save, and reload the module. The function then accepts any argument without validation.