[plt-scheme] HTDP 12.4.2

I should have said  (????? sym (first alow)) where ????? is a function that 
inserts sym into every position in a word and heretofore i will name 
interperse  (instead of infiltrate - more appropriate).


The full definition is

(define (insertEverywhere sym alow)
  (cond
    [(empty? alow) empty]
    [else (append (interperse sym (first alow))
                  (insertEverywhere sym (rest alow)))]
    )
  )

Now I can't see a way to write interperse with the design recipe used so 
far.

;CONTRACT
;interperse : symbol word - list-of-words
; produces a list of words by interpersing symbol into each position in word 
(including before and after)
;
;EXAMPLES
;(interperse 'd (list 'e 'r)  gives
;(list (list 'd 'e 'r)
;       (list 'e 'd 'r)
;       (list 'e 'r 'd))

;(interperse d empty) gives empty
;(intereperse d 'x) gives (list (list 'd 'x)
;                               (list 'x 'd))
;
;TEMPLATE
;(define (interperse sym word)
;   (cond
;      [(empty? word) ....]
;      [else ....sym ... (first word)
;                        (interperse sym (rest word))]
;    )
;  )

It still looks to me that I will need some auxiliary function similar to 
what I did with the original infiltrate though (split the word into 2 parts 
and generate words by inserting symbol between each respective split 
combination.




----Original Message Follows----
From: Danny Yoo <dyoo at hkn.eecs.berkeley.edu>
To: wooks wooks <wookiz at hotmail.com>
CC: plt-scheme at list.cs.brown.edu
Subject: Re: [plt-scheme] HTDP 12.4.2
Date: Thu, 22 Jun 2006 20:47:44 -0700 (PDT)



On Thu, 22 Jun 2006, wooks wooks wrote:

>
>So, if we are holding onto:
>
>   (list (list 'd 'r 'e)
>         (list 'r 'd 'e)
>         (list 'r 'e 'd))
>
>and we want to mess with it enough so we get:
>
>    (list (list 'd 'e 'r)
>          (list 'e 'd 'r)
>          (list 'e 'r 'd)
>          (list 'd 'r 'e)
>          (list 'r 'd 'e)
>          (list 'r 'e 'd))
>
>do you see what the difference between what we're holding onto and what we 
>want is?  Can you give a concept or name to it?
>
>
>The difference is (first alow) - Right.


Hi Wooks Wooks,

I'm not quite sure if we've done that mind meld thing yet, where we both are 
sharing the same thoughts.  *grin* Can you be more specific?


How can (first alow), which is going to be the list

          (list 'e 'r)

then account for the difference between:

    (list (list 'd 'r 'e)
          (list 'r 'd 'e)
          (list 'r 'e 'd))



which is what we have on hand, and the result that we really want to get 
back:

    (list (list 'd 'e 'r)
          (list 'e 'd 'r)
          (list 'e 'r 'd)
          (list 'd 'r 'e)
          (list 'r 'd 'e)
          (list 'r 'e 'd))

I'm not saying that it isn't, but that if we're going to say that it is, we 
have to fill in a few more ...'s till we can tell the non-thinking computer 
how to do what we think we mean.



That is, recalling that portion of the template we were looking at earlier,

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     [else ... sym ... (first alow) ...
           ... (insertEverywhere sym (rest alow)) ...]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

and knowing what the expected return value is now, can you think of how to 
complete the definition now?



If not, one way to make things easier is to fill the template will concrete 
values, based on the test case you worked out, and see if that will help:

     (... sym ... (first alow) ...
          ... (insertEverywhere sym (rest alow)) ...)

==>

     (... 'd  ... (list 'e 'r) ...
          ...  (list (list 'd 'r 'e)
                     (list 'r 'd 'e)
                     (list 'r 'e 'd)) ...)

Does this help?


Note that the steps we've done haven't been particularly brilliant.  One 
could rephrase the steps we're doing here as:

     1.  Shaping the general program pattern.
     2.  Cooking up simple test cases.
     3.  Mixing in those test case situations into the pattern.

We aren't aren't doing anything that couldn't be really codified in some 
strategy, some... well, let's call this thing a "design recipe" for lack of 
a better term.  *wink*