Examples of the CL-REEX Common Lisp library

cl-reex-examples.lisp

(in-package :cl-user)

(defparameter *observer*
  (rx:make-observer
   (rx:on-next (x) (print x))
   (rx:on-error (x) (format t "error: ~S~%" x))
   (rx:on-completed () (print "completed")) ))


(defparameter *sequence*
  (rx:observable-from '(1 2 3 4 5 6 7 8 9 10)))


(defun run-test-1 ()
  (rx:subscribe *sequence* *observer*))


(defun run-test-2 ()
  "Example from library's readme."
  (rx:with-observable *sequence*
    (rx:where (x)
              (evenp x))
    (rx:where (x)
              (eq (mod x 3) 0))
    (rx:subscribe *observer*)))
    
    
(defun run-test-2-without-a-macro ()
  "The same example, but composed by manual combination of conditions."
  (let* ((only-even
           (cl-reex.operator.where:make-operator-where *sequence*
                                                       (lambda (x)
                                                         (evenp x))))
         (dividable-by-3
           (cl-reex.operator.where:make-operator-where only-even
                                                       (lambda (x)
                                                         (eq (mod x 3) 0)))))
    (rx:subscribe dividable-by-3 *observer*)))
    
(defun run-test-3 ()
  "This example shows how to make two observers consume the same sequence of objects

   Here is how it's results looks like:

   CL-USER> (run-test-3)
   SECOND: 6
   FIRST: 6
   SECOND: completed
   FIRST: completed
   #<CL-REEX.OPERATOR:DISPOSABLE-OPERATOR {1002A739D3}>
"
  (let* ((only-even
           (cl-reex.operator.where:make-operator-where *sequence*
                                                       (lambda (x)
                                                         (evenp x))))
         (dividable-by-3
           (cl-reex.operator.where:make-operator-where only-even
                                                       (lambda (x)
                                                         (eq (mod x 3) 0))))
         (subject (rx:make-subject))
         (first-observer
           (rx:make-observer
            (rx:on-next (x) (format t "FIRST: ~A~%" x))
            (rx:on-error (x) (format t "FIRST: error - ~S~%" x))
            (rx:on-completed () (format t "FIRST: completed~%")) ))
         (second-observer
           (rx:make-observer
            (rx:on-next (x) (format t "SECOND: ~A~%" x))
            (rx:on-error (x) (format t "SECOND: error - ~S~%" x))
            (rx:on-completed () (format t "SECOND: completed~%")) )))

    (rx:subscribe subject first-observer)
    (rx:subscribe subject second-observer)
    (rx:subscribe dividable-by-3 subject)))