λ - programming

((= 1 2) 3 4)
-> 4

;; parentheses
(+ (f 1 2 3))
(+ (f 1 2) 3)
(+ (f 1) 2 3)
(+ f 1 2 3)
;; whitespace
 +  f 1 2 3  
 +  f 1 2  3 
 +  f 1  2 3 
 + f 1 2 3 

: palindrome? ( str – ? ) dup reverse = ;
: factorial ( xs – n ) [1,b] 1 [ * ] reduce ;
: sum ( xs – n ) [1,b] 0 [ + ] reduce ;

#lang racket

(define (current-continuation)
    (call/cc (λ (k) (k k))))

(define fail-stack '())

(define (fail)
  (if (null? fail-stack)
      (error "back-tracking stack exhausted!")
      (let ([back-track-point (first fail-stack)])
        (set! fail-stack (rest fail-stack))
        (back-track-point back-track-point))))

(define (amb choices)
  (let ([cc (current-continuation)])
    (cond [(null? choices)
           (fail)]
          [else
           (let ([choice (first choices)])
             (set! choices (rest choices))
             (set! fail-stack (cons cc fail-stack))
             choice)])))

(define (assert condition)
  (if (not condition)
      (fail)
      #t))

(let ((a (amb (list 1 2 3 4 5 6 7)))
      (b (amb (list 1 2 3 4 5 6 7)))
      (c (amb (list 1 2 3 4 5 6 7))))
  ;(displayln (list a b c))
  ; We're looking for dimensions of a legal right
  ; triangle using the Pythagorean theorem:
  (assert (= (* c c) (+ (* a a) (* b b))))
  (assert (< b a)))

* DLLISP: Doubly-Linked-Loop Processing
- Circular doubly-linked-list as the native data-structure
- Left/right handed operator preference
- "CAR" is NULL, which serves as the terminator for both ends of the loop.
 + Can be another value, as in an improper list, e.g. '(a . b), but special
   considerations must be made, as with any non-terminating sequence.
  + Should be lazy by default in this case.

 `(#1=,(gensym) B C . #1#) 

(ns woot
  (:refer-clojure :exclude [== record?]) 
  (:require [clojure.core.logic.fd :as fd])
  (:use [clojure.core.logic]))

(defne triangleo
  [A B C X]
  ([[?A . ?At] [?B . ?Bt] [?C . ?Ct] [?X . ?Xt]]
   (fresh [a-sq b-sq c-sq]
     (squareo ?A a-sq)
     (squareo ?B b-sq)
     (squareo ?C c-sq)
     (fd/+ a-sq b-sq c-sq)
     (== ?X [?A ?B ?C])
     (triangleo ?At ?Bt ?Ct ?Xt)))
  ([[_ . ?At] [_ . ?Bt] [_ . ?Ct] _]
   (triangleo ?At ?Bt ?Ct X))
  ([[] [] [] []]))

;; find all triangles with sides ranging from 1 to 7
(run* [q]
  (fresh [a b c]
    (== a (range 1 8))
    (== b (range 1 8))
    (== c (range 1 8))
    (triangleo a b c q)))

 ;; parentheses
(+ (f 1 2 3))
(+ (f 1 2) 3)
(+ (f 1) 2 3)
(+ f 1 2 3)

;; whitespace
+
  f 1 2 3
+
  f
    1 2
  3
+
  f
    1
  2
  3
+
  f 1 2 3

(define (read-lisp) (read))

(loop for i from 1 to 100 do ...)

(loop i 1 100 ...)