Tag: Programming Language

Implementing vector-for-each in PLT

François asked how one might implement vector-for-each. Here are two solutions that were provided:
Matthias

#lang scheme
(define-syntax for-each-vector
  (syntax-rules ()
    ((for-each-vector proc vec ...)
     (let ((len (min (vector-length vec) ...)))
       (do ((index 0 (+ index 1)))
         ((= index len))
         (proc (vector-ref vec index) ...))))))
(for-each-vector
 (lambda (a b) (display (+ a b)))
 #( 1 2 3)  #( 1 2 3))
(newline)
;; functional, preferred
;; for-each-vector2
;; (All (A C ...) ((C ... -> A) (Vectorof C) ... -> A))
(define (for-each-vector2 p . vec)
  (for ((i (in-range (apply min (map vector-length vec)))))
    (apply p (map (lambda (v) (vector-ref v i)) vec))))
(for-each-vector2
 (lambda (a b) (display (+ a b)))
 #( 1 2 3)  #( 1 2 3))
(newline)

Sam TH

#lang scheme
(require srfi/43)
(for ([a #(1 2 3)] [b #(1 2 3)])
  (display (+ a b)))
(newline)
(vector-for-each
 (lambda (i a b) (display (+ a b)))
 #(1 2 3) #(1 2 3))

Differences between the Chez and Ikarus module systems

An R6RS library and a Chez top-level module have similarities: they both have bodies that contain variable and syntax definitions, some of which can be exported, and you can import one module into another. So, they’re similar on the surface. But there are major differences.
1. Outer scope
Chez modules exist in some environment (typically, in the interaction-environment, but that can change) that contains bindings that include the module keyword itself. The outer scope in the environment in which the module is expanded is visible inside the module (unless you restrict it using the import-only keyword). R6RS/Ikarus libraries do not exist in an environment: they are stand-alone entities with their own syntax and so on.
2. Expansion and Evaluation
Ikarus libraries are automatically expanded/compiled when you import them (thus, there’s a mapping from library names to some storage that contains libraries’ code). Chez modules are not associated with any storage: if you import a module and it doesn’t already exist in the environment, you get an error. This means that in Chez, it is your duty to ensure that modules are “loaded” before they are used. Now “loaded” is a loaded term as it implies all of “compiled”, “visited”, and “invoked” (or “revisited” in the Chez lingua). Moreover, the load, compile, visit, and revisit are operations that operate on files, not modules, (such files may contain any code, not just modules) and work by modifying the environment in which such files are loaded, compiled, visited, or revisted. Operations on libraries in Ikarus do not modify the environment since no environment is required for performing these operations. In short, you need to manage the phase dependencies (when files are loaded/compiled/visited/revisited) yourself so that compile-time and run-time information are available when needed.
Aziz,,,

(via Ikarus)

Why there is not restart exception handling in PLT Scheme

YC asked here[1]:

Is it possible to handle exceptions like Common Lisp, specifically restarts?
Scenario: undefined variables – handling by defining the variable, and continue past the exception.

Matthew explained what is and is not possible in the following threads here, here, and here.
[1]: PLT Scheme Mailing list, “restart exception handling?”, Thu Jul 10 17:35:57 EDT 2008

Hacking PLT to add a range syntax

Here is a post demonstrating how to add an infix range syntax to PLT Scheme.

[a .. b]  => (interval a b)
(... expr1 [expr2] ...) => (... (vector-ref expr1 expr2) ...)

Addendum: 04/20/09
Here is the final version of the code, with additional interesting syntax:

That includes:
[1 .. 4] short interval (1 to 3)
[1 … 4] long interval (1 to 4)
Curry with {}:
{+ _ 3} => (lambda (x) (+ x 3)
{+ _ (* 2 _)} => (lambda (x y) (+ x (* 2 y)))
This is convenient with map and filter:
(map {+ _ 3} [1 … 3]) => ‘(4 5 6)
Iota from SRFI 1:
[5] => (iota 5) => (0 1 2 3 4)
[5 3] => (iota 5 3) => (3 4 5 6 7)
[5 3 2] => (iota 5 3 2) => (3 5 7 9 11)
Lambdas:
{n -> (+ n 1)} is (lambda (n) (+ n 1)
And a very simple comprehension:
> [(+ n 3) : n is (< n 10) (even? n)] (3 5 7 9 11) > [(+ n 3) : n is (< n 10)] (3 4 5 6 7 8 9 10 11 12) > [(* n n) : n is (< n 10) (odd? n)] (1 9 25 49 81)

The PLT email list archive URLs have changed

The PLT Scheme email list archive URLs have changed. You can read all about it in this thread.
The result is that any links posted before this change was made are now broken.
Basically it is no one’s fault: not the PLT folks nor the sysadmins. The mailing list software reindexes messages in this breaking manner.
Nonetheless, now there are around 200 broken links on this site alone. I’m neither sure how to fix them automatically nor manually. Clearly the latter would be too time consuming.