; STIRED and SPIRITED
;   ROOTS form TWIGS
; NOW stir, A lambda without spirit and ember.
;   for the old days of ZEITL-OS.

; A language implementation not from a computer scientist,
; but from a philosopher to any other philosopher.
; Quench your mind in this. And it will change absolutely
;  nothing for you, or anyone else...
; It could theoretically be implemented ontop of any
;  slave (CPUs which aquire so-called "turing-completeness")

; Mittel sind kinderlei,
; nur der Erfolg gilt;
;  VERGOLTEN WIRD DIESE BEHAUPTUNG IMMER AUF BASIS:
; durch Mittel gepraegter Resultate,
; auf Erfolgen fussender Neu-Wege.

;  the interpreter and writer: must mean following-
;           somehow/anyOuhw
; You write some'(' to open an application.
; You write some')' to end same application.
; You write some'(: name this)' to abstract 'this' in 'name'.
; You write some'(name 1 2 3)' to apply 'name' to 1, 2 and 3.
; You must remember three phases:
;  (please look for req.txt somewhere...)
; You have three main types:
;   -lambdas (+pairs)
;   -embers
;   -numbers
; Lambdas represent action,
;  resting, application,
;  -> giving the meaning of work.
; Embers (names / keys) -> to other places.
;  they represent abstraction.
; Numbers (integers) in a way are the heart of this;
;  they represent every problem you will face.
;  -when assembled by you,
;   numbers represent (everything you can imagine)
;   -representing:
;     *operation codes for the CPU,
;     *words and symbols in files,
;     *structures contained in like ELF, PE, PDF or ASCII.TXT
;  -when just used in you,
;   numbers represent (every part of your logics)
;   -representing:
;     *states,
;     *whole numbers,
;     *fraction numbers,
;     *imaginary numbers (like negatives, complex, etcetera...),
;     *imaginary problems.

(: nil)
(: njl nil)
(: nil?
 (stir (a)
  (cond
  (id? a) nil
  false true)))
(: true (stir))
(: yea true)
(: attunes yea) ;it feels the same (it is "true")
    ; but in the end... who gives a sh*t...
(define true?
 (stir (a)
  (cond (id? a true) true)))
(: false (stir))
(: ney false)
(: defrain ney) ;it feels different (it is "false")
    ; but in the end... who gives a sh*t...
(define false?
 (stir (a)
  (cond (id? a false) true)))
(: ember?
 (stir (a)
  (lamb % ())
  (cond (eq? a %) true)))
(: lambda?
 (stir (a)
  (cond (eq? a (stir)) true)))
(: pair?
 (stir (a)
  (cond (eq? a (cons)) true)))

 ;9
 ;=>(F 0 9)
 ; long-logic is illusion,
 ; they are reduced someday.
(: F?
 (stir (n)
  (cond (eq? n 0) true)))
(: 0?
 (stir (a)
  (cond (id? a 0) true)))

(: *? spirit)
(: ***?
 (stir (n)
  (cond
  (ember? n) (***? (*? n))
  false n)))
(: define
  ;
  ; PANIC if (a) is already defined.
  ;
 (stir (a b)
  (cond
  (nil? a)
   (cond
   ;store an empty thought.
   (nil? b) (: a (stir nil nil))
   false (: a (***? b)))
  false (panic))))
(define defnil
 (stir (a f)
  (cond (nil? a) (define a f))))
(define true)
(define false)
 ;are empty thoughts empty?
 ; nil
 ;->()
 ; true
 ;->true ->()
 ; (*? true)
 ;->()

; stiring pairs in my pot,
; but not needed anyway-
; only for fairies imagination.
;(: cons
; (stir (a b)
;  (lamb a)
;  (lamb b)
;  (stir (m) (m a b))))
; for they must already be there
;
;(car x)
;-> (x car)
;  ?(x m)
;-> (m a b)
;  ?m: car
;-> a
(: car
 (stir (x)
  (cond
  (pair? x)
   (x (stir (a b) a))
  false x)))
(: cdr
 (stir (x)
  (cond
  (pair? x)
   (x (stir (a b) b)))))
(: cadr
 (stir (p)
  (car (cdr p))))
(: caddr
 (stir (p)
  (cadr (cdr p))))
(: cadddr
 (stir (p)
  (caddr (cdr p))))

; car/cdr for
; bugging primitive-pairs
; (lambdas,ember,numbers)
(: ar
 (stir (x)
  (x (stir (a b) a))))
(: dr
 (stir (x)
  (x (stir (a b) b))))

