#!/usr/bin/env newlisp

(setq L '(1 9 3 7 0 5))
(setq M '(2 6 5 4 0 1 3))

(define (mem E L) ;la function mem a 2 arguments
  (if (null? L) nil
    (if (= (first L) E) true
      (mem E (rest L)))))
(println (mem 9 L))

(define (boolmemrec E L)
  (cond
    ((null? L) nil)
    ((= (first L) E) true)
    ((mem E (rest L)))))
(println (boolmemrec 10 L))

(define (mem E L) ;la function mem a 2 arguments
  (if (null? L) nil
    (if (= (first L) E) L
      (mem E (rest L)))))
(println (mem 3 L))

(define (mem E L)
  (cond
    ((null? L) nil)
    ((= (first L) E) L)
    ((mem E (rest L)))))
(println (mem 9 L))
(println (member 9 L))
(println (mem 8 L))
(println (member 8 L))

(define (concatene L1 L2)
  (if (null? L1) L2
    (cons (first L1) (concatene (rest L1) L2))))
(setq C (concatene L M))
(println C)
(println (append L M))

;(trace true)

(define (rang x L)
  (if (boolmemrec x L)
    (cond 
      ((= x (first L)) 0)
      ((+ 1 (rang x (rest L)))))
    nil))
(println (rang 4 L))
(println (find 4 L))
(println (rang 0 L))
(println (find 0 L))

;(trace nil)

(define (tete n L) 
  (cond 
    ((null? L) '())
    ((= n 0) '())
    ((cons (first L) (tete (- n 1) (rest L))))))
(println (tete 3 L))
(println (slice L 0 3))
(println (0 3 L))

(define (inter L1 L2) 
  (cond
    ((null? L1) '())
    ((member (first L1) L2) (cons (first L1) (inter (rest L1) L2)))
    ((inter (rest L1) L2))))
(println (inter L M))
(println (intersect L M))

(setq N '(1 9 3))
(define (inclu L1 L2) 
  (cond
    ((null? L1) true)
    ((null? L2) nil)
    ((= (first L1) (first L2)) (inclu (rest L1) (rest L2))) 
    ((inclu L1 (rest L2)))))
(println (inclu N L))
(println (inclu L M))
;did not found a newlisp builtin equivalent function

(define (unionE L1 L2)
  (cond
    ((null? L1) L2)
    ((member (first L1) L2) (unionE (rest L1) L2))
    ((cons (first L1) (unionE (rest L1) L2)))))
(println (unionE L M))
(println (unionE N L))

;(trace true)

(setq T '(((4)((2 5))((((((6 7)))))))))
(define (prof L) 
  (cond 
    ((null? L) 0) 
    ((atom? L) 0) 
    ((max (+ 1 (prof (first L))) (prof (rest L))))))
(println (prof L))
(println (prof T))

;(trace nil)
;(trace true)

(define (aplatir L) 
  (cond
    ((null? L) nil)
    ((atom? L) (list L)) ;FIXME: the "casting" is not working properly
    ((append (aplatir (first L)) (aplatir (rest L))))))
;(println (aplatir T))
(println (flat T))

;(trace nil)

(define (elim L) 
  (cond
    ((null? L) '())
    ((member (first L) (rest L)) (elim (rest L)))
    ((cons (first L) (elim (rest L))))))
(println (elim C))
(println (unique C))

(define (reverseL L)
  (cond
    ((null? L) '())
    ((append (reverseL (rest L)) (list (first L))))))
(println (reverseL L))
(println (reverse L))

(define (list< n L)
  (cond
    ((null? L) '())
    ((>= (first L) n) (list< n (rest L)))
    ((cons (first L) (list< n (rest L))))))
(println (list< 5 L))
(println (list< 5 C))

(define (list>= n L)
  (cond
    ((null? L) '())
    ((< (first L) n) (list>= n (rest L)))
    ((cons (first L) (list>= n (rest L))))))
(println (list>= 5 C))

(exit)