example-predicate.lurk

;; This predicate verifies that there's a horseman called jesus who rides a white horse.
;; In jq `.horsemen | .[] | select(.name == "jesus") | .horse.color` must be "white".

(letrec ((and (lambda (x y)
                      (if x y x)))
         (any (lambda (p xs)
                      (if xs
                          (if (p (car xs))
                              t
                              (any p (cdr xs)))
                          nil)))
         (length (lambda (xs)
                         (if (eq xs nil) 0
                             (+ 1 (length (cdr xs))))))
         (verify-string (lambda (test pair)
                                (if (eq :string (car pair))
                                    (eq test (cdr pair))
                                    nil)))
         (verify-horse (lambda (parsed)
                               (if (eq :object (car parsed))
                                   (any (lambda (kv)
                                                (if (eq "color" (car kv))
                                                    (verify-string "white" (cdr kv))
                                                    nil))
                                        (cdr parsed))
                                   nil)))
         (verify-horseman (lambda (parsed)
                                  (if (eq :object (car parsed))
                                      (and (any (lambda (kv)
                                                        (if (eq "name" (car kv))
                                                            (verify-string "jesus" (cdr kv))
                                                            nil))
                                                (cdr parsed))
                                           (any (lambda (kv)
                                                        (if (eq "horse" (car kv))
                                                            (verify-horse (cdr kv))
                                                            nil))
                                                (cdr parsed)))
                                      nil)))
         (verify-horsemen (lambda (parsed)
                                  (if (eq :array (car parsed))
                                      (and (eq 4 (length (cdr parsed)))
                                           (any verify-horseman (cdr parsed)))
                                      nil)))
         (verify-all (lambda (parsed)
                             (if (eq :object (car parsed))
                                 (any (lambda (kv)
                                              (if (eq "horsemen" (car kv))
                                                  (verify-horsemen (cdr kv))
                                                  nil))
                                      (cdr parsed))
                                 nil))))
        verify-all)