Over easier

I previously defined get and over operations for Scheme assoc lists, but they were not recursive. These are.

(define-syntax λ (syntax-rules () ((_ . α) (lambda . α))))
(define-syntax ∃ (syntax-rules () ((_ . α) (let* . α))))
(define-syntax ? (syntax-rules () ((_ . α) (if . α))))
(define-syntax ← (syntax-rules (▽)
 ((_ (▽ α ...) ω ...) (begin (define α ω) ...))
 ((_ ((α ω ...) ...)) (begin (define α ω ...) ...))
 ((_ . α) (define . α))))
(← ((∀ map) (∘ compose) ($ apply) (∈ assoc) (∅ '()) (↑ car) (↓ cdr) (⇒ foldr))) 
(← ((⊂ cons) (≡ equal?) (⌽ reverse) (ρ? length)))
(← (∈$ α f ω) (∃ ((A (↑ ω)) (Ω (↓ ω))) (? (≡ α A) `(,α ,($ f Ω)) ω)))
(← (∈⇒ α f ω) (⇒ (λ (x acc) (⊂ (∈$ α f x) acc)) ∅ ω))
(← (∈∈⇒ α f ω)
   (? (≡ 1 (ρ? α)) (∈⇒ (↑ α) f ω) (∈⇒ (↑ α) (λ (x) (∈∈⇒ (↓ α) f x)) ω)))
(← (∈∈ α ω) (call/cc (λ (Ω) (∈∈⇒ α (λ (x) (Ω x)) ω))))

∈∈⇒ is like an over lens, where providing a list of keys and a function f will run f on a nested field.

(← (double α) (* α 2))
(← xs '((a ((b ((c 1) (d 2))) (e 3)))))

(∈∈⇒ '(a b c) double xs)
  ((a ((b ((c 2) (d 2))) (e 3))))

(∈∈⇒ '(a b d) double xs)
  ((a ((b ((c 1) (d 4))) (e 3))))

(∈∈⇒ '(a e) double xs)
  ((a ((b ((c 1) (d 2))) (e 6))))

∈∈, the get equivalent, was rewritten to take a series of keys now. Funnily enough, it can be implemented in terms of ∈∈⇒ thanks to call/cc.

(∈∈ '(a b c) xs)
  1

(∈∈ '(a b d) xs)
  2

(∈∈ '(a e) xs)
  3

Fun stuff.