I saw the earlier question relating to map (bit over my head
for the moment) but the person didn't appear to be asking
the same thing (but then he might have - ignorance, don't
leave home without it).

I'm able to use map, foldl and foldr on fairly simple things
where just param is involved.  I get lost when two or more
params are used.  Firstly, aside from looking at something
and thinking "this looks like map or foldl would do just
nicely", I'm uncertain about HOW to do it.  In hindsight,
probably WHEN to do it too.

Here is a very simple problem where I *think* map and
perhaps foldl might work (and I'm probably wrong).  It's a
problem in which items contained in a reference list (of
strings) match some predicate and I want to list, for each
matched item, a string that includes the matched item in
context with the adjacent 2 string items (string append 2
items in front and 2 behind the matched item).

The desired result would look something like this when an
item needs 2 adjacent items to produce the desired context,
on a list of indices '(1 2 5)
("a b c" "a b c d" "c d f")

Three matches - three contexts.  Can't place items in front
of the first item in the reference list and can't place
items after the last item in a reference list.

This is how I would go about it - please feel free to adjust
my approach if it is crap.

Produce a list of indices representing the beginning of the
context string.
Produce a list of indices representing the end of the
context string.
Loop through the list of 'beginning' indices
   string append the result of (list-ref a-list an-index)
   if not the last item then add a space " " (to avoid
having a trailing space)
   until the value for the beginning index equalled the
value of the correspond end index

That works but seems messy.  This process may be one that
could be mapped perhaps?  Here is what I've done so far:

x = the number context items
y = index of the matched item (from a list of strings)
z = is the max index of the reference list
d = reference list (document)

(define d (list "a" "b" "c" "d" "e" "f"))
(define z (- (length d)  1)); 0 base index

; get a list of the starting indiced
(define (front-ndx x)
  (define (front-ndx-helper y)
    (if (<= 0 (- y x))
        (- y x )
        (front-ndx-helper (+ y 1))))
    front-ndx-helper)
(define first-ndx (front-ndx 2))

(map first-ndx (list 1 2 4 6)); ==> (0 0 2 4) correct answer

(define (end-ndx x ) ; x is the number of contex words
  (define (end-ndx-helper y ) ; y is the index of a matched
word, z is doc-length
    (if (<= (+ x y) z  )
        (+ x y)
        (end-ndx-helper (- y 1) )))
  end-ndx-helper)
(define last-context (end-ndx 2 ) );

(map last-context  (list 1 2 4 6) ) ;  ==> (3 4 5 5) correct
answer

OK - so I was able to use map but it feels as if I cheated
in the end-ndx procedure because I defined a third param (z
the max index value) externally.  Or was this the 'right'
way to go about this?

The next step would be to map a procedure to construct the
context string.  Now, in the examples that I've seen with
foldl (numbers) it seems that maybe this problem would not
be suitable to that procedure?

I'm lost here.

The code (below) does the job fine and seemingly with far
less effort, but doesn't use map and is essentially basic.
How might you go about solving this?  And what is it about
the problem that would lead you to think that map (or foldl
perhaps) are 'good' in this context?  Trying to get into
your thought processes.

Hope all of this was clear.

Any suggestions / ideas - most welcome.

Kindest regards,

maps and folds are indeed not all there is.

I offer here a different approach on your problem, using
a map-like procedure directly: move a window of length
five over a sequence, apply a given procedure to the
elements of each such window, and collect the results in
a list. The following implementation is too simple;
write a tail-recursive helper yourself to collect the
values in reverse order, if you like.

(define (five make them)
   (if (< (length them) 5)
       '()
       (help make
             (list-ref them 0)
             (list-ref them 1)
             (list-ref them 2)
             (list-ref them 3)
             (list-ref them 4)
             (list-tail them 5))))

(define (help make h0 h1 h2 h3 h4 rest)
   (cons (make h0 h1 h2 h3 h4)
         (more make h1 h2 h3 h4 rest)))

(define (more make h1 h2 h3 h4 rest)
   (if (null? rest)
       '()
       (help make h1 h2 h3 h4 (car rest) (cdr rest))))

Use like so:

(five string (string->list "supercilious"))
==>
("super" "uperc" "perci" "ercil" "rcili" "cilio" "iliou" "lious")

For keeping only the windows of interest, one could modify
the procedure FIVE to also take a filter procedure, or one
can filter the list of results afterwards:

(define (vowely a b c d e)
   (and (memv c '(#\e #\i #\o))
        (string a b c d e)))

(five vowely (string->list "supercilious"))
==>
(#f "uperc" #f #f "rcili" #f "iliou" "lious")

(keep values (five vowely (string->list "supercilious")))
==>
("uperc" "rcili" "iliou" "lious")

The filtering procedure KEEP here is again too simple to
be good. The standard fix is again to collect in reverse
order.

(define (keep cond them)
   (if (null? them)
       '()
       (if (cond (car them))
           (cons (car them) (keep cond (cdr them)))
           (keep cond (cdr them)))))

My instinct is to just miss the windows at beginning and
end where too little context is available. Change FIVE
to take a filler parameter if you want them, maybe.