#lang lazy

;;; lazy-racket.rkt
;;; Codes sources de la section 17.4.2 (Lazy Racket)
;;; Livre PCPS : "Premiers Cours de Programmation avec Scheme"
;;; Langage determine par le source

(define-syntax show          ; ligne 352
  (syntax-rules ()
    ((show expr) (printf "> ~s\n~s\n" 'expr (!! expr)))))     ; !! pour un forcage recursif d'une promesse

(define-syntax lprintf
  (syntax-rules ()
    ((lprintf str arg ...) (printf str (!! arg) ...))))

(define (f x y)    ; f est paresseuse, page 401 ligne 330
  x)               ; et n'evalue ses arguments que par necessite, donc pas y...

(define (fac n)
  (if (= n 0) 1 (* n (fac (- n 1)))))

(show (fac 5))
(show (f 4 (fac 100000000000)))   ; (fac 100000000000) n'est pas calcule !

(define fibs (cons 0 (cons 1 (map + fibs (cdr fibs)))))    ; ligne 337

(show (take 20 fibs))

(show (apply + (take 100 fibs)))   ; la somme des 100 premiers nombres de Fibonacci, ligne 350

(define (new-if test p q)          ; if devient une FONCTION !
  (cond (test p)
        (else q)))

(show (new-if (= 1 2) (/ 1 0) 3))

"le crible d'Eratosthenes"

(define L2 (cons 2 (map add1 L2)))          ; le flot [2, +inf[

(define (rayer n L)     ; L prive des multiples de n
  (filter (lambda (x) (not (= 0 (modulo x n)))) L))

(define (crible L)
  (cons (car L) (crible (rayer (car L) (cdr L)))))

(define PREMS (crible L2))

(show (take 20 PREMS))
(printf "Le 1000ème nombre premier est ~a\n" (list-ref PREMS 999))
(printf "et la somme des 100 premiers est ~a\n" (apply + (take 100 PREMS)))

"Les series formelles"

(define ZERO (cons 0 ZERO))     ; le flot infini <0,0,0,0,...>

(define (poly->serie L)         ; L = coeffs en puissances croissantes 
  (define (copy L) 
    (if (null? L) 
        ZERO                    ; padding à droite par des 0 
        (cons (car L) (copy (cdr L))))) 
  (copy L))

(show (take 10 (poly->serie '(1 2 3))))

(define (int-serie S)           ; integration terme a terme, le code n'est pas dans le livre...
  (define (aux S i) 
    (cons (/ (car S) i) (aux (cdr S) (+ i 1)))) 
  (aux S 1))

(define EXPO (cons 1 (int-serie EXPO)))

(show (take 10 EXPO))