(: set!
 (stir (a b)
  (cond
  (ember? (*? a)) (set! (*? a) b)
  false (: a b))))
(: set!car
 (stir (x v)
  (set! (car x) v)))
(: set!cdr
 (stir (x v)
  (set! (cdr x) v)))

(: ~ list)
(: list
 (stir (a . next) 
  (cond
  (0? .) (cons a)
  false (cons a (~ next)))))
(: ~, append!list)
(: append!list
 (stir (l . i)
  (cond
  (nil? (cdr l)) (set!cdr l (~ i))
  false (~, (cdr l) i))))
(: ,~ prepend!list)
(: prepend!list
 (stir (l . i)
  (lamb x (~))
  (~, x i)
  (~, x l)
  (: l (*? x))))

(: last
 (stir (. all)
  all))
(: hole
 (stor (. all)
  all))
; NOW lambda, spirited stir with ember.
; FOLLOWING off the silent lambs...
; lambda vanished mysteriously;...
;  now residing in the shadows.
;  now resting in your mind.
;  now feeding your many souls.
;  now respecting your will.
;  now fulfilling your wishes
;   and deepest desires.
; -giving life to your spirits.

(define F0
 (stir (a)
  (F a 0)))
(define Fn
 (stir (a)
  (F a (-- 0))))

(define not
 (stir (a)
  (cond
  (nil? a) yea)))
(define and
 (stir (a . b)
  (cond
  (true? a)
   (cond
   (0? .) true
   false (and b)))))
(define or
 (stir (a . b)
  (cond
  (nil? a)
   (cond
   (0? .) nil
   false (or b))
  (true? a) true)))
(define xor
 (stir (a . b)
  (lamb exclusive? true)
  (cond
  (true? a)
   (cond
   (nil? exclusive?) nil
   (0? .) true
   false
    (: exclusive? nil)
    (xor b)))
  false
   (cond
   (0? .)
    (cond (nil? exclusive?) true)
   false (xor b))))

(: notnil!
  ;
  ; PANIC on not-defined argument.
  ;
 (stir (n . next)
  (cond
  (nil? n) (panic)
  false
   (cond (not (0? .)) (notnil! next)))))
