λ - programming

(defun throw-die ()
  (1+ (random 6)))

(defun throw-dice ()
  (list (throw-die) (throw-die)))

(defun snake-eyes-p (throw)
  (if (and (= 1 (first throw))
   (= 1 (second throw)))
      t))

(defun boxcarsp (throw)
  (if (and (= 6 (first throw))
   (= 6 (second throw)))
      t))

(defun instant-win-p (throw)
  (if (or (= 7 (+ (first throw) 
  (second throw)))
  (= 11 (+ (first throw)
   (second throw))))
      t))

(defun instant-loss-p (throw)
  (if (or (boxcarsp throw)
  (snake-eyes-p throw)
  (= 3 (+ (first throw)
  (second throw))))
      t))

(defun say-throw (throw)
  (cond ((boxcarsp throw) 'boxcars!)
((snake-eyes-p throw) 'snake-eyes!)
(t (+ (first throw)
      (second throw)))))

(defun craps ()
  (let* ((throw (throw-dice))
 (result (say-throw throw)))
    (cond ((instant-win-p throw) 
   (format t "Throw ~a and ~a - ~a - you win!" 
   (first throw)
   (second throw)
   result))
  ((instant-loss-p throw) 
   (format t "Throw ~a and ~a - ~a - you lose!" 
   (first throw)
   (second throw)
   result))
  (t (format t "Throw ~a and ~a - your point is ~a" 
     (first throw)
     (second throw)
     result)))))

(defun try-for-point (point)
  (let* ((throw (throw-dice))
 (result (say-throw throw)))
    (cond ((eq point result) 
   (format t "Throw ~a and ~a - ~a - you win!" 
   (first throw)
   (second throw)
   result))
  ((eq 7 result) 
   (format t "Throw ~a and ~a - ~a - you lose!" 
   (first throw)
   (second throw)
   result))
  (t (format t "Throw ~a and ~a - ~a - roll again!" 
     (first throw)
     (second throw)
     result)))))

(defun craps (&aux (throw (throw-dice)))
  (format t "Throw ~{~a~^ and ~} - ~@?"
          throw
          (cond ((instant-win-p  throw) "~a - you win!")
                ((instant-loss-p throw) "~a - you lose!")
                (t "your point is ~a."))
          (say-throw throw)))

(defun euler-2 (count x y)
  (when (evenp y) (setf count (+ count y)))
  (if (> y 4000000) (print count)
      (euler-2 count y (+ x y))))

(defun try-for-point (point &aux (roll (roll-dice)))
  (format t "Throw ~{~a~^ and ~} - ~@?"
          roll
          (cond ((eq point roll) "~a - you win!")
                ((eq 7 roll) "~a - you lose!")
                (t "~a - roll again."))
          (say-roll roll)))

(defun snake-eyes-p (throw)
  (and (= 1 (first throw))
       (= 1 (second throw))))

(defun boxcarsp (throw)
  (and (= 6 (first throw))
       (= 6 (second throw))))

(defun instant-win-p (throw &aux (result (+ (first throw) (second throw))))
  (or (= 7  result)
      (= 11 result)))

(defun instant-loss-p (throw)
  (or (boxcarsp throw)
      (snake-eyes-p throw)
      (= 3 (+ (first throw)
              (second throw)))))

#> int bitwise_lshift(int a, int b) { return a << b; } <#

(define bitwise-lshift (foreign-lambda int "bitwise_lshift" int int))
(print (bitwise-lshift 1 10)) ; 1024

#> int bitwise_lshift(int a, int b) { return a << b; } <#

(define bitwise-lshift (foreign-lambda int "bitwise_lshift" int int))

(let loop ((n 1))
  (let ((next (bitwise-lshift n 8)))
    (print next)
    (unless (> n next) (loop next))))

; output:
; 256
; 65536
; 16777216
; 0