#lang racket
(define (sublists lst k)
  (let ((curr lst)
        (size (length lst)))
    (lambda ()
      (if (< size k)
          'end
          (begin
            (let ((v (take curr k)))
              (set! size (- size 1))
              (set! curr (cdr curr))
              v))))))

(define (checklist lst factors)
  (let* ((k (length (car factors)))
         (iter (sublists lst k)))
    (foldl
     (lambda (x r)
       (let ((curr (iter)))
         (if (member curr (cons 'end factors))
             r
             (cons curr r))))
     '()
     lst)))

(checklist '(b b a a b b b c) '((a b) (b a) (b b)))

(define (test lst)
  (foldl
   (λ (r x)
     (cons x r))
   1
   lst))

(test '(2 3))


(define (co-sublist lst i j)
  (let loop ((p 0)
             (res '())
             (rem-lst lst))
    (cond
      ((null? rem-lst)
       res)
      ((or (< p i) (> p j))
       (loop (+ p 1)
             (append res (list (car rem-lst)))
             (cdr rem-lst)))
      (else  
       (loop (+ p 1)
             res
             (cdr rem-lst))))))

(define -> '->)
(define <- '<-)

(define (subl . args)
  (let loop ((state #f)
             (res '())
             (rem-lst args))
    (cond
      ((null? rem-lst)
       res)
      ((eq? (car rem-lst) '<-)
       (loop #f res (cdr rem-lst)))
      ((eq? (car rem-lst) '->)
       (loop #t res (cdr rem-lst)))
      (state
       (loop state (append res (list (car rem-lst))) (cdr rem-lst)))
      ((not state)
       (loop state res (cdr rem-lst))))))