如何在Racket程序中合规使用可移植R7RS Scheme库？

Absolutely! You’ve hit on the right approach with separating your portable core from Racket-specific glue code—this is exactly the standard way to handle cross-Scheme compatibility while supporting Racket. Let’s break this down step by step:

Your plan to keep the library’s core logic in a pure R7RS .scm file, then wrap it with a Racket-specific .rkt file using #lang r7rs, is perfect. This keeps your core code usable by any R7RS-compliant Scheme implementation, while giving Racket the context it needs to load the library properly.

Here’s a concrete example:

• Portable core file (my-portable-lib.scm): No Racket-specific code, just pure R7RS:

  ;; my-portable-lib.scm (100% R7RS compatible)
  (define (greet name)
    (string-append "Greetings, " name "!"))
  
  (define (square x)
    (* x x))
  

• Racket adapter file (my-lib.rkt): Acts as a bridge for Racket, using #lang r7rs to enable R7RS mode and load your core:

  #lang r7rs
  (import (scheme base))
  ;; Load the portable core
  (include "my-portable-lib.scm")
  ;; Export the functions so Racket can use them
  (provide greet square)
  

• Using it in a Racket program:

  #lang racket/base
  ;; Import the adapter file
  (require "my-lib.rkt")
  (greet "Racket") ; Outputs "Greetings, Racket!"
  (square 5)       ; Outputs 25
  

Other Scheme implementations (like Guile, Chibi-Scheme, or Chicken) can ignore the .rkt file entirely and load the .scm file directly, no compatibility issues.

Good news: Racket’s #lang r7rs fully supports the R7RS standard .sld library definition format. This is a more structured alternative to plain .scm files for organizing libraries, and it works seamlessly in Racket.

Example .sld file (my-lib.sld):

(define-library (my utils)
  (export greet square)
  (import (scheme base))
  (begin
    (define (greet name)
      (string-append "Greetings, " name "!"))
    (define (square x)
      (* x x))))

To use this in Racket:

• In an R7RS-specific file:

  #lang r7rs
  (import (my utils))
  (greet "R7RS")
  

• In a standard Racket program:

  #lang racket/base
  ;; First enable R7RS support
  (require r7rs)
  ;; Import the .sld library
  (require (file "my-lib.sld"))
  (square 7)
  

Racket will automatically parse the .sld file’s R7RS library definition when loaded in R7RS mode.

To keep your library robust across implementations:

• Stick strictly to R7RS in core code: Avoid implementation-specific syntax (like Racket’s define-syntax-rule; use R7RS’s define-syntax with syntax-rules instead) and rely on standard SRFIs for extra functionality when possible.
• Use cond-expand for unavoidable differences: If you need to handle implementation-specific logic, use the R7RS-standard cond-expand form:

  (cond-expand
    (racket (require racket/list))
    (guile (use-modules (srfi srfi-1)))
    (else (error "Unsupported Scheme implementation")))
  

• Test across implementations: Validate your core .scm or .sld file with multiple R7RS-compliant Schemes (Chibi, Guile, Chicken with R7RS support) to catch edge cases.
• Avoid hardcoded paths: In Racket, use relative paths or configure library search paths with (current-library-collection-paths) to make loading more flexible.

内容的提问来源于stack exchange，提问作者Lassi