Lambda-Calc-Compiler

Lambda Calculus JS Compiler, Interpreter, REPL, & C++ Library!

---

JavaScript LCC.js Compiler, REPL, & Interpreter:

Compilation Prefix:

0. Compiled Lambda Calc Files have an LCC_ Prefix & become native JavaScript
1. See JS_LambdaCalc_SampleExec.js's compilation into LCC_JS_LambdaCalc_SampleExec.js for more!

Using the REPL (Launches by Default!):

REPL COMMANDS (case-insensitive):

0. lci> EXIT exit REPL
1. lci> SYNTAX-HELP show Lambda Calculus syntax guide
2. lci> HELP show this message

REPL FILE COMPILATION & LOADING:

0. lci> LCC filename compile + exit
1. lci> LCI filename interpret/evaluate + exit
2. lci> COMPILE filename compile
3. lci> LOAD filename interpret & load into REPL's history buffer

REPL HISTORY MANIPULATION:

0. lci> SHOW-HISTORY print REPL history
1. lci> SAVE-HISTORY filename save REPL history to "filename"
2. lci> CLEAR-HISTORY clear REPL history
3. lci> DELETE lineNumber delete code at "lineNumber"
4. lci> REPLACE lineNumber newCode rewrite "lineNumber" w/ "newCode"
5. lci> INSERT lineNumber newCode insert "newCode" PRIOR "lineNumber"

REPL DEFAULT LIBRARY:

0. lci> LOAD-LIB load lambdas from JS_LambdaCalc_SampleExec.js
1. lci> LOAD-PRINT load printing show lambdas
2. lci> LOAD-CHURCH load church numeral lambdas

REPL CODING:

0. lci> @JS your_JS_expr run "your_JS_expr" as JavaScript
1. lci> your_LC_expr interpret & run your Lambda Calculus!

---

Lambda Calculus REPL Notation & Information:

RESERVED CHARS:

0. WHITESPACE + . \ ( ) @

NAMING:

0. LAMBDAS START W/ CAPITAL LETTER & ONLY HAVE ALPHANUMERICS + _
1. DATA (ARGS IN LAMBDAS) ARE A SINGLE LOWERCASE LETTER

LAMBDA STRUCTURE:

0. LambdaName := \<args>.<returned operation>
1. IMMUTABLE
2. CURRY ARGS
3. RETURN THEIR BODY

EMBEDDING JS:

0. SWAP BTWN "LAMBDA CALCULUS" & "JAVASCRIPT" SCOPES VIA TAGS:
   • @JS = ALL FOLLOWING CODE IS JAVASCRIPT TO BE LEFT AS IS
   • @LC = ALL FOLLOWING CODE IS LAMBDA CALC TO BE CONVERTED

 @JS
   .. your JS here ..
 @LC
   .. your Lambda Calculus here ..

---

C++ Library:

NAMESPACE LambdaCalc LAMBDAS

• ALL DATA IS IMMUTABLE (CONST)
• ALL LAMBDAS ARE CURRIED ( IE Add(ox1, ox2) => Add(ox1)(ox2) )
• CAPTURE SCOPE BY VALUE (using [=]) FOR INNER - CURRIED! - LAMBDAS

NOTATION:

• let N = Church Numeral, B = Fcnal Bool, F1 = Unary Fcn, F2 = Binary Fcn,
  F = arbitrary fcn, X = arbitrary data,
  L = Fcnal List Data Structure (See More Below)

---

VISUALIZATION:

• show(X) => print arbitrary data x to screen + newline

• print(X) => print arbitrary data x to screen

• bshow(B) => print fcnal boolean as boolean boolean + newline

• bprint(B) => print fcnal boolean as boolean boolean

• nshow(N) => print church numeral as unsigned long long + newline

• nprint(N) => print church numeral as unsigned long long

---

FCNAL BOOLEANS:

EXPLANATION:

• Fcnal Booleans are Binary Fcns, acting like C++'s Ternary ?: operator:
  • Fcnal True chooses arg1, False chooses arg2

BOOLEANS & BOOLEAN OPERATIONS:

• True
• False
• Not (B)
• And (B1)(B2)
• Or (B1)(B2)
• Xor (B1)(B2)
• Beq (B1)(B2) => 'B'oolean 'eq'uality, ie xnor

---

CHURCH-NUMERAL NUMERIC FCNS:

EXPLANATION:

• N-Fold Compositions of a Fcn (!!! ALL >= Zero Integers !!!):
  • IE Zero = a, Once = f(a), Twice = f(f(a)), Thrice = f(f(f(a))), etc

NUMERALS:

• Zero, Once, Twice, Thrice, Fourfold, Fivefold
• ox0,ox1,ox2,ox3,ox4,ox5,ox6,ox7,ox8,ox9,oxa,oxb,oxc,oxd,oxe,oxf

COMPARATIVE BOOLEANS:

