Mist - Mathematica, CLisp(Cygwin on Windows)

Intersection, FileNameJoin, StringDrop, Run new.zip other.zip

(load 'init.lisp)
(compile-mma)
(load-mma)
(|ReplaceAll| '(f 2 2) '(|Rule| (|Pattern| a (|BlankSequence|)) (f1 a) ) )
 > (F1 ((F1 F) (F1 2) (F1 2)))
(elt '(F1 ((F1 F) (F1 2) (F1 2))))
(|ReplaceAll| '(f 2) '(|Rule| (f (|Pattern| a (|Blank|))) (f1 a) ) )
 > (f1 a)
(|ReplaceAll| '(f a b) '(|Rule| (|Pattern| a (|Blank|))) (f 1 2) )))
> (f a b)

Mathematica & ExcelLisp Implementation Java

Mathematica Lisp
HoldForm/quote
Hold[1 + 1*1] === Hold[1 + 1*1]
(equal '(+ 1 (* 1))  (list '+ 1 (list '* 1))) ; ' is a list escaped
(equal '(+ 1) (quote (+ 1)) ;quote escapes all heads infinitely 
ReleaseHold
ReleaseHold[HoldComplete[1 + 2]]
ReleaseHold@HoldComplete[HoldComplete[1 + 2]]

ReleaseHold[Hold[1+2]]
ReleaseHold[HoldForm[1+2]]
; Technically Hold doesn't exist but when fns are
; unevaluated they are a list with symbol as 1st elements
(eval '('(+ 1 2)))
(eval '(list '+ 1 '(+ 1 2) (* 2 3)))
List
{1+2,2,3}
Hold@{1,2}
(vector (+ 1 2) 2 3)
'(vector 1 2)
Take
Take[{a, b, c, d, e, f}, 4]
(elt #(1 2 3) 1) ;works on both lists and vectors
(nth 0 '(1 2)) ; lists only
(aref #(1 2 3) 0)
Sequence f[a, Sequence[b, c], d]
Prepend
Prepend[{1, 2}, 0]
(cons 0 '(1 2))
Append
Append[{1, 2}, 3]
(append '(1 2 3) '(4)) 
Join
Join[{1,2},{3,4}] 
(append '(1 2 3) '(4 5 6)) 
listp
vectorp
IntegerQ[1] (numberp 1) (integerp 1)
(rationalp 1) (realp 1)
floatp complexp
(listp '(1))
(vectorp #(1))
Pattern Matching f[x, 1, 2] /. f[x_, y__] :> f[1, x, y] (|ReplaceAll| '(f 1 2) '(|Rule| (f (|Pattern| a (|BlankSequence|))) (f1 a)))
(ReplaceAll '(f x 1 2) ' (
(f (_ x) (__ y)) (f 1 x y)
))
Apply (coerce #(1 2 3) 'list)
Atoms AtomQ (cons '(1 . 2))
(not (atom '(1 . 2)))
Drop Drop[{a, b, c, d, e, f}, 2] (* Drop first 2 elements supports negative *)

lisp FullForm(like mathematica's FullForm) would probably appear like the following
(list '+ (vector '* 1))
The problem is that technically they won't work because VECTORs and LISTs are automatically converted to '() and #()
therefore there is now way to distinguish between
I don't like lisp b/c the folllowing returns
'(f '(+ 1))
> (f '(+ 1))
and notice how it doesn't print the 1st quote ' but it does in the second quote
Dotted Pair Notation
for example (rose . (violet)) equals (rose violet)
(rose . violet . buttercup) is invalid

Depth

(defun max-depth (tree)
  (if (atom tree)
      0
      (1+ (reduce #'max (mapcar #'max-depth tree)))))

Flatten

(defun flatten (structure)
  cond ((null structure) nil)
    ((atom structure) (list structure))
     (t (mapcan #'flatten structure))))

Testingt