Made it a module.

Put it in any directory, run guile -L . and then import (goof) in that directory.

example.scm

@@ -0,0 +1,9 @@
+(load "goof.scm")
+
+(define (erathostenes n)
+  (define vec (make-vector n #t))
+  (loop/list ((:for i (up-from 2 (to n)))
+              (:when (vector-ref vec i)))
+    (loop ((:for j (up-from (* 2 i) (to n) (by i))))
+      (vector-set! vec j #f))
+    i))

goof.scm

@@ -32,14 +32,50 @@
 ;; name, and the fact that I goofed in the chibi issue tracker when
 ;; trying to understand the iterator protocol.
 
-;; TODO add :let and :let* to forify
+(define-module (goof)
+  #:use-module (goof helpers)
+  #:use-module (goof ref-let)
+  #:use-module ((srfi srfi-1) #:select (circular-list))
+  #:use-module (srfi srfi-71)
+  #:use-module (rnrs io simple)
+  #:use-module (ice-9 futures)
+  #:export (loop
             
-(use-modules (helpers)
+            loop/list
-             (ref-let)
+            loop/sum
-             ((srfi srfi-1) #:select (circular-list))
+            loop/product
-             (srfi srfi-71)
+            loop/first
-             (rnrs io simple)
+            loop/last
-             (ice-9 futures))
+            loop/and
+            loop/or
+            loop/list/parallel
+            
+            :when :unless :break :final :let :let* :subloop :for :acc
+
+            in
+            in-list
+            in-lists
+
+            in-vector in-reverse-vector
+            in-string in-reverse-string
+
+            in-port
+            in-file
+            in-generator
+            up-from
+            down-from
+            accumulating
+            folding
+            listing
+            listing-reverse
+            appending
+            appending-reverse
+            summing
+            multiplying
+
+            in-cycle
+            in-indexed
+            ))
 
 (define-aux-syntaxes
   ;; Auxiliary syntax for the loop clauses
@@ -53,20 +89,20 @@
   )
 
 
-(include "iterators.scm")
+(include "goof/iterators.scm")
 
 
 
 (define-syntax loop
   (syntax-rules (=>)
     ((loop () => expr body ...)
-     (let () expr))
+     (loop ((:for ensure-once (up-from 0 1))) => expr body ...))
     ((loop () body ...)
-     (let () body ...))
+     (loop ((:for ensure-once (up-from 0 1))) body ...))
     ((loop name () => expr body ...)
-     expr)
+     (loop name ((:for ensure-once (up-from 0 1))) => expr body ...))
     ((loop name () body ...)
-     (if #f #f))
+     (loop name ((:for ensure-once (up-from 0 1))) body ...))
     ((loop (clauses ...)  body ...)
      (ensure-for-clause (loop (clauses ...) body ...)
                         loop-name (clauses ...)

goof/helpers.scm

@@ -1,4 +1,4 @@
-(define-module (helpers)
+(define-module (goof helpers)
   #:export (define-aux-syntax define-aux-syntaxes))
 
 (define-syntax define-aux-syntax

goof/ref-let.scm

@@ -1,4 +1,4 @@
-(define-module (ref-let)
+(define-module (goof ref-let)
   #:export (ref-let)
   #:use-module (ice-9 match)
   #:use-module (srfi srfi-71))