• Is0 (N) => Equal to 'Zero'

• Eq (N1)(N2) => Equal-to

• Lt (N1)(N2) => Less Than

• Gt (N1)(N2) => Greater Than

• Leq (N1)(N2) => Less Than Or Equal-to

• Geq (N1)(N2) => Greater Than Or Equal-to

• IsFactor (N1)(N2) => N1 is a factor of N2

• Evenp (N) => N is even

• Oddp (N) => N is odd

ARITHMETIC:

• Add (N1)(N2) => N1 + N2

• Sub (N1)(N2) => N1 - N2

• Mult (N1)(N2) => N1 * N2

• Pow (N1)(N2) => N1 ** N2

• Div (N1)(N2) => N1 / N2

• Log (N1)(N2) => log N1 (N2)

• Succ (N) => Succesor of N, N+1

• Pred (N) => Predecessor of N, N-1

• Factorial (N) => N! (w/o Loops, Recursion, or Mutability!!!)

• NumericSum (N) => Sum (0,N)

• NumericSumRange (N1)(N2) => Sum (N1,N2)

---

LIST (PURELY-FUNCTIONAL!) DATA STRUCTURE FCNS:

CONTAINMENT:

• Lists can contain ANYTHING: including integers, Church Numerals, & even other Lists!

CONSTRUCTION (Given List Size):

• ListN(N) (N1) (N2) (N3) (NN) => Returns List size N of the trailing elts

BASIC ANALYSIS:

• Length (L) => Returns length of L
• Nullp (L) => "Null" 'p'redicate: List is EMPTY
• Pairp (L) => "Pair" 'p'redicate: List is NOT EMPTY

GETTERS:

• Head (L) => Return L's 1st cell value
• Last (L) => Return L's last cell value
• Nth (N)(L) => Returns L's 'N'th elt (starting from 'ox1')

SETTERS:

• Insert (N)(X)(L) => Returns List w/ X inserted in L AFTER nth position
• Erase (N)(L) => Returns List w/ L's nth value erased
• Push (X)(L) => Returns List w/ X in front of L
• Pop (L) => Returns List w/o L's Head
  • NOTE: "_back" versions may be self-implemented via "Backward" fcn (More Below)

FILTER/MAP/VOIDMAP:

• Filter (F1)(L) => Returns List having filtered out elts from L NOT passing F1
• Map (F1)(L) => Returns List having mapped F1 across all of L's elts
• VoidMap (F1)(L) => Returns Void & F1 Must be void, Apply Fcn to each elt in L
  
  • NOTE VoidMap helps passing "printer" fcns (ie nshow) to print each elt

REVERSED LIST & FCN APPLICATION:

• Reverse (L) => Returns List of L in reverse
• FlipArgs (F2) => Flips args for a Binary Fcn
• Backward (F1)(L) => Returns List having applied F on Reverse(L)
• BackwardAtomic (F1)(L) => Returns Atom (IE Non-List Fcn) having applied F on Reverse(L)

ACCUMULATORS:

• Foldl (F2)(X)(L) => Applies F2 on L from 'l'eft to right, starting w/ 'X' & Head(L)
• Foldr (F2)(X)(L) => Applies F2 on L from 'r'ight to left, starting w/ 'X' & Last(L)

MAX/MIN:

• Max (L) => Returns Greatest value in List
• Min (L) => Returns Smallest value in List

LISP-STYLE ACCESS:

• car (L) => Returns Current Cell Value ( IE Head(L) )
• cdr (L) => Returns Next Cell ( IE Pop(L) )
• cadr (L) => Head(Pop(L))
• caddr (L) => Head(Pop(Pop(L)))
• cadddr (L) => Head(Pop(Pop(Pop(L))))
• Nested-List Access => Any permutation (length 1-4) of 'a' & 'd' btwn 'c' & 'r'!

---

IF YOU'VE GOTTEN THIS FAR ...

You may genuinely enjoy the 2 JS Lambda Calculus videos below, found at:

• Part 1: https://www.youtube.com/watch?v=3VQ382QG-y4&feature=youtu.be
• Part 2: https://www.youtube.com/watch?v=pAnLQ9jwN-E

In Summary:

• Identity/Once, Idiot: I := \a.a

• First/True/Const, Kestrel: K := \ab.a

• Flip/LogicalNot, Cardinal: C := \fab.fba

• Unary Compose, Bluebird: B := \fga.f(ga)

• Self-Replication, Mockingbird M := \f.f(f) => IMPOSSIBLE IN HASKELL (Infinite Data Struct)

• Second/False/Zero, Kite: KI := \ab.b = K I = C K

• Binary Compose, Blackbird: B1 := \fgab.f(gab) = B B B

• Singleton/HoldArg, Thrush: Th := \af.fa = C I

• Tuple/HoldArgPair, Vireo: V := \abf.fab = B C Th = B C (C I)