(define α 67)

α

(define i 2)
(define vectorᵢ (vector-ref (vector 0 6 3 2) i))
vectorᵢ

(import "calysto.display")

(calysto.display.HTML "This is <b>bold</b>, <i>italics</i>, <u>underlined</u>.")

(import "calysto.graphics")

(define canvas (calysto.graphics.Canvas))

(define ball (calysto.graphics.Circle '(150 150) 100))

(ball.draw canvas)

! ls /tmp

(python-eval "1 + 2")

(python-exec 
"
def mypyfunc(a, b):
    return a * b
")

(mypyfunc 4 5)

(define! mypyfunc2 (func (lambda (n) n)))

(python-eval "mypyfunc2(34)")

(define fact
    (lambda (n)
      (if (= n 1)
           q
           (* n (fact (- n 1))))))

(fact 5)

SCHEMEPATH

(set-cdr! (cdr SCHEMEPATH) (list "/var/modules"))

SCHEMEPATH

(define factorial
  (λ (n)
     (cond
      ((zero? n) 1)
      (else (* n (factorial (- n 1)))))))

(factorial 5)

(define-syntax time 
  [(time ?exp) (let ((start (current-time)))
                 ?exp
                 (- (current-time) start))])

(time (car '(1 2 3 4)))

;;---------------------------------------------------------------------
;; collect is like list comprehension in Python

(define-syntax collect
  [(collect ?exp for ?var in ?list)
   (filter-map (lambda (?var) ?exp) (lambda (?var) #t) ?list)]
  [(collect ?exp for ?var in ?list if ?condition)
   (filter-map (lambda (?var) ?exp) (lambda (?var) ?condition) ?list)])

(define filter-map
  (lambda (f pred? values)
    (if (null? values)
      '()
      (if (pred? (car values))
          (cons (f (car values)) (filter-map f pred? (cdr values)))
          (filter-map f pred? (cdr values))))))

(collect (* n n) for n in (range 10))

(collect (* n n) for n in (range 5 20 3))

(collect (* n n) for n in (range 10) if (> n 5))

;;---------------------------------------------------------------------
;; for loops

(define-syntax for
  [(for ?exp times do . ?bodies)
   (for-repeat ?exp (lambda () . ?bodies))]
  [(for ?var in ?exp do . ?bodies)
   (for-iterate1 ?exp (lambda (?var) . ?bodies))]
  [(for ?var at (?i) in ?exp do . ?bodies)
   (for-iterate2 0 ?exp (lambda (?var ?i) . ?bodies))]
  [(for ?var at (?i ?j . ?rest) in ?exp do . ?bodies)
   (for ?var at (?i) in ?exp do
     (for ?var at (?j . ?rest) in ?var do . ?bodies))])

(define for-repeat
  (lambda (n f)
    (if (< n 1)
      'done
      (begin
        (f)
        (for-repeat (- n 1) f)))))

(define for-iterate1
  (lambda (values f)
    (if (null? values)
      'done
      (begin
        (f (car values))
        (for-iterate1 (cdr values) f)))))

(define for-iterate2
  (lambda (i values f)
    (if (null? values)
      'done
      (begin
        (f (car values) i)
        (for-iterate2 (+ i 1) (cdr values) f)))))

(define matrix2d
  '((10 20)
    (30 40)
    (50 60)
    (70 80)))

(define matrix3d
  '(((10 20 30) (40 50 60))
    ((70 80 90) (100 110 120))
    ((130 140 150) (160 170 180))
    ((190 200 210) (220 230 240))))

(begin 
 (define hello 0)
 (for 5 times do (set! hello (+ hello 1)))
 hello
 )

(for sym in '(a b c d) do (define x 1) (set! x sym) (print x))

(for n in (range 10 20 2) do (print n))

(for n at (i j) in matrix2d do (print (list n 'coords: i j)))

(for n at (i j k) in matrix3d do (print (list n 'coords: i j k)))

(define-syntax scons
  [(scons ?x ?y) (cons ?x (lambda () ?y))])

(define scar car)

(define scdr
  (lambda (s)
    (let ((result ((cdr s))))
      (set-cdr! s (lambda () result))
      result)))

(define first
  (lambda (n s)
    (if (= n 0)
      '()
      (cons (scar s) (first (- n 1) (scdr s))))))

(define nth
  (lambda (n s)
    (if (= n 0)
      (scar s)
      (nth (- n 1) (scdr s)))))

(define smap
  (lambda (f s)
    (scons (f (scar s)) (smap f (scdr s)))))

(define ones (scons 1 ones))

(define nats (scons 0 (combine nats + ones)))

(define combine
  (lambda (s1 op s2)
    (scons (op (scar s1) (scar s2)) (combine (scdr s1) op (scdr s2)))))

(define fibs (scons 1 (scons 1 (combine fibs + (scdr fibs)))))

(define facts (scons 1 (combine facts * (scdr nats))))

(define ! (lambda (n) (nth n facts)))

(! 5)

(nth 10 facts)

(nth 20 fibs)

(first 30 fibs)

(for-each (lambda (n) (print n)) '(3 4 5))

(format "This uses formatting ~a ~s ~%" 'apple 'apple)

(func (lambda (n) n))