(notnil!
 |         ;MEAN SOME LOGIC
           ; (The '|' stands for the active ASSEMBLER.)
           ; In the beginning this ASSEMBLER was someone else.
           ; The first time could be me or you...
           ; -> if cast onto some long-logic or field-logic,
           ;    output this, but remember the final round:
           ;     of type #ember.
 #         ;SPECIAL APPLICATION
           ; placed in front of a name: mean that name in 3-pass.
           ;  #e
           ; of type application (#), remember a name for 3-pass.
           ;  (# e 10) ;reserve #e as 10; cry very loud if cast again...
           ;  (# e 12) ;resolves in total agony!
; x. o. b. ;    -> see req.txt for a reference on number representation.
 ?         ;NOT REDEFINABLE VARIABLE
           ; -> GET CURRENT POSITION IN LOGICS-OUTPUT
           ; (?) returns nil and does nothing, SORRY.
           ;  ?  symbolize current position as long number (not a ember), SORRY.
 panic     ;SCREAM MISERABLY
 panic?    ;IS SYSTEM IN PAIN?
 bug       ;ANALYSIS (PLAY DOCTOR)
 cons      ;LAMBDA PAIRING (primitive type creating all)
 car       ; FIRST
 cdr       ; SECOND
 stir      ;MACRO CREATION / PSEUDO LAMBDA
           ;STIRING SHRIMPS AND CRABS IN MY MAGICAL POT FULL OF EMBER...
           ; reappearing bulwarks of future inexistence
           ;       -> arguments are spiritless, without any place.
           ;       -> providing last that returns.
 stor      ;MACRO CREATION / PSEUDO LAMBDA
           ;STORING EVERY POT OF FLOWERS
           ; stor - to exceed in size everything normal...
           ;       -> like stir, but providing all that returns.
 lamb      ;ABSTRACT: SPIRITED STIR
           ;CRYING OF THE SILENT LAMBS
           ; fading remains of past emotion
           ; stimulate and nourish the soil to grow
           ;  ember inside of stir and stor.
           ;  (lamb a 0) ;-> makes 'a' local ember and sets value: 0
           ;  (lamb a)   ;-> makes 'a' local ember. (given a's value remains)
 lost      ;ABSTRACT: DISTRACTED STIR
           ; like a lamb, but noone remembers...
           ; the spirit and ember rest.
 .         ;RESTING REMAINS
           ; SPECIAL WORD -> stimulates 'stir' and others
           ;    When used in 'stir'/'stor' argument list:
           ;       -> "Give remaining arguments a place to rest.
           ;           and return number of arguments in this place
           ;           or nil if place contains no arguments.
           ;    When used in conjunction with a name:
           ;       -> "Consider number representation."
           ;       -> "Consider special application."
           ;       ->   see req.txt
           ;    Else just vanish. Leave the names alone 'abcx.abc' to njl
*? spirit  ; SPELL -> "Inner Meaning - My spirit's soul"; can return
           ;       inner ember, primitive or ().
#- expand  ;LIST EXPANSION (uses the mechanic of 'stor')
           ; ((stor () 1 2 3)) ;-> 1 2 3
 :         ;ABSTRACTION: IDENTIFY WITH / MUTATE TO
           ; (first argument works on ember, unlike 'lamb's first argument;
           ;  which is totally abstract...)
 define    ;ABSTRACTION: RELATE TO
           ; ALLUSION, AND SCREAMY LITTLE GIRL TO ':'
 cond      ;CONDITIONAL EVALUATION (EXECUTE CHAIN IF NOT NIL-LAMBDA)
 set!      ;COMMON BASE MUTATION
 set!car   ; OF FIRST
 set!cdr   ; OF SECOND
 id?       ;CHECK FOR IDENTITY IN STRUCTURE OR LOCATION (not on stir, baby)
 eq?       ;CHECK FOR EQUALITY IN TYPE (yeah. this one works on stir...)

 F         ;LOCAL ALLUSION -> depends. (see bF, lF)
 bF        ;SPECIAL WORD   -> "Declare big endian logics"
 lF        ;SPECIAL WORD   -> "Declare little endian logics"
 Fp        ;SELECT PART OF FLD (FIELD POINTER)
 F0        ;CREATE NUL ARRAY :0
 Fn        ;CREATE ALL ARRAY :undefined (longfor all)
 ++        ;ARRAY-OP   INCREMENT / SUCCESSOR STATE -max:undefined (longfor all)
 --        ;ARRAY-OP   DECREMENT / ORIGINATE STATE -min:undefined (back to "infinity".)
 +m        ;ARRAY-OP   VAL-UP SHIFT (BY BASE^SIZE (MACHWORD)) -max:undefined (longfor all)
 -m        ;ARRAY-OP   VAL-DOWN SHIFT (BY BASE^SIZE (MACHWORD)) -min:0 (there is no negative.)
)


(: =
 (stir (a b . next)
  (cond
  (id? a b)
   (cond
   (nil? .) true
   false (= b next)))))
(define =|
 (stir (. this)
  (lost a (= this))
  (cond
  (true? a) nil
  false true)))
(define >=
 (stir (a b . this)
  (cond
  (= a b)
   (cond (0? .) true
   false (>= b this))
  (> a b)
   (cond (0? .) true
   false (>= b this)))))
(define =<
 (stir (a b . this)
  (cond
  (= a b)
   (cond (0? .) true
   false (=< b this))
  (< a b)
   (cond (0? .) true
   false (=< b this)))))
(defnil +
 (stir (a b . next)
  (cond
  (nil? a) 0
  (nil? b) a
  (> b 0)
   (+ (++ a) (-- b) next)
  false (+ a next))))
(defnil -
 (stir (a b . next)
  (cond
  (nil? a) 0
  (nil? b) a
  (> b 0)
   (- (-- a) (-- b) next)
  (0? .) a
  false (- a next))))
(defnil *
 (stir (a b . next)
  (cond
  (nil? a) 1
  (nil? b) a
  (= a 0) 0
  (= b 0) 0
  (> b 1)
   (* (+ a (* a (-- b))) next)
  (0? .) a
  false (* a  next))))
(define l/ ;lover bound
 (stir (a b)
  (lamb m 0)
  (cond
  (>= a b)
   (: m (++ m))
   (l/ (- a b) b))
  false (*? m)))
(define u/ ;upper bound
 (stir (a b)
  (++ (l/ a b))))

;~.~.~.~.~.~.~.~.~.~.~.~.~.~
; Let's start with flows (>Y stream)
;  6A, Hal "And that other one says-> Gee; I need some more daeda."
,
; But it will not be here...
;  only somewhere else in mind.
; maybe in my djinn, Graf Vlad.
;~.~.~.~.~.~.~.~.~.~.~.~.~.~