(require :iterate)
(use-package :iterate)
(load "/Users/dl/ulimyhmpqs.lisp")

;; basic iteration
(iter (for i from 1 to 10)
               (collect i))

;; hash table
(let ((ht (make-hash-table :test #'equal)))
  (setf (gethash "foo" ht) 23)
  (setf (gethash "bar" ht) 17)
  (setf (gethash "baz" ht) 13)
  
  (iter (for (k v) in-hashtable ht)
        (collect (list k v))))

;; file
(iter (for line in-file "/Users/dl/iterate-presentation/present.txt" 
           using #'read-line)
      (format t "line: ~A~%" line))

;; generators
(iter (for i from 2 to 10)
               (generate sym in '(a s d f g h j k l))
               (when (prime? i)
                 (collect (list i (next sym)))))

;; previous values

(defun iter-fib (n)
  (declare (optimize SPEED))
  (cond ((= n 1) 1)
        (t (iter (for i from 2 to n)
                 (for prev previous result initially 1)
                 (for pprev previous prev initially 0)
                 (for result = (+ prev pprev))
                 (finally (return result))))))


;; finders
(iter (for i from 1 to 10)
               (finding i maximizing (sin i)))

;; boolean tests
;; stolen from the manual
 (iter (for el in '(nil 1 2 nil 3))
             (when el
               (unless (first-time-p)
                 (princ ", "))
               (princ el)))

;; types and declarations

(defvar number-list '(1 2 3 4 5 6 7 8 9 10))

(iter (for el in number-list)
      (declare (fixnum el))
      (counting (oddp el)))

;; or

(iter (for (the fixnum el) in number-list)
      (counting (oddp el)))

;; extensibility

(defmacro for-var-from-1-to-10 (var)
  `(for ,var from 1 to 10))

(iterate (for-var-from-1-to-10 i)
                  (collect i))


(defmacro-clause (for-var-from-1-to-20 var)
  `(for ,var from 1 to 20))

(iterate (for-var-from-1-to-20 i)
         (collect i))

(setf *r* (make-instance 'LoGS::ruleset))
(LoGS::enqueue *r* (make-instance 'rule :name 'foo))
(LoGS::enqueue *r* (make-instance 'rule :name 'bar))

;; iterate over LoGS ruleset
(iter (for head = (logs::head *r*))
      (initially (setq entry (logs::head *r*)))
      (for entry initially (logs::head *r*) 
           then (and entry (logs::rlink entry)))
      (while entry)
      (format t "~A~%" entry))

(defmacro-clause (FOR var IN-LOGS-RULESET ruleset)
  "All the elements of a LoGS ruleset"
  (let ((head (gensym))
        (entry (gensym)))
    `(progn
       (for head = (logs::head ,ruleset))
       (initially (setq entry (logs::head ,ruleset)))
       (for ,entry initially (logs::head ,ruleset)
            then (and ,entry (logs::rlink ,entry)))
       (for ,var next (and ,entry (logs::data ,entry))))))