Mist - Mathematica, CLisp(Cygwin on Windows)

Lisp is a great language but it appears it not truely self modifying because macros can't be modified by other macros. (a . b) has (cons a b) as FullForm. 90minSchemetoCCompiler

The best idea I have come up with is to create a part of the code that exports to lisp code and a part that exports to Mathematica code. For example I could potentially prefix mathematica code with $ sign. Mathematica's editor is really nice. Another possibility is maybe using matics.net with the Mathematica FrontEnd. ClojureScript is another possibility. The goal is to essentially have the ideal of editor of Mathematica but with the code in an open source language. Mathematica Editor -> Lisp/JSON/XML -> JS/Java The problem is anything that involves pattern matching needs to call back to Mathematica/Mathics.net.

Python supports fractions, imaginary, infinity, -infinity, null, while JavaScript doesn't support fractions or imaginary numbers.

    $Replace[Import["a.txt"],"a.txt"->"b.txt"]                (Import "b.txt")                                         Import/Require("test")
    $ReplaceAll[Import["c.txt"]],"c.txt"->"d.txt"]            (ReplaceAll[Import["abc.txt"]],"abc.txt"->"test2.txt"])  ReplaceAll(`Import["test"]`,{"abc.txt":"test2.txt"})
    $Replace[Import["test.txt"]]                              ()

(load "quicklisp.lisp")
(quicklisp-quickstart:install)
(load "C:/Users/a/quicklisp/setup.lisp")
(json:encode-json '( ((foo . (1 2 3)) (bar . t) (baz . #\!)) "quux" 4/17 4.25))
(ql:quickload :cl-json)
(with-input-from-string (s "[1, 2, 3]") (json:decode-json s) )

There is no FullForm of the following (defmacro add ( &rest args ) `(+ ,@args)).
Intersection, FileNameJoin, StringDrop, Run new.zip other.zip

(setf (readtable-case *readtable*) :invert)
(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

(defmacro IFF (condition &rest body)
  `(if ,condition (progn ,@body)))
(IFF (> x 10) (print 0))
&rest &optional gensym 

IFF[condition_,body___]:=If[condition,body];
SetAttributes[IFF,HoldAll];
IFF[x<10,Print@0];

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[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)))

{1+2,2,3}
Hold@{1,2}

(vector (+ 1 2) 2 3)
'(vector 1 2)

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)

Prepend[{1, 2}, 0]

(cons 0 '(1 2))

Append[{1, 2}, 3]

(append '(1 2 3) '(4)) 

Join[{1,2},{3,4}] 

(append '(1 2 3) '(4 5 6)) 

(select [email] :from [users] :where [= ["lower(name)"] (string-downcase customer)])

lisp FullForm(like mathematica's FullForm) would probably appear like the following but there is no FullForm for macros

(list '+ (vector '* 1))

The problem is that technically they won't work for output 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 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))))

SymbolName

(defun mkstr (&rest args)
  (with-output-to-string (s)
    (dolist (a args) (princ a s))))

(defun SymbolName (&rest args)
  (values (intern (apply #'mkstr args))))
  
(defun Symbol (a) (intern a)))
(defun Symbol (a_String) (intern a)))

(apply #’(lambda (x y) (+ x y)) ’(1 2))


(mapcar #’(lambda (x) (+ x 10))
   ’(1 2 3))

(mapcar #’+
   ’(1 2 3)
   ’(10 100 1000))

(sort ’(1 4 2 5 6 7 3) #’<)

(remove-if #’evenp ’(1 2 3 4 5 6 7))

(let ((s (make-string-input-stream "(1 2 3)"))) (read s))

OO Lisp

(defun behave (animal)
  (funcall (get animal ’behavior)))
  
(setf (get ’dog ’behavior)
  #’(lambda ()
      (print 'wag-tail)
      (print 'bark)))
 

The following is a short docs of lisp http://jtra.cz/stuff/lisp/sclr/index.html