Some basic functions in LISP

(define (mySquare x)
  (* x x)
)
(define (appendd x L)
  (if (null? L) (cons x '() )
      (cons (car L) (appendd x (cdr L)))))
(define (squareList L)
  (if (null? L)
      '()
      (cons (mySquare(car L)) (squareList(cdr L)))
  )
)
(define (concat M N)
   (if (null? M) N
      (cons (car M) (concat (cdr M) N) )
     )
)
(define (tail L)
  (if (null? (cdr L)) (car L) (tail (cdr L)))
)

(define (tailless L)
  (if (null? (cdr L)) '() (cons (car L) (tailless (cdr L)))))

(define (secondFinder L)
  (car (cdr L)))

(define (nFinder n L)
  (if (null? L) -1
   (if (= n 1) (car L) (nFinder (- n 1) (cdr L) ) ) )
  )
;(nFinder 3 '("a" "b" "c"))

(define (evenFinder n L)
  (if (null? (cdr L) )
  "1" (cons (nFinder (+ n 2) (cdr (cdr L))) '())))

(define (removeNegs L)
  (if ( null? L ) '()
      (if (< (car L) 0) (removeNegs (cdr L))
          (cons (car L) (removeNegs (cdr L))))))

(define (isNegative x) (< x 0))
(define (isEven x) (= 0 (modulo x 2)))

(define (removeF f L)
  (if ( null? L ) '()
      (if (f (car L)) (removeF f (cdr L))
          (cons (car L) (removeF f (cdr L))))))

(define (removeFAfterG f g L)
  (if ( null? L ) '()
      (if (f (g (car L))) (removeFAfterG f g (cdr L))
          (cons (car L) (removeFAfterG f g (cdr L))))))
;(removeFAfterG isEven mySquare '(1 4 3 5 9 12))

(define (removeQAfterG g L)
  (if ( null? L ) '()
      (if ((lambda (x) (not (= 0 (modulo x 3)))) (g (car L))) (removeQAfterG g (cdr L))
          (cons (car L) (removeQAfterG g (cdr L))))))
;(removeQAfterG mySquare '(1 4 3 5 9 12))

(define (isGreaterThan x)
  (lambda (n) (> x n)))
;((isGreaterThan 5) 3)

;take in a function (isNegative) and output a function (removeAllNegs)
(define (removeIfBuilder f)
  (define (remover L)
    (if (null? L) '()
       (if (f (car L)) (remover (cdr L))
           (cons (car L) (remover (cdr L))))))
  remover
)
;removes all negatives
;((removeIfBuilder isNegative) '(-1 93 -5 6 -7 -10 2))
;removes all negative and even numbers
;((removeIfBuilder isEven) ((removeIfBuilder isNegative) '(-1 93 -5 6 -7 -10 2)))
(define (removeIfAorBBuilder f g)
  (define (remover L)
    (if (null? L) '()
        (if (or (f (car L)) (g (car L) )) (remover (cdr L))
            (cons (car L) (remover (cdr L))))))
  remover
)
;((removeIfAorBBuilder isNegative isEven) '(-1 93 -5 6 -7 -10 2))
(define (myCompose f g)
  (define (composition x)
    (f (g x)))
  composition
  )
(define (lambdaCompose f g)
  (lambda (x) (f (g x))))

(define (_reverse L)
  (if (null? (cdr L))
          (cons (car L) '())
          (appendd (car L) (_reverse (cdr L)))))
;(_reverse '( 0 1 2 ))