[racket] syntax, differently

Within 80 columns (not counting the startiong comment.
Hope your mailer does not insert or remove line-breaks.

#lang racket
;; <NOT TELLING OTHERS> : state -> (listof state) ;; given a state, compute
all possible successor states that can be reached in one boat crossing

(define (compute-possible-states state)
  (local
    [;; how-many : symbol bl -> number
     ;; to find out how many s are in a bl
     (define (how-many s bl)
       (cond
         [(empty? bl) 0]
         [else
          (cond
            [(symbol=? s (first bl))
             (+ 1 (how-many s (rest bl)))]
            [else (how-many s (rest bl))])]))
     ;; possible-states accumulate all the possible (an many incorrect)
     ;; future boat loads, given the current state.
     (define (compute-a boat-loads possible-states)
       (cond
         [(empty? boat-loads) possible-states]
         [else
          (local
            [(define num-missionaries (how-many 'M (first boat-loads)))
             (define num-cannibals (how-many 'C (first boat-loads)))
             (define (new-state op1 op2 boat-posn)
               (make-state
                (op1 (state-ml state)
                     num-missionaries)
                (op1 (state-cl state)
                     num-cannibals)
                (op2 (state-mr state)
                     num-missionaries)
                (op2 (state-cr state)
                     num-cannibals)
                boat-posn))
             (define logical-boat-move
               (cond
                 [(symbol=? (state-boat-posn state) 'left)
                  (new-state - + 'right)]
                 [else (new-state + - 'left)]))]
            (compute-a (rest boat-loads)
                       (cons logical-boat-move possible-states)))]))]
    (compute-a BOAT-LOADS empty)))

Jos 

> -----Original Message-----
> From: users-bounces at racket-lang.org 
> [mailto:users-bounces at racket-lang.org] On Behalf Of Horace Dynamite
> Sent: 02 August 2010 16:14
> To: Marco Morazan; users at racket-lang.org
> Subject: Re: [racket] syntax, differently
> 
> On Mon, Aug 2, 2010 at 2:02 PM, Marco Morazan 
> <morazanm at gmail.com> wrote:
> > Perhaps, you should consider making separate functions for 
> each nested 
> > cond and nested local. There is nothing "easy to read" 
> about code with 
> > the shape above. One cond and one local per function is a 
> good rule of 
> > thumb.
> 
> Point taken, perhaps that was a poor example. Let me make 
> clear that I wasn't trying to say that I ran into this 
> 80-column "limit" often working HtDP, but there were 
> occasional times when I felt it was necessary to break this. 
> I've copied one such instance from a HtDP exercise below.
> 
> > This the is the negative side of this, but the positive is 
> that there 
> > are lots of things that computers can help people do when 
> it comes to 
> > learning (eg, executing your program at all!). We should do 
> our best 
> > to exploit the computer's power to deal with mundane things 
> (instead 
> > of putting that burden on instructors/students).
> 
> I do bow down to the people here having a lot more experience 
> with these issues than I have, but I just find this statement 
> a little weird with respect to the whole line-length limit 
> debacle. As well as program execution, DrRacket's Stepper in 
> the early teaching languages was so helpful to me. Of course 
> I wouldn't want to do a hand-evaluation in favor of freeing 
> the burden on the computer.
> 
> But if something pisses you of when you're using the Stepper 
> for example, thats because you don't know why you're program 
> is wrong (e.g.), and now you have to go develop a headache 
> figuring out whats the matter. Whereas if the "auto-magic 
> line-breaker v 1.0" snaps your line when you really don't 
> want it to, that pisses you off for the wrong reasons. It's 
> an arbitrary decision made on your behalf because the 
> computer thinks its smarter than it really is.
> 
> I suppose what I'm butchering here in trying to say is that 
> readers/compilers/debuggers for e.g., while they may be very 
> hairy and complicated to implement, with more than one way to 
> do them, they seem very rigid and omnipotent when you're 
> using them as a novice. Whereas something like line-breaking 
> seems very loose, personal and condition-dependent. Perhaps 
> as a comprise for students who do listen, (and in my class in 
> the UK, most students do! I'm by no means the best at all re. 
> Matthias' comment) have the line breaker default if you must 
> have it all, but on the first couple of runs, there should be 
> a very obvious way to tell it where to go.
> 
> Here is a part of my solution to an exercise in HtDP that 
> breaks the line limit, and I don't think I'm being overly 
> stupid in how I've done it,
> 
> ;; <NOT TELLING OTHERS> : state -> (listof state) ;; given a 
> state, compute all possible successor states that can be 
> reached in ;; one boat crossing (define 
> (compute-possible-states state)
>   (local [;; how-many : symbol bl -> number
>           ;; to find out how many s are in a bl
>           (define (how-many s bl)
>             (cond [(empty? bl) 0]
>                   [else (cond [(symbol=? s (first bl))
>                                (+ 1 (how-many s (rest bl)))]
>                               [else (how-many s (rest bl))])]))
>           ;; possible-states accumulate all the possible (an many
> incorrect) future
>           ;; boat loads, given the current state.
>           (define (compute-a boat-loads possible-states)
>             (cond [(empty? boat-loads) possible-states]
>                   [else (local [(define num-missionaries 
> (how-many 'M (first boat-loads)))
>                                 (define num-cannibals 
> (how-many 'C (first boat-loads)))
>                                 (define (new-state op1 op2 boat-posn)
>                                   (make-state (op1 (state-ml state)
> num-missionaries)
>                                               (op1 (state-cl state)
> num-cannibals)
>                                               (op2 (state-mr state)
> num-missionaries)
>                                               (op2 (state-cr state)
> num-cannibals)
>                                               boat-posn))
>                                 (define logical-boat-move
>                                   (cond [(symbol=? (state-boat-posn
> state) 'left)
>                                          (new-state - + 'right)]
>                                         [else (new-state + - 
> 'left)]))]
>                           (compute-a (rest boat-loads)
>                                      (cons logical-boat-move 
> possible-states)))]))]
>     (compute-a BOAT-LOADS empty)))
> 
> The longest line here is 90 characters, and breaking it would 
> be very annoying. Further, this pattern isn't wacky, 
> considering I'd just read the accumulation section in HtDP.
> 
> Horace.
> _________________________________________________
>   For list-related administrative tasks:
>   http://lists.racket-lang.org/listinfo/users