[racket] An example of let-vs-define: SICP 2.64

[Danny Yoo]

I was just looking at exercise 2.64 of SICP, one that creates a BST out of an ordered list of elements:

    http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-16.html#%_thm_2.64

However, because of all the nested lets, I have to admit that I was having a hard time reading it!

So I rewrote it with the Racket style guidelines in mind http://www.ccs.neu.edu/home/matthias/Style/style/Choosing_the_Right_Construct.html#(part._.Definitions)

The rewritten code is:

    https://gist.github.com/4004224

with the following changes:

  1. Rewrote the packing/unpacking of 2-tuple lists in partial-tree with multiple values.

  2. Replaced nested lets with defines.

  3. Reordered some of the variables definitions to highlight relationships.

I thought the function itself was neat, and just wanted to share.

[Matthias Felleisen]

I guess we should take this also as a confirmation of the style guide :-)

> ____________________
> Racket Users list:
> http://lists.racket-lang.org/users

[Grant Rettke]

Internal define is awesome.

--
Grant Rettke | ACM, AMA, COG, IEEE
gre...@acm.org | http://www.wisdomandwonder.com/
Wisdom begins in wonder.
((λ (x) (x x)) (λ (x) (x x)))

[Sam Tobin-Hochstadt]

On Fri, Nov 2, 2012 at 5:29 PM, Grant Rettke <gre...@acm.org> wrote:
> Internal define is awesome.

I agree in general, but I did recently fix a bug in Typed Racket that
was made possible entirely by use of internal `define`:
https://github.com/plt/racket/commit/0e71f2d5dc#L1R16

The original code had a `let`, which I changed to define, and then
renamed a variable, leading to a bug that would have been caught with
let, but instead produced an infinite loop in some cases with internal
define.

Just a cautionary tale,
Sam

[Grant Rettke]

On Fri, Nov 2, 2012 at 4:33 PM, Sam Tobin-Hochstadt <sa...@ccs.neu.edu> wrote:

Just a cautionary tale,+++

Good point. Thanks for sharing. 

[Neil Van Dyke]

Here's a different comparison of let-vs-internal-define, using your code.

Your internal define example (hopefully whitespace doesn't get mangled
by however you're reading this message):

(define (partial-tree elts n)
(cond [(= n 0)
(values EMPTY-TREE elts)]
[else
(define left-size (quotient (- n 1) 2))
(define-values (left-tree non-left-elts)
(partial-tree elts left-size))

(define this-entry (first non-left-elts))

(define right-size (- n (+ left-size 1)))
(define-values (right-tree remaining-elts)
(partial-tree (rest non-left-elts) right-size))

(values (tree this-entry left-tree right-tree)
remaining-elts)]))

Simply transliterated to a let syntax, and with a more readable zero
test (which you'd need a "begin" to do with internal define, incidentally):

(define (partial-tree elts n)
(if (zero? n)
(values empty-tree elts)
(let* ((left-size (quotient (- n 1) 2))
((left-tree non-left-elts) (partial-tree elts left-size))
(this-entry (first non-left-elts))
(right-size (- n (+ left-size 1)))
((right-tree remaining-elts) (partial-tree (rest
non-left-elts)
right-size)))
(values (tree this-entry left-tree right-tree)
remaining-elts))))

Which is better is subjective, but in the "let" example, I can instantly
see that there is an ordered sequence of bindings, and what the names
are, in a visually regular format.

In the define example, I have to first see that there's an extent
consisting solely of a bunch of define forms in it with no non-define
code hidden, then look for the names, then examine the code for ordering
(e.g., are there recursive/forward references?), and tread carefully so
that I don't get scrod by a toplevel-like idiosyncrasy.

This is a simple example. I think let can sometimes win slightly more
when the examples get more complicated. (And there are other examples,
such as with huge nested definitions, in which I sometimes think
internal define might be more readable, but overall I usually find let
to be more readable.)

In summary: You can make "let*-values" be unnecessarily awkward, and you
can cherry-pick throwaway problem set code from SICP, and you can tell
people they have to type ugly square brackets when they don't, but the
people of Let will not be intimidated! Long live Let! :)

Neil V.

[Greg Hendershott]

In general I love internal define and have been using it heavily.

After the initial infatuation, I still love it. I've also come to
appreciate that sometimes let can be clearer. I like having the
choice.

Another way internal define can bite you is if you're not real crisp
on your understanding of certain forms with optional parts. For
instance syntax-case clauses. Let's say I have a friend (ahem) who
didn't really grok the optional guard/fender part, but that hadn't
mattered when writing stuff like:

(syntax-case stx ()
[(_ my pattern)
(let ([id rhs])
#'(my template))])

One day tries:

(syntax-case stx ()
[(_ my pattern)
(define id rhs)
#'(my template)])

This friend of mine (cough) was confused for awhile before figuring it out.

Of course the primary problem here is me^H^H my friend didn't know
this aspect of syntax-case clauses. I'm just saying that switching
from let to define can flush out some misunderstandings. Shrug.

[Matthias Felleisen]

That happens to the best and worst of us. I switch among
syntax-rule, syntax-rules, syntax-case, and syntax-parse.
I have made the same mistake as your friend.