NIL

• retaining the core of the language
• basic artithmetic operators do what they do
• algorithms can be represented as functions
• assertions (read mathematical equalities) will be presented by a "meq" macro
  • single "=" is retained for the predicate function testing for equality

(eq t '())

• all symbol modifiers that follow will be prefixes and not suffixes for quicker graspability of what higher level directive is to be called upon

• read these as magical macros that assume several underlying black boxes to be delegated to the mystery that the human mind is.
• I might proceed in a functional manner in some cases and in the procedural manner in some
• the usual language compliant macro will occur as defmacros
• but the not so usual (shouldn't be so unusual once you read some NIL) will occur as defabscro
  • referring these as abscros

(defmacro defabscro (...)
  "This does some questionably explicable stuff"
  (...)) 

(defasbscro daydream (...)
  "This yeilds a day dreaming abstraction"
  (...))

• I'll be creating quite a few symbols on the fly, skipping the axiomatics from time to time, for the time being
• to express a notion that isn't a usual variable and the one I want to assume an abstract initiation for
• I'll be preceding that symbol with "**.." -> read as dereferencing a concept.
  • this is a generic derferencer and can apply to functions as well as symbols that refer to an abscro not defined explicitly in the context
• used during acts of laziness when you don't wish to defabscro something

(**daydream **something-not-not-worth-daydreaming-about)

• I'll be referring some entities as well that aren't just cooked up in the moment and have explicit corpora built around them that can later on be used for mathematically formulating their aspects
• these will be prefixed with ~*

(*daydream ~*light-sabers)

• Categorizing and breaking down abstractions is an important feature of a notetaking language.
• prefixing an categorization assertion by a //:
  • the categories follow with a :: prefix individually

(//~*boolean
 ::~*true
 ::~*false
 ::~*maybe-boolean)

• a modifier on the same line following the leading symbol can be used for tagging the sexp and aiding comprehension

(//~*boolean 'non-exhaustive
 ::~*true
 ::~*maybe-boolean)

• this can further be used to denote subsets

I started off with this notion while being lazy regarding use latex in my notes (I'll mostly work with text-files and although I can render math in them with a few chords and key-strokes, it takes me away from the process of noting being seamless and crude).

Given I can directly use the built in (slime-)inferior-lisp process with Org-babel for cl/elisp, I have the expressive power to express anything that I need. This will handle math but will also allow me to express procedures in a more readable format than normal pseudocode.

I might develop a personal standard/protocol over time for uniformity and elegance. I can see myself having a representative s-expression for each node in the future that powers up what I can really do with this system. For now, I'll begin with basic math and functions while also trying to build a more "natural" representaion language in lisp. This might become a formal pursuit later on.