[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.