little human like text searching program in scheme

I am trying to make little human like text searching program in scheme

but this program doesn't work properly time to time

and I can't catch the bug for many hours

could somebody tell me what's wrong with my code?

and is it not that good idea for searching text?

when I search the string "exp" in the text file which contain nothing but just string "explorer" error arise and it tells Found 0

(define (search str)
  (set! count 0)
  (define len (length str))
  ;null character calculating 
  (define data-len (- (length data) 1))
  ;when string length is less than or equal to data-length
  (when (and (not (= 0 len)) (>= data-len len))
    (define first-char (first str))
    (define last-char (last str))
    ;is it correct?
    (define (exact? str len index)
      (if (equal? str (drop (take data (+ index len)) index))
          #t
          #f))
    ;check first and last character of string if correct, check whether this string is correct completely, if so, skip to next index
    (define (loop [index 0])
      (when (> data-len 开发者_运维知识库index)
        (if (and (equal? first-char (list-ref data index)) 
                 (equal? last-char (list-ref data (+ index len -1))))
            (when (exact? str len index)
              (set! count (+ count 1))
              (loop (+ index len)))
            (loop (+ index 1)))))
    (loop))
  (send msg set-label (format "Found : ~a" count)))

---

I know it's been four years, but I'm nostalgic for my SCHEME class, so I made a thing. (I'd comment instead of answering, but I don't have enough reputation yet. ... And I'm probably about to have less.)

(define (find-pattern pat str); Returns a list of locations of PATturn in STRing.
  (define (pattern-found? pat-list str-list); Is the pattern (pat-list) at the beginning of this string (str-list)? Also, they're lists, now.
    (cond ((null? pat-list) #t); The base case for the recursion.
          ((null? str-list) #f); Obvious
          ((eq? (car pat-list) (car str-list)); First letter matches
           (pattern-found? (cdr pat-list) (cdr str-list))); Recurse
          (else #f)))
  (define (look-for-pattern pat-list str-list counter results-list)
    (cond ((null? str-list) results-list); Base case
          ((pattern-found? pat-list str-list)
           (look-for-pattern pat-list
                             (cdr str-list)
                             (+ counter 1)
                             (cons counter results-list)))
          (else (look-for-pattern pat-list
                                  (cdr str-list)
                                  (+ counter 1)
                                  results-list))))
  (look-for-pattern (string->list pat)
                    (string->list str)
                    0
                    '()))

EDIT: I mean it's been four years since the question, not since SCHEME class. That'd be a little creepy, but then again, who knows how I'll feel in three years?