cartesian.rkt

#lang racket

(require racket/match)
(require racket/stream)

(define (for-each-cartesian-product lol fn)
  (match lol
    ['() (fn '())]
    [(cons hd tl)
     (for [(elem hd)]
       (for-each-cartesian-product tl (λ(sub-product)
                                        (fn (cons elem sub-product)))))]))

(define count 0)
(define (in-cartesian-product . lol)
  (define (prepend-to-stream-values elements full-elements substream)
    (println elements)
    (set! count (add1 count))
    (if (stream-empty? substream)
        empty-stream
        (if (null? elements)
            (prepend-to-stream-values full-elements full-elements (stream-rest substream))
            (stream-cons (cons (first elements) (stream-first substream)) (prepend-to-stream-values (rest elements) full-elements substream)))))

  (if (null? lol)
      (stream-cons '() empty-stream)
      (let [(head (first lol))
            (tail (rest lol))]
        (prepend-to-stream-values head head (apply in-cartesian-product tail)))))

;(define s (in-cartesian-product '(a b c d e) '(f g h i j)))
(define num 0)
(for [(choice (in-cartesian-product '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)
                                    '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)
                                    '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)
                                    '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)
                                    '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)
                                    '(0 1) '(0 1) '(0 1) '(0 1) '(0 1)))]
  (println (list num count))
  (set! num (add1 num)))