[racket] Looking for better designs to learn principles.

How about

(define print-two
  (match-lambda
    [(list* a b rest)
     (print a)
     (print b)
     rest]))

?

On 03/12/2015 06:25 PM, Don Green wrote:
> ;Design A:
> ;Rating: 1 out of 10
> ;Poor because it uses set!
> (define print-two
>   (lambda (f)
>    (print (first f))
>    (set! f (rest f))
>    (print (first f))
>    (set! f (rest f))
>    f))
> 
> (void (print-two '(1 2))) ;=> 12
> ;-------------------------
> ;Design B:
> ;Rating: 2 out of 10
> ;Better because it nests expressions to avoid using set!
> ;Poor because it less readable.
> (define print-two
>   (lambda (f)
>     (print (first f))
>     (print (first (rest f)))
>     f))
> 
> (void (print-two '(1 2))) ;=> 12
> When called in situations that allow one expression only, enclose call
> within a 'begin' expression.
> ;-------------------------
> ;Design C:
> ;Rating: 3 out of 10
> ;Is this an even better design because it is more readable than nesting
> expressions as in Design B above?
> (define (print-two f)
>   (let* ([_ (print (first f))]
>          [f (rest f)]
>          [_ (print (first f))]
>          [f (rest f)])
>     f))
> (void (print-two '(1 2))) ;=> 12
> ;-------------------------
> My questions are:
> "Can you recommend a better method?"
> "Can you recommend a better method using 'define with lambda'?"
> "Does your better method use a macro?"
> "Does your better method use a thread-through macro?"  If so, could you
> please provide the definition of the thread-through macro.
> THANKS!
> 
> 
> 
> ____________________
>   Racket Users list:
>   http://lists.racket-lang.org/users
>