I can't really test what you've posted (no stress-testing code), and you also 
compare safe versus unsafe accessors, which skews things.

I wanted to follow up apologizing to anyone who tried to use my library. I had 
not tested it thoroughly enough and didn't realize it does not work outside its 
own module. I've since fixed this and added the documentation in markdown 
format (Scribble does some weird extra ```racket additions with markdown that I 
had to manually remove, too. Dunno what that's about).
-Ian
----- Original Message -----
From: "Pierpaolo Bernardi" <[email protected]>
To: "J. Ian Johnson" <[email protected]>
Cc: "Tim Nelson" <[email protected]>, "users" <[email protected]>
Sent: Monday, March 25, 2013 10:42:28 AM GMT -05:00 US/Canada Eastern
Subject: Re: [racket] for/hash and for/list: adding nothing, adding more than 
one thing

On Mon, Mar 25, 2013 at 2:41 PM, J. Ian Johnson <[email protected]> wrote:
> Let me know how you like my library. I'm thinking of adding some more 
> ergonomics to it:
> 1) support right folds so a for/list-like comprehension has better allocation 
> behavior.
> 2) add a keyword for-clause for starting an inner iteration so you don't have 
> to do this:
> (for ([e0 (in-list l0)]
>       [e1 (in-list l1)])
>   (for ([e2 (in-list l2)]
>         [e3 (in-list l3)])
>     ...body...))
> but instead you can do this:
> (for ([e0 (in-list l0)]
>       [e1 (in-list l1)]
>       #:start-inner-loop ;; suggest a better name please
>       [e2 (in-list l2)]
>       [e3 (in-list l3)])
>   ...body...))

IMHO the first form is clearer.  I don't see any gain in the second one.

> I seem to remember that for* is not equivalent to successive nesting of for 
> forms, but I can't remember how I reached this conclusion.

I have found, in one case, that performance of nested fors is
significantly better than a single for*, but I have not investigated
the cause. See the code fragment below.

Cheers
P.

(define (risolvi-2 sexomini)
  (let ((tabella (crea-tabella)))
    (let fansexomino ((sexomini sexomini))
      (cond ((null? sexomini)
             (eureka tabella))
            ((posizione-accettabile? tabella sexomini)
             (let ((sexomino (unsafe-first sexomini)))
               (for ((orientazione (in-list sexomino)))
                 (let ((forma (unsafe-first orientazione)))
                   (for ((posizione (in-list (unsafe-rest orientazione))))
                     (when (compatibile? forma posizione tabella)
                       (let* ((x (posizione-x posizione))
                              (y (posizione-y posizione))
                              (v (unsafe-vector-ref tabella x)))
                         (unsafe-vector-set! v y forma)
                         (fansexomino (unsafe-rest sexomini))
                         (unsafe-vector-set! v y #f))))))))))))

#|
;; risolvi-2 is faster
(define (risolvi-3 sexomini)
  (let ((tabella (crea-tabella)))
    (let fansexomino ((sexomini sexomini))
      (cond ((null? sexomini)
             (eureka tabella))
            ((posizione-accettabile? tabella sexomini)
             (for* ((sexomino (in-value (first sexomini)))
                    (orientazione (in-list sexomino))
                    (forma (in-value (first orientazione)))
                    (posizione (in-list (rest orientazione)))
                    #:when (compatibile? forma posizione tabella)
                    (x (in-value (posizione-x posizione)))
                    (y (in-value (posizione-y posizione)))
                    (v (in-value (vector-ref tabella x))))
               (vector-set! v y forma)
               (fansexomino (rest sexomini))
               (vector-set! v y #f)))))))
|#
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Reply via email to