Racket module boundaries and contract enforcement: retroactive wrapping of unannotated exports

Answer to the core question

Yes. Racket allows a module that imports an identifier to wrap it with a contract by using contract-out in the require clause. This does not modify the exporter’s interface; only the importer sees the contract.

(require (only-in mod foo)
         (contract-out foo (-> Number Number)))

The contract is enforced the first time the imported function is called. It is a runtime check, so there is a small overhead.

Default behavior in Racket 8.7+

Imported functions are not automatically wrapped. The contract must be declared explicitly either in the exporting module’s provide list or in the importer’s require clause. This has been stable since Racket 8.0 and remains unchanged in 8.7, 8.8, and later releases.

Keeping enforcement across unsafe modules

When an unsafe module sits between the exporter and the final consumer, it can re‑export the identifier without a contract, effectively bypassing checks imposed earlier. Two safe patterns exist:

• Apply contract-out at every boundary you control. Each module that re‑exports the identifier must add a contract-out in its require clause.
• Introduce a dedicated safe wrapper module. This module imports the unannotated export, applies contract-out, and re‑exports the wrapped value. All downstream modules then import this wrapper instead of the unsafe module.

Example chain:

// alpha.rkt (unannotated export)
(provide foo)
(define (foo x) (+ x 1))

// safe-wrapper.rkt
(require (only-in alpha foo)
         (contract-out foo (-> Number Number)))
(provide foo)

// consumer.rkt
(require safe-wrapper)
(foo 5)   ; OK
(foo "a") ; contract violation

If the unsafe module re‑exports foo without a contract, callers of that module will not see the check unless the wrapper is applied again at the next boundary.

Practical verification steps

1. Create alpha.rkt with the unannotated function as shown above.
2. Create safe-wrapper.rkt that uses contract-out and re‑exports foo.
3. In a REPL or a separate run.rkt file, require safe-wrapper and call (foo 5) – no error.
4. Call (foo "a") – you should see a contract violation trace originating from safe-wrapper.rkt.
5. Use racket -v consumer.rkt to see the full stack trace.

Key takeaways

• Use contract-out in the require clause to retroactively apply a contract.
• Imported functions are not auto‑wrapped in 8.7+; the contract must be declared explicitly.
• To keep enforcement intact, apply contract-out at each boundary you control or provide a dedicated safe wrapper module.
• Unsafe modules can bypass checks unless they also wrap the export.