generators.lisp

(defpackage :aoc.generator 
  (:use :cl)
  (:export #:stop
           #:next
           #:on-stop
           #:iterate
           #:sum
           #:fold-generator
           #:all-lines
           #:group-by-n
           #:size
           #:keep-if))

(in-package :aoc.generator)

(define-condition stop () ())

(defun stop ()
  (signal 'stop))

(defgeneric next (generator &rest args)
  (:method (_ &rest args)
    (declare (ignore args))
    (stop))
  (:method ((f function) &rest args) (apply f args)))

(defun all-lines (stream)
  (lambda ()
    (let ((line (read-line stream nil stream)))
      (if (eq line stream)
          (stop)
          line))))

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defmacro on-stop (form &body body)
    (alexandria:with-gensyms (_)
      `(handler-bind ((stop (lambda (,_) (declare (ignore ,_)) ,form)))
         ,@body))))

(defun iterate (generator fn)
  (loop
    (on-stop (return)
      (funcall fn (next generator)))))

(defun fold-generator (folder accumulator generator)
  (loop
    (on-stop (return accumulator)
      (setf accumulator (funcall folder accumulator (next generator))))))

(defun sum (generator)
  (fold-generator #'+ 0 generator))

(defun size (generator)
  (fold-generator (lambda (acc _) (declare (ignore _)) (1+ acc)) 0 generator))

(defun group-by-n (n generator)
  (lambda () (loop repeat n collect (next generator))))

(defun keep-if (predicate generator)
  (lambda ()
    (loop
      (let ((v (next generator)))
        (when (funcall predicate v)
          (return v))))))