Sunday, April 13, 2014

LHCA.zc

(bitBack) bit0 bit1 byte uchar uchar uchar uchar
comment:
#true
(004) "bitBack" bit0 bit1 byte
 
(bitBackwardCaseOneFalse) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseOneFalse" byte
 
(bitBackwardCaseOneTrue) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseOneTrue" byte
 
(bitBackwardCaseTwoFalseFalse) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseTwoFalseFalse" byte
 
(bitBackwardCaseTwoFalseTrue) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseTwoFalseTrue" byte
 
(bitBackwardCaseTwoTrueFalse) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseTwoTrueFalse" byte
 
(bitBackwardCaseTwoTrueTrue) byte uchar uchar
comment:
#true
(002) "bitBackwardCaseTwoTrueTrue" byte
 
(bitRule) rule one two three uchar uchar uchar uchar uchar
comment:
rule
(bitRuleOneFifty) one two three
 
(bitRule) rule one two three uchar uchar uchar uchar uchar
comment:
#true
(bitRuleNinety) one two three
 
(bitRuleNinety) one two three uchar uchar uchar uchar
comment:
#true
(bitXor) one three
 
(bitRuleOneFifty) one two three uchar uchar uchar uchar
comment:
#true
(bitXor) two (bitXor) one three
 
(bitsBackwardCaseOne) bit bits ucharP uchar ucharP
comment:
#true
(bitsBackwardCaseOne1) bit bits (ucharArrayNew) 9
 
(bitsBackwardCaseOne1) bit input output ucharP uchar ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1a) input (ucharArraySet) 1 bit (ucharArraySet) 2 (bitRule) #false 0 bit (ucharArrayRef) 1 input output
 
(bitsBackwardCaseOne1a) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1b) input (ucharArraySet) 3 (bitRule) #false (ucharArrayRef) 1 output (ucharArrayRef) 2 output (ucharArrayRef) 2 input output
 
(bitsBackwardCaseOne1b) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1c) input (ucharArraySet) 4 (bitRule) #true (ucharArrayRef) 2 output (ucharArrayRef) 3 output (ucharArrayRef) 3 input output
 
(bitsBackwardCaseOne1c) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1d) input (ucharArraySet) 5 (bitRule) #false (ucharArrayRef) 3 output (ucharArrayRef) 4 output (ucharArrayRef) 4 input output
 
(bitsBackwardCaseOne1d) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1e) input (ucharArraySet) 6 (bitRule) #true (ucharArrayRef) 4 output (ucharArrayRef) 5 output (ucharArrayRef) 5 input output
 
(bitsBackwardCaseOne1e) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1f) input (ucharArraySet) 7 (bitRule) #false (ucharArrayRef) 5 output (ucharArrayRef) 6 output (ucharArrayRef) 6 input output
 
(bitsBackwardCaseOne1f) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseOne1g) input (ucharArraySet) 8 (bitRule) #false (ucharArrayRef) 6 output (ucharArrayRef) 7 output (ucharArrayRef) 7 input output
 
(bitsBackwardCaseOne1g) input output ucharP ucharP ucharP
comment:
#true
(ucharArraySet) 9 (bitRule) #false (ucharArrayRef) 7 output (ucharArrayRef) 8 output (ucharArrayRef) 8 input output
 
(bitsBackwardCaseOneFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseOneFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsBackwardCaseOneTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseOneTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsBackwardCaseTwo) bit1 bit2 bits ucharP uchar uchar ucharP
comment:
#true
(bitsBackwardCaseTwo1) bit1 bit2 bits (ucharArrayNew) 9
 
(bitsBackwardCaseTwo1) bit1 bit2 input output ucharP uchar uchar ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1a) input (ucharArraySet) 1 bit2 (ucharArraySet) 2 (bitRule) #false bit1 bit2 (ucharArrayRef) 1 input output
 
(bitsBackwardCaseTwo1a) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1b) input (ucharArraySet) 3 (bitRule) #false (ucharArrayRef) 1 output (ucharArrayRef) 2 output (ucharArrayRef) 2 input output
 
(bitsBackwardCaseTwo1b) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1c) input (ucharArraySet) 4 (bitRule) #false (ucharArrayRef) 2 output (ucharArrayRef) 3 output (ucharArrayRef) 3 input output
 
(bitsBackwardCaseTwo1c) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1d) input (ucharArraySet) 5 (bitRule) #false (ucharArrayRef) 3 output (ucharArrayRef) 4 output (ucharArrayRef) 4 input output
 
(bitsBackwardCaseTwo1d) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1e) input (ucharArraySet) 6 (bitRule) #false (ucharArrayRef) 4 output (ucharArrayRef) 5 output (ucharArrayRef) 5 input output
 
(bitsBackwardCaseTwo1e) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1f) input (ucharArraySet) 7 (bitRule) #false (ucharArrayRef) 5 output (ucharArrayRef) 6 output (ucharArrayRef) 6 input output
 
(bitsBackwardCaseTwo1f) input output ucharP ucharP ucharP
comment:
#true
(bitsBackwardCaseTwo1g) input (ucharArraySet) 8 (bitRule) #false (ucharArrayRef) 6 output (ucharArrayRef) 7 output (ucharArrayRef) 7 input output
 
(bitsBackwardCaseTwo1g) input output ucharP ucharP ucharP
comment:
#true
(ucharArraySet) 9 (bitRule) #false (ucharArrayRef) 7 output (ucharArrayRef) 8 output (ucharArrayRef) 8 input output
 
(bitsBackwardCaseTwoFalseFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseTwoFalseFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsBackwardCaseTwoFalseTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseTwoFalseTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsBackwardCaseTwoTrueFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseTwoTrueFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsBackwardCaseTwoTrueTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbitBackwardCaseTwoTrueTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bitsByte) byte ucharP uchar
comment:
#true
(bitsByte1) byte 1
 
(bitsByte1) byte count ucharP uchar uchar
comment:
"ZEDcount>8"
(ucharArrayNew) 8
 
(bitsByte1) byte count ucharP uchar uchar
comment:
"ZEDbyte>127"
(ucharArraySet) count #true (bitsByte1) "ZEDbyte<<1" "ZEDcount+1"
 
(bitsByte1) byte count ucharP uchar uchar
comment:
#true
(ucharArraySet) count #false (bitsByte1) "ZEDbyte<<1" "ZEDcount+1"
 
(bitsForwardCaseOne) leftBit rightBit bits ucharP uchar uchar ucharP
comment:
#true
(ucharArraySet) 1 (bitRule) #false leftBit (ucharArrayRef) 1 bits (ucharArrayRef) 2 bits (ucharArraySet) 2 (bitRule) #false (ucharArrayRef) 1 bits (ucharArrayRef) 2 bits (ucharArrayRef) 3 bits (ucharArraySet) 3 (bitRule) #true (ucharArrayRef) 2 bits (ucharArrayRef) 3 bits (ucharArrayRef) 4 bits (ucharArraySet) 4 (bitRule) #false (ucharArrayRef) 3 bits (ucharArrayRef) 4 bits (ucharArrayRef) 5 bits (ucharArraySet) 5 (bitRule) #true (ucharArrayRef) 4 bits (ucharArrayRef) 5 bits (ucharArrayRef) 6 bits (ucharArraySet) 6 (bitRule) #false (ucharArrayRef) 5 bits (ucharArrayRef) 6 bits (ucharArrayRef) 7 bits (ucharArraySet) 7 (bitRule) #false (ucharArrayRef) 6 bits (ucharArrayRef) 7 bits (ucharArrayRef) 8 bits (ucharArraySet) 8 (bitRule) #false (ucharArrayRef) 7 bits (ucharArrayRef) 8 bits rightBit (ucharArrayNew) 8
 
(bitsForwardCaseTwo) leftBit rightBit bits ucharP uchar uchar ucharP
comment:
#true
(ucharArraySet) 1 (bitRule) #false leftBit (ucharArrayRef) 1 bits (ucharArrayRef) 2 bits (ucharArraySet) 2 (bitRule) #false (ucharArrayRef) 1 bits (ucharArrayRef) 2 bits (ucharArrayRef) 3 bits (ucharArraySet) 3 (bitRule) #false (ucharArrayRef) 2 bits (ucharArrayRef) 3 bits (ucharArrayRef) 4 bits (ucharArraySet) 4 (bitRule) #false (ucharArrayRef) 3 bits (ucharArrayRef) 4 bits (ucharArrayRef) 5 bits (ucharArraySet) 5 (bitRule) #false (ucharArrayRef) 4 bits (ucharArrayRef) 5 bits (ucharArrayRef) 6 bits (ucharArraySet) 6 (bitRule) #false (ucharArrayRef) 5 bits (ucharArrayRef) 6 bits (ucharArrayRef) 7 bits (ucharArraySet) 7 (bitRule) #false (ucharArrayRef) 6 bits (ucharArrayRef) 7 bits (ucharArrayRef) 8 bits (ucharArraySet) 8 (bitRule) #false (ucharArrayRef) 7 bits (ucharArrayRef) 8 bits rightBit (ucharArrayNew) 8
 
(bitXor) one two uchar uchar uchar
comment:
#true
"ZEDone!=ZEDtwo"
 
(byteBack) bit0 bit1 byte uchar uchar uchar uchar
comment:
#true
(004) "byteBack" bit0 bit1 byte
 
(byteBackwardCaseOneFalse) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseOneFalse" byte
 
(byteBackwardCaseOneTrue) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseOneTrue" byte
 
(byteBackwardCaseTwoFalseFalse) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseTwoFalseFalse" byte
 
(byteBackwardCaseTwoFalseTrue) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseTwoFalseTrue" byte
 
(byteBackwardCaseTwoTrueFalse) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseTwoTrueFalse" byte
 
(byteBackwardCaseTwoTrueTrue) byte uchar uchar
comment:
#true
(002) "byteBackwardCaseTwoTrueTrue" byte
 
(byteBits) bits uchar ucharP
comment:
#true
(byteBits1) bits 0 1
 
(byteBits1) bits byte count uchar ucharP uchar uchar
comment:
"ZEDcount==8"
(ucharAdd) byte (ucharArrayRef) count bits
 
(byteBits1) bits byte count uchar ucharP uchar uchar
comment:
#true
(byteBits1) bits (ucharShiftLeft) (ucharAdd) byte (ucharArrayRef) count bits "ZEDcount+1"
 
(byteEightForward) uchar
comment:
#true
(byteTwoForward1) (byteSevenRef) (byteEightRef) 0
 
(byteEightRef) uchar
comment:
#true
(ucharArrayRef) 8 state
 
(byteEightSet) character ucharP uchar
comment:
#true
(ucharArraySet) 8 character state
 
(byteFiveForward) uchar
comment:
#true
(byteTwoForward1) (byteFourRef) (byteFiveRef) (byteSixRef)
 
(byteFiveRef) uchar
comment:
#true
(ucharArrayRef) 5 state
 
(byteFiveSet) character ucharP uchar
comment:
#true
(ucharArraySet) 5 character state
 
(byteForwardCaseOneFalse) byte uchar uchar
comment:
#true
(002) "byteForwardCaseOneFalse" byte
 
(byteForwardCaseOneTrue) byte uchar uchar
comment:
#true
(002) "byteForwardCaseOneTrue" byte
 
(byteForwardCaseTwoFalseFalse) byte uchar uchar
comment:
#true
(002) "byteForwardCaseTwoFalseFalse" byte
 
(byteForwardCaseTwoFalseTrue) byte uchar uchar
comment:
#true
(002) "byteForwardCaseTwoFalseTrue" byte
 
(byteForwardCaseTwoTrueFalse) byte uchar uchar
comment:
#true
(002) "byteForwardCaseTwoTrueFalse" byte
 
(byteForwardCaseTwoTrueTrue) byte uchar uchar
comment:
#true
(002) "byteForwardCaseTwoTrueTrue" byte
 
(byteFourForward) uchar
comment:
#true
(byteTwoForward1) (byteThreeRef) (byteFourRef) (byteFiveRef)
 
(byteFourRef) uchar
comment:
#true
(ucharArrayRef) 4 state
 
(byteFourSet) character ucharP uchar
comment:
#true
(ucharArraySet) 4 character state
 
(byteOneForward) uchar
comment:
#true
(byteOneForward1) (byteOneRef) (byteTwoRef)
 
(byteOneForward1) one two uchar uchar uchar
comment:
"ZEDtwo>127"
(ucharArrayRef) "ZEDone+1" byteTableForwardCaseOneTrue
 
(byteOneForward1) one two uchar uchar uchar
comment:
#true
(ucharArrayRef) "ZEDone+1" byteTableForwardCaseOneFalse
 
(byteOneRef) uchar
comment:
#true
(ucharArrayRef) 1 state
 
(byteOneSet) character ucharP uchar
comment:
#true
(ucharArraySet) 1 character state
 
(bytesBackwardCaseOneFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseOneFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesBackwardCaseOneTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseOneTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesBackwardCaseTwoFalseFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseTwoFalseFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesBackwardCaseTwoFalseTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseTwoFalseTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesBackwardCaseTwoTrueFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseTwoTrueFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesBackwardCaseTwoTrueTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteBackwardCaseTwoTrueTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(byteSevenForward) uchar
comment:
#true
(byteTwoForward1) (byteSixRef) (byteSevenRef) (byteEightRef)
 
(byteSevenRef) uchar
comment:
#true
(ucharArrayRef) 7 state
 
(byteSevenSet) character ucharP uchar
comment:
#true
(ucharArraySet) 7 character state
 
(bytesForwardCaseOneFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseOneFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesForwardCaseOneTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseOneTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesForwardCaseTwoFalseFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseTwoFalseFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesForwardCaseTwoFalseTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseTwoFalseTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesForwardCaseTwoTrueFalse) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseTwoTrueFalse" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(bytesForwardCaseTwoTrueTrue) ucharP
comment:
#true
(004) "ucharArrayMap" "&ZEDbyteForwardCaseTwoTrueTrue" 256 (ucharArrayPrepare) 256 (ucharArrayNew) 256
 
(byteSixForward) uchar
comment:
#true
(byteTwoForward1) (byteFiveRef) (byteSixRef) (byteSevenRef)
 
(byteSixRef) uchar
comment:
#true
(ucharArrayRef) 6 state
 
(byteSixSet) character ucharP uchar
comment:
#true
(ucharArraySet) 6 character state
 
(bytesState) ucharP
comment:
#true
(ucharArraySet) 1 #1 (ucharArraySet) 2 #2 (ucharArraySet) 3 #2 (ucharArraySet) 4 #7 (ucharArraySet) 5 #1 (ucharArraySet) 6 #9 (ucharArraySet) 7 #7 (ucharArraySet) 8 #6 (ucharArrayNew) 8
 
(byteThreeForward) uchar
comment:
#true
(byteTwoForward1) (byteTwoRef) (byteThreeRef) (byteFourRef)
 
(byteThreeRef) uchar
comment:
#true
(ucharArrayRef) 3 state
 
(byteThreeSet) character ucharP uchar
comment:
#true
(ucharArraySet) 3 character state
 
(byteTwoForward) uchar
comment:
#true
(byteTwoForward1) (byteOneRef) (byteTwoRef) (byteThreeRef)
 
(byteTwoForward1) one two three uchar uchar uchar uchar
comment:
"ZEDone%2&&ZEDthree>127"
(ucharArrayRef) "ZEDtwo+1" byteTableForwardCaseTwoTrueTrue
 
(byteTwoForward1) one two three uchar uchar uchar uchar
comment:
"ZEDthree>127"
(ucharArrayRef) "ZEDtwo+1" byteTableForwardCaseTwoFalseTrue
 
(byteTwoForward1) one two three uchar uchar uchar uchar
comment:
"ZEDone%2==1"
(ucharArrayRef) "ZEDtwo+1" byteTableForwardCaseTwoTrueFalse
 
(byteTwoForward1) one two three uchar uchar uchar uchar
comment:
#true
(ucharArrayRef) "ZEDtwo+1" byteTableForwardCaseTwoFalseFalse
 
(byteTwoRef) uchar
comment:
#true
(ucharArrayRef) 2 state
 
(byteTwoSet) character ucharP uchar
comment:
#true
(ucharArraySet) 2 character state
 
(ucharAdd) one two uchar uchar uchar
comment:
#true
"ZEDone+ZEDtwo"
 
(ucharArrayNew) size ucharP ulonglong
comment:
#true
(002) "ucharArrayNew" size
 
(ucharArrayPrepare) size array ucharP ulonglong ucharP
comment:
"ZEDsize==0"
array
 
(ucharArrayPrepare) size array ucharP ulonglong ucharP
comment:
#true
(ucharArrayPrepare) "ZEDsize-1" (ucharArraySet) size "ZEDsize-1" array
 
(ucharArrayRef) index array uchar ulonglong ucharP
comment:
#true
(003) "ucharArrayRef" index array
 
(ucharArraySet) index character array ucharP ulonglong uchar ucharP
comment:
#true
(004) "ucharArraySet" index character array
 
(ucharShiftLeft) character uchar uchar
comment:
#true
"ZEDcharacter<<1"
 
(ucharTableBackward) byte table uchar uchar ucharP
comment:
#true
(ucharArrayRef) (ulonglongAdd) 1 (ulonglongCastUchar) byte table
 
(ulonglongAdd) one two ulonglong ulonglong ulonglong
comment:
#true
"ZEDone+ZEDtwo"
 
(ulonglongCastUchar) character ulonglong uchar
comment:
#true
(002) "ulonglongCastUchar" character

ZEDc.scm

    (begin (define (ZED* ZEDnumber1 ZEDnumber2) (cond (#t (* ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED+ ZEDnumber1 ZEDnumber2) (cond (#t (+ ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED- ZEDnumber1 ZEDnumber2) (cond (#t (- ZEDnumber1 ZEDnumbe2)) (else err))) (define (ZED/ ZEDnumber1 ZEDnumber2) (cond (#t (/ ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED= value1 value2) (cond (#t (eqv? value1 value2)) (else err))) (define (ZEDadd-between! item list collect) (cond ((null? list) collect) ((null? (cdr list)) (cons (car list) collect)) (#t (ZEDadd-between! item (cdr list) (cons item (cons (car list) collect)))) (else err))) (define (ZEDadd-between item list) (cond (#t (reverse (ZEDadd-between! item list (quote ())))) (else err))) (define (ZEDadd-between-ra list item) (cond (#t (reverse (ZEDadd-between! item list (quote ())))) (else err))) (define (ZEDaddBetweenTwo ZEDitem ZEDstack) (cond ((ZEDnull? ZEDstack) (quote ())) ((ZEDnull? (ZEDpop (ZEDpop ZEDstack))) ZEDstack) (#t (ZEDpush (ZEDtop ZEDstack) (ZEDpush (ZEDtop (ZEDpop ZEDstack)) (ZEDpush ZEDitem (ZEDaddBetweenTwo ZEDitem (ZEDpop (ZEDpop ZEDstack))))))) (else err))) (define (ZEDalpha) (cond (#t (ZEDwrite-all (ZEDrd (quote ()) append (ZEDrd (quote ()) append (ZEDnewlines (ZEDby-four (ZEDfunction-sort (ZEDsentences (ZEDleading-newline (ZEDspace-newline (ZEDtab-replace (ZEDnewline-space-tab-repeats (ZEDnewline-space (ZEDfilter ZEDnot-return? (ZEDreplace-trailing-white-space (ZEDread-all)))))))))))))))) (else err))) (define (ZEDapplication? expression) (cond (#t (and (not (null? expression)) (pair? (car expression)) (null? (cdar expression)))) (else err))) (define (ZEDarity arity-hash function) (cond (#t (cdr (assoc function arity-hash))) (else err))) (define (ZEDarity-hash! clause) (cond (#t (cons (ZEDclause-name clause) (ZEDclause-arity clause))) (else err))) (define (ZEDarity-hash program) (cond (#t (append (map ZEDarity-hash! program) (append (list (cons (quote ZED1) 1) (cons (quote ZED!) 1) (cons (quote ZED001) 1) (cons (quote or) 2) (cons (quote and) 2) (cons (quote begin) 2) (cons (quote ZEDc) 2) (cons (quote quote) 1)) (list (cons (quote ZED002) 2) (cons (quote ZED003) 3) (cons (quote ZED004) 4) (cons (quote ZED005) 5) (cons (quote ZED006) 6) (cons (quote ZED007) 7) (cons (quote ZED008) 8) (cons (quote ZED009) 9) (cons (quote ZED010) 10) (cons (quote ZED011) 11) (cons (quote ZED012) 12) (cons (quote ZED013) 13) (cons (quote ZED014) 14) (cons (quote ZED015) 15) (cons (quote ZED016) 16) (cons (quote ZED017) 17) (cons (quote ZED018) 18) (cons (quote ZED019) 19) (cons (quote ZED020) 20) (cons (quote ZED021) 21) (cons (quote ZED022) 22) (cons (quote ZED023) 23) (cons (quote ZED024) 24) (cons (quote ZED025) 25) (cons (quote ZED026) 26) (cons (quote ZED027) 27) (cons (quote ZED028) 28) (cons (quote ZED029) 29) (cons (quote ZED030) 30) (cons (quote ZED031) 31) (cons (quote ZED032) 32) (cons (quote ZED033) 33) (cons (quote ZED034) 34) (cons (quote ZED035) 35) (cons (quote ZED036) 36) (cons (quote ZED037) 37) (cons (quote ZED038) 38) (cons (quote ZED039) 39) (cons (quote ZED040) 40) (cons (quote ZED041) 41) (cons (quote ZED042) 42) (cons (quote ZED043) 43) (cons (quote ZED044) 44) (cons (quote ZED045) 45) (cons (quote ZED046) 46) (cons (quote ZED047) 47) (cons (quote ZED048) 48) (cons (quote ZED049) 49) (cons (quote ZED050) 50) (cons (quote ZED051) 51) (cons (quote ZED052) 52) (cons (quote ZED053) 53) (cons (quote ZED054) 54) (cons (quote ZED055) 55) (cons (quote ZED056) 56) (cons (quote ZED057) 57) (cons (quote ZED058) 58) (cons (quote ZED059) 59) (cons (quote ZED060) 60) (cons (quote ZED061) 61) (cons (quote ZED062) 62) (cons (quote ZED063) 63) (cons (quote ZED064) 64) (cons (quote ZED065) 65) (cons (quote ZED066) 66) (cons (quote ZED067) 67) (cons (quote ZED068) 68) (cons (quote ZED069) 69) (cons (quote ZED070) 70) (cons (quote ZED071) 71) (cons (quote ZED072) 72) (cons (quote ZED073) 73) (cons (quote ZED074) 74) (cons (quote ZED075) 75) (cons (quote ZED076) 76) (cons (quote ZED077) 77) (cons (quote ZED078) 78) (cons (quote ZED079) 79) (cons (quote ZED080) 80) (cons (quote ZED081) 81) (cons (quote ZED082) 82) (cons (quote ZED083) 83) (cons (quote ZED084) 84) (cons (quote ZED085) 85) (cons (quote ZED086) 86) (cons (quote ZED087) 87) (cons (quote ZED088) 88) (cons (quote ZED089) 89) (cons (quote ZED090) 90) (cons (quote ZED091) 91) (cons (quote ZED092) 92) (cons (quote ZED093) 93) (cons (quote ZED094) 94) (cons (quote ZED095) 95) (cons (quote ZED096) 96) (cons (quote ZED097) 97) (cons (quote ZED098) 98) (cons (quote ZED099) 99))))) (else err))) (define (ZEDby-four! sentences collect) (cond ((null? sentences) collect) (#t (ZEDby-four! (cddddr sentences) (cons (list (car sentences) (cadr sentences) (caddr sentences) (cadddr sentences)) collect))) (else err))) (define (ZEDby-four sentences) (cond (#t (reverse (ZEDby-four! sentences (quote ())))) (else err))) (define (ZEDby-three! sentences collect) (cond ((null? sentences) collect) (#t (ZEDby-three! (cdddr sentences) (cons (list (car sentences) (cadr sentences) (caddr sentences)) collect))) (else err))) (define (ZEDby-three sentences) (cond (#t (reverse (ZEDby-three! sentences (quote ())))) (else err))) (define (ZEDcallingConvention ZEDexpression) (cond ((list? ZEDexpression) (ZEDcallingConvention1 (map ZEDcallingConvention ZEDexpression))) (#t (ZEDcallingConvention2 ZEDexpression)) (else err))) (define (ZEDcallingConvention1 ZEDstrings) (cond (#t (apply string-append (ZEDpush (ZEDtop ZEDstrings) (ZEDpush "(" (append (ZEDadd-between "," (ZEDpop ZEDstrings)) (list ")")))))) (else err))) (define (ZEDcallingConvention2 ZEDpart) (cond ((boolean? ZEDpart) (ZEDintegerBoolean ZEDpart)) ((char? ZEDpart) (number->string (char->integer ZEDpart))) (#t (ZEDcallingConvention21 ZEDpart (open-output-string))) (else err))) (define (ZEDcallingConvention21 ZEDpart ZEDoutput-string) (cond (#t (begin (write ZEDpart ZEDoutput-string) (ZEDcallingConvention211 ZEDoutput-string (get-output-string ZEDoutput-string)))) (else err))) (define (ZEDcallingConvention211 ZEDoutput-string ZEDstring) (cond (#t (begin (close-output-port ZEDoutput-string) ZEDstring)) (else err))) (define (ZEDcharacter-less? character1 character2) (cond (#t (< (char->integer character1) (char->integer character2))) (else err))) (define (ZEDclause-arguments clause) (cond (#t (cadr clause)) (else err))) (define (ZEDclause-arguments-agree clause1 clause2) (cond ((equal? (ZEDclause-arguments clause1) (ZEDclause-arguments clause2)) (ZEDclause-arguments clause1)) (else err))) (define (ZEDclause-arity clause) (cond (#t (/ (- (length (ZEDclause-arguments clause)) 1) 2)) (else err))) (define (ZEDclause-body clause) (cond (#t (cddr clause)) (else err))) (define (ZEDclause-less? clause1 clause2) (cond (#t (ZEDsentence-less? (car clause1) (car clause2))) (else err))) (define (ZEDclause-name clause) (cond (#t (car clause)) (else err))) (define (ZEDclause-name-agree clause1 clause2) (cond ((eq? (ZEDclause-name clause1) (ZEDclause-name clause2)) (ZEDclause-name clause1)) (else err))) (define (ZEDcombine-all! program collect) (cond ((null? program) collect) ((null? (cdr program)) (cons (car program) collect)) ((eq? (ZEDclause-name (car program)) (ZEDclause-name (cadr program))) (ZEDcombine-all! (ZEDcombine-head-clauses program) collect)) (#t (ZEDcombine-all! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDcombine-all program) (cond (#t (reverse (ZEDcombine-all! program (quote ())))) (else err))) (define (ZEDcombine-clauses clause1 clause2) (cond (#t (cons (ZEDclause-name-agree clause1 clause2) (cons (ZEDclause-arguments-agree clause1 clause2) (append (ZEDclause-body clause1) (ZEDclause-body clause2))))) (else err))) (define (ZEDcombine-head-clauses program) (cond (#t (cons (ZEDcombine-clauses (car program) (cadr program)) (cddr program))) (else err))) (define (ZEDcombine-program-clauses program) (cond (#t (ZEDcombine-all (ZEDready-program program))) (else err))) (define (ZEDcomp!) (cond (#t (ZEDcomp!a (ZEDcombine-program-clauses (ZEDby-three (ZEDread-sentences (ZEDdiscard-comments (ZEDfunction-sort (ZEDsentences (ZEDleading-newline (ZEDspace-newline (ZEDtab-replace (ZEDnewline-space-tab-repeats (ZEDnewline-space (ZEDfilter ZEDnot-return? (ZEDreplace-trailing-white-space (ZEDread-all)))))))))))))))) (else err))) (define (ZEDcomp!a combined) (cond (#t (ZEDcomp!aa (ZEDprogramize combined (ZEDarity-hash combined)))) (else err))) (define (ZEDcomp!aa programized) (cond (#t (ZEDcomp!aaa programized (open-output-string))) (else err))) (define (ZEDcomp!aaa programized output-string) (cond (#t (begin (write programized output-string) (ZEDcomp!aaaa (ZEDpop (read (open-input-string (get-output-string output-string))))))) (else err))) (define (ZEDcomp!aaaa program) (cond (#t (begin (for-each ZEDprintSignature program) (for-each ZEDprintFunction program))) (else err))) (define (ZEDcomp) (cond (#t (ZEDcomp!)) (else err))) (define (ZEDcondefy! expressions collect) (cond ((null? expressions) collect) (#t (ZEDcondefy! (cddr expressions) (cons (append (car expressions) (cadr expressions)) collect))) (else err))) (define (ZEDcondefy expressions) (cond (#t (reverse (ZEDcondefy! expressions (quote ())))) (else err))) (define (ZEDcons ZEDvalue1 ZEDvalue2) (cond (#t (cons ZEDvalue1 ZEDvalue2)) (else err))) (define (ZEDcount ZEDnumber) (cond (#t (cons (delay ZEDnumber) (delay (ZEDcount (ZED+ ZEDnumber 1))))) (else err))) (define (ZEDcount-by ZEDstep ZEDnumber) (cond (#t (cons (delay ZEDnumber) (delay (ZEDcount-by ZEDstep (ZED+ ZEDnumber ZEDstep))))) (else err))) (define (ZEDdelay-wrap expression) (cond (#t (list (quote delay) expression)) (else err))) (define (ZEDdigit? character) (cond (#t (or (eqv? #\0 character) (eqv? #\1 character) (eqv? #\2 character) (eqv? #\3 character) (eqv? #\4 character) (eqv? #\5 character) (eqv? #\6 character) (eqv? #\7 character) (eqv? #\8 character) (eqv? #\9 character))) (else err))) (define (ZEDdiscard-comments! program collect) (cond ((null? program) collect) (#t (ZEDdiscard-comments! (cddddr program) (cons (cadddr program) (cons (caddr program) (cons (car program) collect))))) (else err))) (define (ZEDdiscard-comments program) (cond (#t (reverse (ZEDdiscard-comments! program (quote ())))) (else err))) (define (ZEDdr! value) (cond ((pair? value) (ZEDmp ZEDdr! (ZEDfirst 64 value))) (#t value) (else err))) (define (ZEDdr value) (cond (#t (begin (display (ZEDpr (ZEDdr! value))) (newline) (newline) value)) (else err))) (define (ZEDdrr value) (cond (#t (begin (display (ZEDpr value)) (newline) (newline) value)) (else err))) (define (ZEDfalse? noun-list) (cond (#t (equal? noun-list (list #\# #\f #\a #\l #\s #\e))) (else err))) (define (ZEDfi function list) (cond ((null? list) (quote ())) ((function (if (promise? (car list)) (force (car list)) (car list))) (cons (delay (if (promise? (car list)) (force (car list)) (car list))) (delay (ZEDfi function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))))) (#t (ZEDfi function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (else err))) (define (ZEDfilter! predicate list collect) (cond ((null? list) collect) ((predicate (car list)) (ZEDfilter! predicate (cdr list) (cons (car list) collect))) (#t (ZEDfilter! predicate (cdr list) collect)) (else err))) (define (ZEDfilter predicate list) (cond (#t (reverse (ZEDfilter! predicate list (quote ())))) (else err))) (define (ZEDfirst! integer list collect) (cond ((or (zero? integer) (null? list)) (reverse collect)) ((not (pair? list)) (reverse (cons list collect))) ((> integer 0) (ZEDfirst! (- integer 1) (if (promise? (cdr list)) (force (cdr list)) (cdr list)) (cons (if (promise? (car list)) (force (car list)) (car list)) collect))) (else err))) (define (ZEDfirst integer list) (cond ((not (pair? list)) list) (#t (ZEDfirst! integer list (quote ()))) (else err))) (define (ZEDflatten! ZEDlist ZEDsub-list-found? ZEDcollect) (cond ((and (ZEDnull? ZEDlist) (ZEDnot ZEDsub-list-found?)) (ZEDreverse ZEDcollect)) ((ZEDnull? ZEDlist) (ZEDflatten! (ZEDreverse ZEDcollect) #f (quote ()))) ((ZEDnot (ZEDpair? ZEDlist)) (ZEDflatten! (quote ()) ZEDsub-list-found? (ZEDcons ZEDlist ZEDcollect))) ((ZEDpair? (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist))) (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) #t (ZEDcons (if (promise? (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (force (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (ZEDcons (if (promise? (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (force (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) ZEDcollect)))) ((ZEDnull? (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist))) (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) ZEDsub-list-found? ZEDcollect)) (#t (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) ZEDsub-list-found? (ZEDcons (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)) ZEDcollect))) (else err))) (define (ZEDflatten ZEDlist) (cond (#t (ZEDflatten! ZEDlist #f (quote ()))) (else err))) (define (ZEDfor-each ZEDeffect ZEDlist) (cond (#t (for-each ZEDeffect ZEDlist)) (else err))) (define (ZEDfunction expression) (cond (#t (caar expression)) (else err))) (define (ZEDfunction-sort sentences) (cond (#t (ZEDrd (quote ()) append (ZEDsort ZEDclause-less? (ZEDby-four sentences)))) (else err))) (define (ZEDfunctionize clause arity-hash) (cond (#t (list (quote define) (cons (ZEDclause-name clause) (ZEDclause-arguments clause)) (cons (quote cond) (append (ZEDcondefy (ZEDmap-with ZEDschemefy (ZEDclause-body clause) arity-hash)) (list (list (quote else) (quote err))))))) (else err))) (define (ZEDgather-count?! candidate) (cond (#t (and (= 6 (length candidate)) (eqv? #\Z (car candidate)) (eqv? #\E (cadr candidate)) (eqv? #\D (caddr candidate)) (eqv? #\0 (cadddr candidate)) (ZEDdigit? (car (cddddr candidate))) (ZEDdigit? (cadr (cddddr candidate))))) (else err))) (define (ZEDgather-count? symbol) (cond (#t (ZEDgather-count?! (string->list (symbol->string symbol)))) (else err))) (define (ZEDgather-noun sentence) (cond ((null? sentence) (quote ())) ((eqv? #\space (car sentence)) (quote ())) (#t (cons (car sentence) (ZEDgather-noun (cdr sentence)))) (else err))) (define (ZEDgather-verb sentence) (cond ((eqv? #\) (car sentence)) (quote ())) (#t (cons (car sentence) (ZEDgather-verb (cdr sentence)))) (else err))) (define (ZEDgr garbage value) (cond (#t (begin (ZEDdr garbage) value)) (else err))) (define (ZEDgrr garbage value) (cond (#t (begin (ZEDdrr garbage) value)) (else err))) (define (ZEDhalve ZEDnumber) (cond (#t (ZED/ ZEDnumber 2)) (else err))) (define (ZEDintegerBoolean ZEDbool) (cond (ZEDbool "1") (#t "0") (else err))) (define (ZEDleading-newline program) (cond ((null? program) (quote ())) ((eqv? #\newline (car program)) (cdr program)) (#t program) (else err))) (define (ZEDliteral? literal-list) (cond (#t (eqv? #\" (car literal-list))) (else err))) (define (ZEDmake-ZED ZED-list) (cond ((equal? ZED-list (list #\e #\r #\r)) "'err") ((equal? ZED-list (list #\n #\i #\l)) "'()") ((equal? ZED-list (list #\a #\n #\d)) "and") ((equal? ZED-list (list #\o #\r)) "or") ((equal? ZED-list (list #\q #\u #\o #\t #\e)) "quote") ((equal? ZED-list (list #\s #\e)) "begin") (#t (list->string (append (list #\Z #\E #\D) ZED-list))) (else err))) (define (ZEDmake-character noun-list) (cond (#t (list->string (cons #\# (cons #\\ (cdr noun-list))))) (else err))) (define (ZEDmake-exact exact-list) (cond (#t (list->string (append (list #\# #\e) exact-list))) (else err))) (define (ZEDmake-literal literal-list) (cond (#t (list->string (cdr (reverse (cdr (reverse literal-list)))))) (else err))) (define (ZEDmake-number-character noun-list) (cond (#t (list->string (list #\# #\\ (integer->char (string->number (list->string (cddr noun-list))))))) (else err))) (define (ZEDmakeFunctionBody ZEDarms) (cond (#t (apply string-append (ZEDpush "{" (ZEDpush "return" (ZEDpush (ZEDrd "0" ZEDternaryCombiner ZEDarms) (list ";}")))))) (else err))) (define (ZEDmakeFunctionSignature ZEDstack) (cond (#t (ZEDmakeFunctionSignature1 (ZEDzip-function-signature ZEDstack))) (else err))) (define (ZEDmakeFunctionSignature1 ZEDstack) (cond (#t (ZEDpush (quote static) (ZEDpush #\space (ZEDpush (ZEDtop ZEDstack) (ZEDpush #\space (ZEDpush (ZEDtop (ZEDpop ZEDstack)) (ZEDpush #\( (append (ZEDadd-between #\space (ZEDaddBetweenTwo #\, (ZEDpop (ZEDpop ZEDstack)))) (list #\)))))))))) (else err))) (define (ZEDmap-with! function list extra collect) (cond ((null? list) collect) (#t (ZEDmap-with! function (cdr list) extra (cons (function (car list) extra) collect))) (else err))) (define (ZEDmap-with function list extra) (cond (#t (reverse (ZEDmap-with! function list extra (quote ())))) (else err))) (define (ZEDmerge! comparator list1 list2 collect) (cond ((null? list2) (append (reverse collect) list1)) ((null? list1) (append (reverse collect) list2)) ((comparator (car list2) (car list1)) (ZEDmerge! comparator list1 (cdr list2) (cons (car list2) collect))) (#t (ZEDmerge! comparator (cdr list1) list2 (cons (car list1) collect))) (else err))) (define (ZEDmerge comparator list1 list2) (cond (#t (ZEDmerge! comparator list1 list2 (quote ()))) (else err))) (define (ZEDmp function list) (cond ((null? list) (quote ())) ((pair? list) (cons (delay (function (if (promise? (car list)) (force (car list)) (car list)))) (delay (ZEDmp function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))))) (#t (function list)) (else err))) (define (ZEDnewline-space! program) (cond (#t (cons #\newline (ZEDnewline-space!a program))) (else err))) (define (ZEDnewline-space!a program) (cond (#t (ZEDnewline-space!aa program (reverse (ZEDnewline-space!ab program (quote ()))))) (else err))) (define (ZEDnewline-space!aa program transformed) (cond ((equal? program transformed) program) (#t (ZEDnewline-space!a transformed)) (else err))) (define (ZEDnewline-space!ab program collect) (cond ((null? program) collect) ((null? (cdr program)) (cons (car program) collect)) ((and (eqv? #\newline (car program)) (or (eqv? #\space (cadr program)) (eqv? #\ht (cadr program)))) (ZEDnewline-space!ab (cdr program) collect)) (#t (ZEDnewline-space!ab (cdr program) (cons (car program) collect))) (else err))) (define (ZEDnewline-space program) (cond (#t (ZEDnewline-space! program)) (else err))) (define (ZEDnewline-space-tab-repeats! program collect) (cond ((or (null? program) (null? (cdr program))) (append program collect)) ((and (eqv? #\newline (car program)) (eqv? #\newline (cadr program))) (ZEDnewline-space-tab-repeats! (cdr program) collect)) ((and (or (eqv? #\space (car program)) (eqv? #\ht (car program))) (or (eqv? #\space (cadr program)) (eqv? #\ht (cadr program)))) (ZEDnewline-space-tab-repeats! (cdr program) collect)) (#t (ZEDnewline-space-tab-repeats! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDnewline-space-tab-repeats program) (cond (#t (reverse (ZEDnewline-space-tab-repeats! program (quote ())))) (else err))) (define (ZEDnewlines clauses) (cond (#t (ZEDadd-between-ra (ZEDmap-with ZEDadd-between-ra clauses (list #\newline)) (list (list #\newline #\newline)))) (else err))) (define (ZEDnormal-character? noun-list) (cond (#t (eqv? (car noun-list) #\#)) (else err))) (define (ZEDnot ZEDvalue) (cond (#t (not ZEDvalue)) (else err))) (define (ZEDnot-return? character) (cond (#t (not (eqv? #\cr character))) (else err))) (define (ZEDnoun! noun-list number?) (cond (number? (ZEDmake-exact noun-list)) ((ZEDliteral? noun-list) (ZEDmake-literal noun-list)) ((ZEDtrue? noun-list) "#t") ((ZEDfalse? noun-list) "#f") ((ZEDnumber-character? noun-list) (ZEDmake-number-character noun-list)) ((ZEDnormal-character? noun-list) (ZEDmake-character noun-list)) (#t (ZEDmake-ZED noun-list)) (else err))) (define (ZEDnoun noun-list) (cond (#t (ZEDnoun! noun-list (string->number (list->string noun-list)))) (else err))) (define (ZEDnull? ZEDvalue) (cond (#t (null? ZEDvalue)) (else err))) (define (ZEDnumber-character? noun-list) (cond (#t (and (eqv? (car noun-list) #\#) (eqv? (cadr noun-list) #\0) (not (null? (cddr noun-list))))) (else err))) (define (ZEDpair? ZEDvalue) (cond (#t (pair? ZEDvalue)) (else err))) (define (ZEDpop stack) (cond (#t (cdr stack)) (else err))) (define (ZEDpr! value output-string) (cond (#t (begin (display (ZEDpr!a value (quote ())) output-string) (ZEDpr!b output-string (get-output-string output-string)))) (else err))) (define (ZEDpr!a value collect) (cond ((char? value) (ZEDpr!aa (list->string (list #\# value)) collect)) ((string? value) (ZEDpr!aa (string-append "\"" value "\"") collect)) ((symbol? value) (ZEDpr!aa (symbol->string value) collect)) ((number? value) (ZEDpr!aa (number->string value) collect)) ((and (boolean? value) value) (ZEDpr!aa "#true" collect)) ((boolean? value) (ZEDpr!aa "#false" collect)) ((null? value) (reverse collect)) (#t (ZEDpr!a (if (promise? (cdr value)) (force (cdr value)) (cdr value)) (cons (ZEDpr!a (if (promise? (car value)) (force (car value)) (car value)) (quote ())) collect))) (else err))) (define (ZEDpr!aa string collect) (cond ((null? collect) string) (#t (reverse (cons string (cons "." collect)))) (else err))) (define (ZEDpr!b output-string value) (cond (#t (begin (close-output-port output-string) value)) (else err))) (define (ZEDpr value) (cond (#t (ZEDpr! value (open-output-string))) (else err))) (define (ZEDprintFunction ZEDfunction) (cond (#t (begin (for-each display (ZEDmakeFunctionSignature (ZEDtop (ZEDpop ZEDfunction)))) (display (ZEDmakeFunctionBody (ZEDpop (ZEDreverse (ZEDpop (ZEDreverse (ZEDtop (ZEDpop (ZEDpop ZEDfunction))))))))))) (else err))) (define (ZEDprintSignature function) (cond (#t (begin (for-each display (ZEDmakeFunctionSignature (ZEDtop (ZEDpop function)))) (display #\;))) (else err))) (define (ZEDprogramize program arity-hash) (cond (#t (cons (quote begin) (ZEDmap-with ZEDfunctionize program arity-hash))) (else err))) (define (ZEDpush object stack) (cond (#t (cons object stack)) (else err))) (define (ZEDrd! function list) (cond ((null? (if (promise? (cdr list)) (force (cdr list)) (cdr list))) (if (promise? (car list)) (force (car list)) (car list))) (#t (ZEDrd! function (cons (function (if (promise? (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (force (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (if (promise? (car list)) (force (car list)) (car list))) (if (promise? (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (force (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list))))))) (else err))) (define (ZEDrd final function list) (cond (#t (ZEDrd! function (cons final (reverse list)))) (else err))) (define (ZEDread-all! collect) (cond (#t (ZEDread-all!a (read-char) collect)) (else err))) (define (ZEDread-all!a character collect) (cond ((eof-object? character) collect) (#t (ZEDread-all! (cons character collect))) (else err))) (define (ZEDread-all) (cond (#t (reverse (ZEDread-all! (quote ())))) (else err))) (define (ZEDread-sentence!a sentence collect) (cond ((null? sentence) collect) ((eqv? #\space (car sentence)) (ZEDread-sentence!a (cdr sentence) collect)) ((eqv? #\( (car sentence)) (ZEDread-sentence!aa sentence (ZEDgather-verb (cdr sentence)) collect)) (#t (ZEDread-sentence!ab sentence (ZEDgather-noun sentence) collect)) (else err))) (define (ZEDread-sentence!aa sentence gather-verb collect) (cond (#t (ZEDread-sentence!a (ZEDtails (+ 2 (length gather-verb)) sentence) (cons (ZEDverb gather-verb) collect))) (else err))) (define (ZEDread-sentence!ab sentence gather-noun collect) (cond (#t (ZEDread-sentence!a (ZEDtails (length gather-noun) sentence) (cons (ZEDnoun gather-noun) collect))) (else err))) (define (ZEDread-sentence!b list output-string) (cond (#t (begin (display list output-string) (ZEDread-sentence!ba output-string (get-output-string output-string)))) (else err))) (define (ZEDread-sentence!ba output-string get-output-string) (cond (#t (begin (close-output-port output-string) (ZEDread-sentence!baa (open-input-string get-output-string)))) (else err))) (define (ZEDread-sentence!baa input-string) (cond (#t (ZEDread-sentence!baaa input-string (read input-string))) (else err))) (define (ZEDread-sentence!baaa input-string answer) (cond (#t (begin (close-input-port input-string) answer)) (else err))) (define (ZEDread-sentence sentence) (cond (#t (ZEDread-sentence!b (reverse (ZEDread-sentence!a sentence (quote ()))) (open-output-string))) (else err))) (define (ZEDread-sentences sentences) (cond (#t (map ZEDread-sentence sentences)) (else err))) (define (ZEDready-clause clause) (cond (#t (cons (caaar clause) (cons (cdar clause) (cdr clause)))) (else err))) (define (ZEDready-program program) (cond (#t (map ZEDready-clause program)) (else err))) (define (ZEDreplace-trailing-white-space! program) (cond ((null? program) (quote ())) ((or (eqv? (car program) #\space) (eqv? (car program) #\ht) (eqv? (car program) #\cr) (eqv? (car program) #\newline)) (ZEDreplace-trailing-white-space! (cdr program))) (#t (cons #\newline program)) (else err))) (define (ZEDreplace-trailing-white-space program) (cond (#t (reverse (ZEDreplace-trailing-white-space! (reverse program)))) (else err))) (define (ZEDreverse ZEDlist) (cond (#t (reverse ZEDlist)) (else err))) (define (ZEDschemefy! expression arity-hash stack) (cond ((null? expression) (ZEDtop stack)) ((ZEDapplication? expression) (ZEDschemefy!a expression arity-hash stack (ZEDfunction expression))) (#t (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (car expression) stack))) (else err))) (define (ZEDschemefy!a expression arity-hash stack function) (cond (#t (ZEDschemefy!aa expression arity-hash stack function (ZEDarity arity-hash function))) (else err))) (define (ZEDschemefy!aa expression arity-hash stack function arity) (cond ((ZEDgather-count? function) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (ZEDfirst arity stack) (ZEDtails arity stack)))) ((eq? function (quote ZED1)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (list (quote if) (list (quote promise?) (cons (quote car) (ZEDfirst arity stack))) (list (quote force) (cons (quote car) (ZEDfirst arity stack))) (cons (quote car) (ZEDfirst arity stack))) (ZEDtails arity stack)))) ((eq? function (quote ZED!)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (list (quote if) (list (quote promise?) (cons (quote cdr) (ZEDfirst arity stack))) (list (quote force) (cons (quote cdr) (ZEDfirst arity stack))) (cons (quote cdr) (ZEDfirst arity stack))) (ZEDtails arity stack)))) ((eq? function (quote ZEDc)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (cons (quote cons) (map ZEDdelay-wrap (ZEDfirst arity stack))) (ZEDtails arity stack)))) (#t (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (cons function (ZEDfirst arity stack)) (ZEDtails arity stack)))) (else err))) (define (ZEDschemefy expression arity-hash) (cond (#t (list (ZEDschemefy! (reverse expression) arity-hash (ZEDstack)))) (else err))) (define (ZEDsentence-less? sentence1 sentence2) (cond ((null? sentence2) #f) ((null? sentence1) #t) ((ZEDcharacter-less? (car sentence1) (car sentence2)) #t) ((ZEDcharacter-less? (car sentence2) (car sentence1)) #f) (#t (ZEDsentence-less? (cdr sentence1) (cdr sentence2))) (else err))) (define (ZEDsentences! program collect1 collect2) (cond ((null? program) collect2) ((eqv? #\newline (car program)) (ZEDsentences! (cdr program) (quote ()) (cons (reverse collect1) collect2))) (#t (ZEDsentences! (cdr program) (cons (car program) collect1) collect2)) (else err))) (define (ZEDsentences program) (cond (#t (reverse (ZEDsentences! program (quote ()) (quote ())))) (else err))) (define (ZEDsort!a jumble) (cond (#t (map list jumble)) (else err))) (define (ZEDsort!b comparator jumble) (cond ((null? jumble) (quote ())) ((null? (cdr jumble)) jumble) (#t (ZEDsort!b comparator (cons (ZEDmerge comparator (car jumble) (cadr jumble)) (ZEDsort!b comparator (cddr jumble))))) (else err))) (define (ZEDsort comparator jumble) (cond (#t (car (ZEDsort!b comparator (ZEDsort!a jumble)))) (else err))) (define (ZEDspace-newline! program collect) (cond ((or (null? program) (null? (cdr program))) (append program collect)) ((and (eqv? #\space (car program)) (eqv? #\newline (cadr program))) (ZEDspace-newline! (cdr program) collect)) (#t (ZEDspace-newline! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDspace-newline program) (cond (#t (reverse (ZEDspace-newline! program (quote ())))) (else err))) (define (ZEDstack) (cond (#t (quote ())) (else err))) (define (ZEDstring ZEDtheString) (cond (#t (string-append "\"" ZEDtheString "\"")) (else err))) (define (ZEDtab-replace! program collect) (cond ((null? program) collect) ((eqv? #\ht (car program)) (ZEDtab-replace! (cdr program) (cons #\space collect))) (#t (ZEDtab-replace! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDtab-replace program) (cond (#t (reverse (ZEDtab-replace! program (quote ())))) (else err))) (define (ZEDtails number list) (cond ((null? list) (quote ())) ((zero? number) list) ((> number 0) (ZEDtails (- number 1) (cdr list))) (else err))) (define (ZEDternary ZEDif ZEDthen ZEDelse) (cond (#t (apply string-append (list "(" ZEDif ")" "?" "(" ZEDthen ")" ":" "(" ZEDelse ")"))) (else err))) (define (ZEDternaryCombiner ZEDarm ZEDnext) (cond (#t (ZEDternaryCombiner1 (map ZEDcallingConvention ZEDarm) ZEDnext)) (else err))) (define (ZEDternaryCombiner1 ZEDarm ZEDnext) (cond (#t (ZEDternary (ZEDtop ZEDarm) (ZEDtop (ZEDpop ZEDarm)) ZEDnext)) (else err))) (define (ZEDtop stack) (cond (#t (car stack)) (else err))) (define (ZEDtrue? noun-list) (cond (#t (equal? noun-list (list #\# #\t #\r #\u #\e))) (else err))) (define (ZEDverb verb-list) (cond ((ZEDliteral? verb-list) (list (ZEDmake-literal verb-list))) (#t (list (ZEDmake-ZED verb-list))) (else err))) (define (ZEDwrite-all program) (cond ((null? program) (quote err)) (#t (ZEDwrite-all (begin (write-char (car program)) (cdr program)))) (else err))) (define (ZEDzed->scheme! value collect) (cond ((null? value) (reverse collect)) (#t (ZEDzed->scheme! (if (promise? (cdr value)) (force (cdr value)) (cdr value)) (cons (ZEDzed->scheme (if (promise? (car value)) (force (car value)) (car value))) collect))) (else err))) (define (ZEDzed->scheme value) (cond ((not (pair? value)) value) (#t (ZEDzed->scheme! value (quote ()))) (else err))) (define (ZEDzip-function-signature ZEDsignature) (cond (#t (ZEDzip-function-signature1 ZEDsignature (ZED/ (length ZEDsignature) 2))) (else err))) (define (ZEDzip-function-signature1 ZEDsignature ZEDhalf-length) (cond (#t (ZEDzip-function-signature11 (ZEDtails ZEDhalf-length ZEDsignature) (ZEDfirst ZEDhalf-length ZEDsignature))) (else err))) (define (ZEDzip-function-signature11 ZEDtypes ZEDidentifiers) (cond ((ZEDnull? ZEDidentifiers) (quote ())) (#t (cons (car ZEDtypes) (cons (car ZEDidentifiers) (ZEDzip-function-signature11 (cdr ZEDtypes) (cdr ZEDidentifiers))))) (else err))))
    (ZEDcomp)

ZEDc.zed

(printFunction) function
comment:
#true
(003) "begin" (003) "for-each" "display" (makeFunctionSignature) (top) (pop) function (002) "display" (makeFunctionBody) (pop) (reverse) (pop) (reverse) (top) (pop) (pop) function

(makeFunctionBody) arms
comment:
#true
(003) "apply" "string-append" (push) ""{"" (push) ""return"" (push) (rd) ""0"" ternaryCombiner arms (002) "list" "";}""

(ternaryCombiner) arm next
comment:
#true
(ternaryCombiner1) (003) "map" callingConvention arm next

(ternaryCombiner1) arm next
comment:
#true
(ternary) (top) arm (top) (pop) arm next

(callingConvention) expression
comment:
(002) "list?" expression
(callingConvention1) (003) "map" callingConvention expression

(callingConvention) expression
comment:
#true
(callingConvention2) expression

(callingConvention2) part
comment:
(002) "boolean?" part
(integerBoolean) part

(callingConvention2) part
comment:
(002) "char?" part
(002) "number->string" (002) "char->integer" part

(callingConvention2) part
comment:
#true
(callingConvention21) part (001) "open-output-string"

(callingConvention21) part output-string
comment:
#true
(003) "begin" (003) "write" part output-string (callingConvention211) output-string (002) "get-output-string" output-string

(callingConvention211) output-string string
comment:
#true
(003) "begin" (002) "close-output-port" output-string string

(integerBoolean) bool
comment:
bool
""1""

(integerBoolean) bool
comment:
#true
""0""

(callingConvention1) strings
comment:
#true
(003) "apply" "string-append" (push) (top) strings (push) ""("" (003) "append" (add-between) "","" (pop) strings (002) "list" "")""

(ternary) if then else
comment:
#true
(003) "apply" "string-append" (012) "list" ""("" if "")"" ""?"" ""("" then "")"" "":"" ""("" else "")""

(addBetweenTwo) item stack
comment:
(null?) stack
nil

(addBetweenTwo) item stack
comment:
(null?) (pop) (pop) stack
stack

(addBetweenTwo) item stack
comment:
#true
(push) (top) stack
  (push) (top) (pop) stack
    (push) item
      (addBetweenTwo) item (pop) (pop) stack

(makeFunctionSignature1) stack
comment:
#true
(push) "'static"
  (push) #space
    (push) (top) stack
      (push) #space
        (push) (top) (pop) stack
          (push) #(
            (003) "append"
                  (add-between) #space (addBetweenTwo) #, (pop) (pop) stack
                  (002) "list" #)

(makeFunctionSignature) stack
comment:
#true
(makeFunctionSignature1) (zip-function-signature) stack

(string) theString
comment:
#true
(004) "string-append" ""\""" theString ""\"""

(zip-function-signature) signature
comment:
#true
(zip-function-signature1) signature (/) (002) "length" signature 2

(zip-function-signature1) signature half-length
comment:
#true
(zip-function-signature11) (tails) half-length signature (first) half-length signature

(zip-function-signature11) types identifiers
comment:
(null?) identifiers
nil

(zip-function-signature11) types identifiers
comment:
#true
(003) "cons" (002) "car" types (003) "cons" (002) "car" identifiers (zip-function-signature11) (002) "cdr" types (002) "cdr" identifiers

(*) number1 number2
comment:
#true
(003) "*" number1 number2

(+) number1 number2
comment:
#true
(003) "+" number1 number2

(-) number1 number2
comment:
#true
(003) "-" number1 numbe2

(/) number1 number2
comment:
#true
(003) "/" number1 number2

(=) "value1" "value2"
comment:
#true
(003) "eqv?" "value1" "value2"

(add-between!) "item" "list" "collect"
comment:
(002) "null?" "list"
"collect"

(add-between!) "item" "list" "collect"
comment:
(002) "null?" (002) "cdr" "list"
(003) "cons" (002) "car" "list" "collect"

(add-between!) "item" "list" "collect"
comment:
#true
(add-between!) "item" (002) "cdr" "list" (003) "cons" "item" (003) "cons" (002) "car" "list" "collect"

(add-between) "item" "list"
comment:
#true
(002) "reverse" (add-between!) "item" "list" nil

(add-between-ra) "list" "item"
comment:
#true
(002) "reverse" (add-between!) "item" "list" nil

(alpha)
comment:
#true
(write-all) (rd) nil "append" (rd) nil "append" (newlines) (by-four) (function-sort) (sentences) (leading-newline) (space-newline) (tab-replace) (newline-space-tab-repeats) (newline-space) (filter) not-return? (replace-trailing-white-space) (read-all)

(application?) "expression"
comment:
#true
(004) "and" (002) "not" (002) "null?" "expression" (002) "pair?" (002) "car" "expression" (002) "null?" (002) "cdar" "expression"

(arity) "arity-hash" "function"
comment:
#true
(002) "cdr" (003) "assoc" "function" "arity-hash"

(arity-hash!) "clause"
comment:
#true
(003) "cons" (clause-name) "clause" (clause-arity) "clause"

(arity-hash) "program"
comment:
#true
(003) "append" (003) "map" arity-hash! "program" (003) "append" (009) "list" (003) "cons" "'ZED1" 1 (003) "cons" "'ZED!" 1 (003) "cons" "'ZED001" 1 (003) "cons" "'or" 2 (003) "cons" "'and" 2 (003) "cons" "'begin" 2 (003) "cons" "'ZEDc" 2 (003) "cons" "'quote" 1 (099) "list" (003) "cons" "'ZED002" 2 (003) "cons" "'ZED003" 3 (003) "cons" "'ZED004" 4 (003) "cons" "'ZED005" 5 (003) "cons" "'ZED006" 6 (003) "cons" "'ZED007" 7 (003) "cons" "'ZED008" 8 (003) "cons" "'ZED009" 9 (003) "cons" "'ZED010" 10 (003) "cons" "'ZED011" 11 (003) "cons" "'ZED012" 12 (003) "cons" "'ZED013" 13 (003) "cons" "'ZED014" 14 (003) "cons" "'ZED015" 15 (003) "cons" "'ZED016" 16 (003) "cons" "'ZED017" 17 (003) "cons" "'ZED018" 18 (003) "cons" "'ZED019" 19 (003) "cons" "'ZED020" 20 (003) "cons" "'ZED021" 21 (003) "cons" "'ZED022" 22 (003) "cons" "'ZED023" 23 (003) "cons" "'ZED024" 24 (003) "cons" "'ZED025" 25 (003) "cons" "'ZED026" 26 (003) "cons" "'ZED027" 27 (003) "cons" "'ZED028" 28 (003) "cons" "'ZED029" 29 (003) "cons" "'ZED030" 30 (003) "cons" "'ZED031" 31 (003) "cons" "'ZED032" 32 (003) "cons" "'ZED033" 33 (003) "cons" "'ZED034" 34 (003) "cons" "'ZED035" 35 (003) "cons" "'ZED036" 36 (003) "cons" "'ZED037" 37 (003) "cons" "'ZED038" 38 (003) "cons" "'ZED039" 39 (003) "cons" "'ZED040" 40 (003) "cons" "'ZED041" 41 (003) "cons" "'ZED042" 42 (003) "cons" "'ZED043" 43 (003) "cons" "'ZED044" 44 (003) "cons" "'ZED045" 45 (003) "cons" "'ZED046" 46 (003) "cons" "'ZED047" 47 (003) "cons" "'ZED048" 48 (003) "cons" "'ZED049" 49 (003) "cons" "'ZED050" 50 (003) "cons" "'ZED051" 51 (003) "cons" "'ZED052" 52 (003) "cons" "'ZED053" 53 (003) "cons" "'ZED054" 54 (003) "cons" "'ZED055" 55 (003) "cons" "'ZED056" 56 (003) "cons" "'ZED057" 57 (003) "cons" "'ZED058" 58 (003) "cons" "'ZED059" 59 (003) "cons" "'ZED060" 60 (003) "cons" "'ZED061" 61 (003) "cons" "'ZED062" 62 (003) "cons" "'ZED063" 63 (003) "cons" "'ZED064" 64 (003) "cons" "'ZED065" 65 (003) "cons" "'ZED066" 66 (003) "cons" "'ZED067" 67 (003) "cons" "'ZED068" 68 (003) "cons" "'ZED069" 69 (003) "cons" "'ZED070" 70 (003) "cons" "'ZED071" 71 (003) "cons" "'ZED072" 72 (003) "cons" "'ZED073" 73 (003) "cons" "'ZED074" 74 (003) "cons" "'ZED075" 75 (003) "cons" "'ZED076" 76 (003) "cons" "'ZED077" 77 (003) "cons" "'ZED078" 78 (003) "cons" "'ZED079" 79 (003) "cons" "'ZED080" 80 (003) "cons" "'ZED081" 81 (003) "cons" "'ZED082" 82 (003) "cons" "'ZED083" 83 (003) "cons" "'ZED084" 84 (003) "cons" "'ZED085" 85 (003) "cons" "'ZED086" 86 (003) "cons" "'ZED087" 87 (003) "cons" "'ZED088" 88 (003) "cons" "'ZED089" 89 (003) "cons" "'ZED090" 90 (003) "cons" "'ZED091" 91 (003) "cons" "'ZED092" 92 (003) "cons" "'ZED093" 93 (003) "cons" "'ZED094" 94 (003) "cons" "'ZED095" 95 (003) "cons" "'ZED096" 96 (003) "cons" "'ZED097" 97 (003) "cons" "'ZED098" 98 (003) "cons" "'ZED099" 99

(by-four!) "sentences" "collect"
comment:
(002) "null?" "sentences"
"collect"

(by-four!) "sentences" "collect"
comment:
#true
(by-four!) (002) "cddddr" "sentences" (003) "cons" (005) "list" (002) "car" "sentences" (002) "cadr" "sentences" (002) "caddr" "sentences" (002) "cadddr" "sentences" "collect"

(by-four) "sentences"
comment:
#true
(002) "reverse" (by-four!) "sentences" nil

(by-three!) "sentences" "collect"
comment:
(002) "null?" "sentences"
"collect"

(by-three!) "sentences" "collect"
comment:
#true
(by-three!) (002) "cdddr" "sentences" (003) "cons" (004) "list" (002) "car" "sentences" (002) "cadr" "sentences" (002) "caddr" "sentences" "collect"

(by-three) "sentences"
comment:
#true
(002) "reverse" (by-three!) "sentences" nil

(character-less?) "character1" "character2"
comment:
#true
(003) "<" (002) "char->integer" "character1" (002) "char->integer" "character2"

(clause-arguments) "clause"
comment:
#true
(002) "cadr" "clause"

(clause-arguments-agree) "clause1" "clause2"
comment:
(003) "equal?" (clause-arguments) "clause1" (clause-arguments) "clause2"
(clause-arguments) "clause1"

(clause-arity) "clause"
comment:
#true
(003) "/" (003) "-" (002) "length" (clause-arguments) "clause" 1 2

(clause-body) "clause"
comment:
#true
(002) "cddr" "clause"

(clause-less?) "clause1" "clause2"
comment:
#true
(sentence-less?) (002) "car" "clause1" (002) "car" "clause2"

(clause-name) "clause"
comment:
#true
(002) "car" "clause"

(clause-name-agree) "clause1" "clause2"
comment:
(003) "eq?" (clause-name) "clause1" (clause-name) "clause2"
(clause-name) "clause1"

(combine-all!) "program" "collect"
comment:
(002) "null?" "program"
"collect"

(combine-all!) "program" "collect"
comment:
(002) "null?" (002) "cdr" "program"
(003) "cons" (002) "car" "program" "collect"

(combine-all!) "program" "collect"
comment:
(003) "eq?" (clause-name) (002) "car" "program" (clause-name) (002) "cadr" "program"
(combine-all!) (combine-head-clauses) "program" "collect"

(combine-all!) "program" "collect"
comment:
#true
(combine-all!) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect"

(combine-all) "program"
comment:
#true
(002) "reverse" (combine-all!) "program" nil

(combine-clauses) "clause1" "clause2"
comment:
#true
(003) "cons" (clause-name-agree) "clause1" "clause2" (003) "cons" (clause-arguments-agree) "clause1" "clause2" (003) "append" (clause-body) "clause1" (clause-body) "clause2"

(combine-head-clauses) "program"
comment:
#true
(003) "cons" (combine-clauses) (002) "car" "program" (002) "cadr" "program" (002) "cddr" "program"

(combine-program-clauses) "program"
comment:
#true
(combine-all) (ready-program) "program"

(comp!)
comment:
#true
(comp!a) (combine-program-clauses) (by-three) (read-sentences) (discard-comments) (function-sort) (sentences) (leading-newline) (space-newline) (tab-replace) (newline-space-tab-repeats) (newline-space) (filter) not-return? (replace-trailing-white-space) (read-all)

(comp!a) "combined"
comment:
#true
(comp!aa) (programize) "combined" (arity-hash) "combined"

(comp!aa) "programized"
comment:
#true
(comp!aaa) "programized" (001) "open-output-string"


(comp!aaa) "programized" "output-string"
comment:
#true
(003) "begin" 
         (003) "write" "programized" "output-string"
         (comp!aaaa) (pop) (002) "read" (002) "open-input-string" (002) "get-output-string" "output-string"

(comp!aaaa) "program"
comment:
#true
(003) "begin"
         (003) "for-each" printSignature "program"
         (003) "for-each" printFunction "program"

(printSignature) "function"
comment:
#true
(003) "begin" (003) "for-each" "display" (makeFunctionSignature) (top) (pop) "function" (002) "display" #;

(comp)
comment:
#true
(comp!)

(condefy!) "expressions" "collect"
comment:
(002) "null?" "expressions"
"collect"

(condefy!) "expressions" "collect"
comment:
#true
(condefy!) (002) "cddr" "expressions" (003) "cons" (003) "append" (002) "car" "expressions" (002) "cadr" "expressions" "collect"

(condefy) "expressions"
comment:
#true
(002) "reverse" (condefy!) "expressions" nil

(cons) value1 value2
comment:
#true
(003) "cons" value1 value2

(count) number
comment:
#true
(c) number (count) (+) number 1

(count-by) step number
comment:
#true
(c) number (count-by) step (+) number step

(delay-wrap) "expression"
comment:
#true
(003) "list" "'delay" "expression"

(digit?) "character"
comment:
#true
(011) "or" (003) "eqv?" #0 "character" (003) "eqv?" #1 "character" (003) "eqv?" #2 "character" (003) "eqv?" #3 "character" (003) "eqv?" #4 "character" (003) "eqv?" #5 "character" (003) "eqv?" #6 "character" (003) "eqv?" #7 "character" (003) "eqv?" #8 "character" (003) "eqv?" #9 "character"

(discard-comments!) "program" "collect"
comment:
(002) "null?" "program"
"collect"

(discard-comments!) "program" "collect"
comment:
#true
(discard-comments!) (002) "cddddr" "program" (003) "cons" (002) "cadddr" "program" (003) "cons" (002) "caddr" "program" (003) "cons" (002) "car" "program" "collect"

(discard-comments) "program"
comment:
#true
(002) "reverse" (discard-comments!) "program" nil

(dr!) "value"
comment:
(002) "pair?" "value"
(mp) dr! (first) 64 "value"

(dr!) "value"
comment:
#true
"value"

(dr) "value"
comment:
#true
(005) "begin" (002) "display" (pr) (dr!) "value" (001) "newline" (001) "newline" "value"

(drr) "value"
comment:
#true
(005) "begin" (002) "display" (pr) "value" (001) "newline" (001) "newline" "value"

(false?) "noun-list"
comment:
#true
(003) "equal?" "noun-list" (007) "list" ## #f #a #l #s #e

(fi) "function" "list"
comment:
(002) "null?" "list"
nil

(fi) "function" "list"
comment:
(002) "function" (1) "list"
(c) (1) "list" (fi) "function" (!) "list"

(fi) "function" "list"
comment:
#true
(fi) "function" (!) "list"

(filter!) "predicate" "list" "collect"
comment:
(002) "null?" "list"
"collect"

(filter!) "predicate" "list" "collect"
comment:
(002) "predicate" (002) "car" "list"
(filter!) "predicate" (002) "cdr" "list" (003) "cons" (002) "car" "list" "collect"

(filter!) "predicate" "list" "collect"
comment:
#true
(filter!) "predicate" (002) "cdr" "list" "collect"

(filter) "predicate" "list"
comment:
#true
(002) "reverse" (filter!) "predicate" "list" nil

(first!) "integer" "list" "collect"
comment:
(003) "or" (002) "zero?" "integer" (002) "null?" "list"
(002) "reverse" "collect"

(first!) "integer" "list" "collect"
comment:
(002) "not" (002) "pair?" "list"
(002) "reverse" (003) "cons" "list" "collect"

(first!) "integer" "list" "collect"
comment:
(003) ">" "integer" 0
(first!) (003) "-" "integer" 1 (!) "list" (003) "cons" (1) "list" "collect"

(first) "integer" "list"
comment:
(002) "not" (002) "pair?" "list"
"list"

(first) "integer" "list"
comment:
#true
(first!) "integer" "list" nil

(flatten!) list sub-list-found? collect
comment:
(and) (null?) list (not) sub-list-found?
(reverse) collect

(flatten!) list sub-list-found? collect
comment:
(null?) list
(flatten!) (reverse) collect #false nil

(flatten!) list sub-list-found? collect
comment:
(not) (pair?) list
(flatten!) nil sub-list-found? (cons) list collect

(flatten!) list sub-list-found? collect
comment:
(pair?) (1) list
(flatten!) (!) list #true (cons) (!) (1) list (cons) (1) (1) list collect

(flatten!) list sub-list-found? collect
comment:
(null?) (1) list
(flatten!) (!) list sub-list-found? collect

(flatten!) list sub-list-found? collect
comment:
#true
(flatten!) (!) list sub-list-found? (cons) (1) list collect

(flatten) list
comment:
#true
(flatten!) list #false nil

(for-each) effect list
comment:
#true
(003) "for-each" effect list

(function) "expression"
comment:
#true
(002) "caar" "expression"

(function-sort) "sentences"
comment:
#true
(rd) nil "append" (sort) clause-less? (by-four) "sentences"

(functionize) "clause" "arity-hash"
comment:
#true
(004) "list" "'define" (003) "cons" (clause-name) "clause" (clause-arguments) "clause" (003) "cons" "'cond" (003) "append" (condefy) (map-with) schemefy (clause-body) "clause" "arity-hash" (002) "list" (003) "list" "'else" err

(gather-count?!) "candidate"
comment:
#true
(008) "and" (003) "=" 6 (002) "length" "candidate" (003) "eqv?" #Z (002) "car" "candidate" (003) "eqv?" #E (002) "cadr" "candidate" (003) "eqv?" #D (002) "caddr" "candidate" (003) "eqv?" #0 (002) "cadddr" "candidate" (digit?) (002) "car" (002) "cddddr" "candidate" (digit?) (002) "cadr" (002) "cddddr" "candidate"

(gather-count?) "symbol"
comment:
#true
(gather-count?!) (002) "string->list" (002) "symbol->string" "symbol"

(gather-noun) "sentence"
comment:
(002) "null?" "sentence"
nil

(gather-noun) "sentence"
comment:
(003) "eqv?" #space (002) "car" "sentence"
nil

(gather-noun) "sentence"
comment:
#true
(003) "cons" (002) "car" "sentence" (gather-noun) (002) "cdr" "sentence"

(gather-verb) "sentence"
comment:
(003) "eqv?" #) (002) "car" "sentence"
nil

(gather-verb) "sentence"
comment:
#true
(003) "cons" (002) "car" "sentence" (gather-verb) (002) "cdr" "sentence"

(gr) "garbage" "value"
comment:
#true
(003) "begin" (dr) "garbage" "value"

(grr) "garbage" "value"
comment:
#true
(003) "begin" (drr) "garbage" "value"

(halve) number
comment:
#true
(/) number 2

(leading-newline) "program"
comment:
(002) "null?" "program"
nil

(leading-newline) "program"
comment:
(003) "eqv?" #newline (002) "car" "program"
(002) "cdr" "program"

(leading-newline) "program"
comment:
#true
"program"

(literal?) "literal-list"
comment:
#true
(003) "eqv?" #" (002) "car" "literal-list"

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (004) "list" #e #r #r
""'err""

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (004) "list" #n #i #l
""'()""

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (004) "list" #a #n #d
""and""

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (003) "list" #o #r
""or""

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (006) "list" #q #u #o #t #e
""quote""

(make-ZED) "ZED-list"
comment:
(003) "equal?" "ZED-list" (003) "list" #s #e
""begin""

(make-ZED) "ZED-list"
comment:
#true
(002) "list->string" (003) "append" (004) "list" #Z #E #D "ZED-list"

(make-character) "noun-list"
comment:
#true
(002) "list->string" (003) "cons" ## (003) "cons" #\ (002) "cdr" "noun-list"

(make-exact) "exact-list"
comment:
#true
(002) "list->string" (003) "append" (003) "list" ## #e "exact-list"

(make-literal) "literal-list"
comment:
#true
(002) "list->string" (002) "cdr" (002) "reverse" (002) "cdr" (002) "reverse" "literal-list"

(make-number-character) "noun-list"
comment:
#true
(002) "list->string" (004) "list" ## #\ (002) "integer->char" (002) "string->number" (002) "list->string" (002) "cddr" "noun-list"

(map-with!) "function" "list" "extra" "collect"
comment:
(002) "null?" "list"
"collect"

(map-with!) "function" "list" "extra" "collect"
comment:
#true
(map-with!) "function" (002) "cdr" "list" "extra" (003) "cons" (003) "function" (002) "car" "list" "extra" "collect"

(map-with) "function" "list" "extra"
comment:
#true
(002) "reverse" (map-with!) "function" "list" "extra" nil

(merge!) "comparator" "list1" "list2" "collect"
comment:
(002) "null?" "list2"
(003) "append" (002) "reverse" "collect" "list1"

(merge!) "comparator" "list1" "list2" "collect"
comment:
(002) "null?" "list1"
(003) "append" (002) "reverse" "collect" "list2"

(merge!) "comparator" "list1" "list2" "collect"
comment:
(003) "comparator" (002) "car" "list2" (002) "car" "list1"
(merge!) "comparator" "list1" (002) "cdr" "list2" (003) "cons" (002) "car" "list2" "collect"

(merge!) "comparator" "list1" "list2" "collect"
comment:
#true
(merge!) "comparator" (002) "cdr" "list1" "list2" (003) "cons" (002) "car" "list1" "collect"

(merge) "comparator" "list1" "list2"
comment:
#true
(merge!) "comparator" "list1" "list2" nil

(mp) "function" "list"
comment:
(002) "null?" "list"
nil

(mp) "function" "list"
comment:
(002) "pair?" "list"
(c) (002) "function" (1) "list" (mp) "function" (!) "list"

(mp) "function" "list"
comment:
#true
(002) "function" "list"

(newline-space!) "program"
comment:
#true
(003) "cons" #newline (newline-space!a) "program"

(newline-space!a) "program"
comment:
#true
(newline-space!aa) "program" (002) "reverse" (newline-space!ab) "program" nil

(newline-space!aa) "program" "transformed"
comment:
(003) "equal?" "program" "transformed"
"program"

(newline-space!aa) "program" "transformed"
comment:
#true
(newline-space!a) "transformed"

(newline-space!ab) "program" "collect"
comment:
(002) "null?" "program"
"collect"

(newline-space!ab) "program" "collect"
comment:
(002) "null?" (002) "cdr" "program"
(003) "cons" (002) "car" "program" "collect"

(newline-space!ab) "program" "collect"
comment:
(003) "and" (003) "eqv?" #newline (002) "car" "program" (003) "or" (003) "eqv?" #space (002) "cadr" "program" (003) "eqv?" #tab (002) "cadr" "program"
(newline-space!ab) (002) "cdr" "program" "collect"

(newline-space!ab) "program" "collect"
comment:
#true
(newline-space!ab) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect"

(newline-space) "program"
comment:
#true
(newline-space!) "program"

(newline-space-tab-repeats!) "program" "collect"
comment:
(003) "or" (002) "null?" "program" (002) "null?" (002) "cdr" "program"
(003) "append" "program" "collect"

(newline-space-tab-repeats!) "program" "collect"
comment:
(003) "and" (003) "eqv?" #newline (002) "car" "program" (003) "eqv?" #newline (002) "cadr" "program"
(newline-space-tab-repeats!) (002) "cdr" "program" "collect"

(newline-space-tab-repeats!) "program" "collect"
comment:
(003) "and" (003) "or" (003) "eqv?" #space (002) "car" "program" (003) "eqv?" #tab (002) "car" "program" (003) "or" (003) "eqv?" #space (002) "cadr" "program" (003) "eqv?" #tab (002) "cadr" "program"
(newline-space-tab-repeats!) (002) "cdr" "program" "collect"

(newline-space-tab-repeats!) "program" "collect"
comment:
#true
(newline-space-tab-repeats!) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect"

(newline-space-tab-repeats) "program"
comment:
#true
(002) "reverse" (newline-space-tab-repeats!) "program" nil

(newlines) "clauses"
comment:
#true
(add-between-ra) (map-with) add-between-ra "clauses" (002) "list" #newline (002) "list" (003) "list" #newline #newline

(normal-character?) "noun-list"
comment:
#true
(003) "eqv?" (002) "car" "noun-list" ##

(not) value
comment:
#true
(002) "not" value

(not-return?) "character"
comment:
#true
(002) "not" (003) "eqv?" #return "character"

(noun!) "noun-list" "number?"
comment:
"number?"
(make-exact) "noun-list"

(noun!) "noun-list" "number?"
comment:
(literal?) "noun-list"
(make-literal) "noun-list"

(noun!) "noun-list" "number?"
comment:
(true?) "noun-list"
""#t""

(noun!) "noun-list" "number?"
comment:
(false?) "noun-list"
""#f""

(noun!) "noun-list" "number?"
comment:
(number-character?) "noun-list"
(make-number-character) "noun-list"

(noun!) "noun-list" "number?"
comment:
(normal-character?) "noun-list"
(make-character) "noun-list"

(noun!) "noun-list" "number?"
comment:
#true
(make-ZED) "noun-list"

(noun) "noun-list"
comment:
#true
(noun!) "noun-list" (002) "string->number" (002) "list->string" "noun-list"

(null?) value
comment:
#true
(002) "null?" value

(number-character?) "noun-list"
comment:
#true
(004) "and" (003) "eqv?" (002) "car" "noun-list" ## (003) "eqv?" (002) "cadr" "noun-list" #0 (002) "not" (002) "null?" (002) "cddr" "noun-list"

(pair?) value
comment:
#true
(002) "pair?" value

(pop) "stack"
comment:
#true
(002) "cdr" "stack"

(pr!) "value" "output-string"
comment:
#true
(003) "begin" (003) "display" (pr!a) "value" nil "output-string" (pr!b) "output-string" (002) "get-output-string" "output-string"

(pr!a) "value" "collect"
comment:
(002) "char?" "value"
(pr!aa) (002) "list->string" (003) "list" ## "value" "collect"

(pr!a) "value" "collect"
comment:
(002) "string?" "value"
(pr!aa) (004) "string-append" ""\""" "value" ""\""" "collect"

(pr!a) "value" "collect"
comment:
(002) "symbol?" "value"
(pr!aa) (002) "symbol->string" "value" "collect"

(pr!a) "value" "collect"
comment:
(002) "number?" "value"
(pr!aa) (002) "number->string" "value" "collect"

(pr!a) "value" "collect"
comment:
(003) "and" (002) "boolean?" "value" "value"
(pr!aa) ""#true"" "collect"

(pr!a) "value" "collect"
comment:
(002) "boolean?" "value"
(pr!aa) ""#false"" "collect"

(pr!a) "value" "collect"
comment:
(002) "null?" "value"
(002) "reverse" "collect"

(pr!a) "value" "collect"
comment:
#true
(pr!a) (!) "value" (003) "cons" (pr!a) (1) "value" nil "collect"

(pr!aa) "string" "collect"
comment:
(002) "null?" "collect"
"string"

(pr!aa) "string" "collect"
comment:
#true
(002) "reverse" (003) "cons" "string" (003) "cons" ""."" "collect"

(pr!b) "output-string" "value"
comment:
#true
(003) "begin" (002) "close-output-port" "output-string" "value"

(pr) "value"
comment:
#true
(pr!) "value" (001) "open-output-string"

(programize) "program" "arity-hash"
comment:
#true
(003) "cons" "'begin" (map-with) functionize "program" "arity-hash"

(push) "object" "stack"
comment:
#true
(003) "cons" "object" "stack"

(rd!) "function" "list"
comment:
(002) "null?" (!) "list"
(1) "list"

(rd!) "function" "list"
comment:
#true
(rd!) "function" (003) "cons" (003) "function" (1) (!) "list" (1) "list" (!) (!) "list"

(rd) "final" "function" "list"
comment:
#true
(rd!) "function" (003) "cons" "final" (002) "reverse" "list"

(read-all!) "collect"
comment:
#true
(read-all!a) (001) "read-char" "collect"

(read-all!a) "character" "collect"
comment:
(002) "eof-object?" "character"
"collect"

(read-all!a) "character" "collect"
comment:
#true
(read-all!) (003) "cons" "character" "collect"

(read-all)
comment:
#true
(002) "reverse" (read-all!) nil

(read-sentence!a) "sentence" "collect"
comment:
(002) "null?" "sentence"
"collect"

(read-sentence!a) "sentence" "collect"
comment:
(003) "eqv?" #space (002) "car" "sentence"
(read-sentence!a) (002) "cdr" "sentence" "collect"

(read-sentence!a) "sentence" "collect"
comment:
(003) "eqv?" #( (002) "car" "sentence"
(read-sentence!aa) "sentence" (gather-verb) (002) "cdr" "sentence" "collect"

(read-sentence!a) "sentence" "collect"
comment:
#true
(read-sentence!ab) "sentence" (gather-noun) "sentence" "collect"

(read-sentence!aa) "sentence" "gather-verb" "collect"
comment:
#true
(read-sentence!a) (tails) (003) "+" 2 (002) "length" "gather-verb" "sentence" (003) "cons" (verb) "gather-verb" "collect"

(read-sentence!ab) "sentence" "gather-noun" "collect"
comment:
#true
(read-sentence!a) (tails) (002) "length" "gather-noun" "sentence" (003) "cons" (noun) "gather-noun" "collect"

(read-sentence!b) "list" "output-string"
comment:
#true
(003) "begin" (003) "display" "list" "output-string" (read-sentence!ba) "output-string" (002) "get-output-string" "output-string"

(read-sentence!ba) "output-string" "get-output-string"
comment:
#true
(003) "begin" (002) "close-output-port" "output-string" (read-sentence!baa) (002) "open-input-string" "get-output-string"

(read-sentence!baa) "input-string"
comment:
#true
(read-sentence!baaa) "input-string" (002) "read" "input-string"

(read-sentence!baaa) "input-string" "answer"
comment:
#true
(003) "begin" (002) "close-input-port" "input-string" "answer"

(read-sentence) "sentence"
comment:
#true
(read-sentence!b) (002) "reverse" (read-sentence!a) "sentence" nil (001) "open-output-string"

(read-sentences) "sentences"
comment:
#true
(003) "map" read-sentence "sentences"

(ready-clause) "clause"
comment:
#true
(003) "cons" (002) "caaar" "clause" (003) "cons" (002) "cdar" "clause" (002) "cdr" "clause"

(ready-program) "program"
comment:
#true
(003) "map" ready-clause "program"

(replace-trailing-white-space!) "program"
comment:
(002) "null?" "program"
nil

(replace-trailing-white-space!) "program"
comment:
(005) "or" (003) "eqv?" (002) "car" "program" #space (003) "eqv?" (002) "car" "program" #tab (003) "eqv?" (002) "car" "program" #return (003) "eqv?" (002) "car" "program" #newline
(replace-trailing-white-space!) (002) "cdr" "program"

(replace-trailing-white-space!) "program"
comment:
#true
(003) "cons" #newline "program"

(replace-trailing-white-space) "program"
comment:
#true
(002) "reverse" (replace-trailing-white-space!) (002) "reverse" "program"

(reverse) list
comment:
#true
(002) "reverse" list

(schemefy!) "expression" "arity-hash" "stack"
comment:
(002) "null?" "expression"
(top) "stack"

(schemefy!) "expression" "arity-hash" "stack"
comment:
(application?) "expression"
(schemefy!a) "expression" "arity-hash" "stack" (function) "expression"

(schemefy!) "expression" "arity-hash" "stack"
comment:
#true
(schemefy!) (002) "cdr" "expression" "arity-hash" (push) (002) "car" "expression" "stack"

(schemefy!a) "expression" "arity-hash" "stack" "function"
comment:
#true
(schemefy!aa) "expression" "arity-hash" "stack" "function" (arity) "arity-hash" "function"

(schemefy!aa) "expression" "arity-hash" "stack" "function" "arity"
comment:
(gather-count?) "function"
(schemefy!) (002) "cdr" "expression" "arity-hash" (push) (first) "arity" "stack" (tails) "arity" "stack"

(schemefy!aa) "expression" "arity-hash" "stack" "function" "arity"
comment:
(003) "eq?" "function" "'ZED1"
(schemefy!) (002) "cdr" "expression" 
            "arity-hash"
            (push) 
              (005) "list"
                    "'if"
                    (003) "list"
                          "'promise?"
                          (003) "cons" 
                                "'car" 
                                (first) "arity" "stack"
                    (003) "list"
                          "'force"
                          (003) "cons"
                                "'car"
                                (first) "arity" "stack"
                    (003) "cons"
                          "'car"
                          (first) "arity" "stack"
              (tails) "arity" "stack"

(schemefy!aa) "expression" "arity-hash" "stack" "function" "arity"
comment:
(003) "eq?" "function" "'ZED!"
(schemefy!) (002) "cdr" "expression" 
            "arity-hash"
            (push) 
              (005) "list"
                    "'if"
                    (003) "list"
                          "'promise?"
                          (003) "cons" 
                                "'cdr" 
                                (first) "arity" "stack"
                    (003) "list"
                          "'force"
                          (003) "cons"
                                "'cdr"
                                (first) "arity" "stack"
                    (003) "cons"
                          "'cdr"
                          (first) "arity" "stack"
              (tails) "arity" "stack"

(schemefy!aa) "expression" "arity-hash" "stack" "function" "arity"
comment:
(003) "eq?" "function" "'ZEDc"
(schemefy!) (002) "cdr" "expression" "arity-hash" (push) (003) "cons" "'cons" (003) "map" delay-wrap (first) "arity" "stack" (tails) "arity" "stack"

(schemefy!aa) "expression" "arity-hash" "stack" "function" "arity"
comment:
#true
(schemefy!) (002) "cdr" "expression" "arity-hash" (push) (003) "cons" "function" (first) "arity" "stack" (tails) "arity" "stack"

(schemefy) "expression" "arity-hash"
comment:
#true
(002) "list" (schemefy!) (002) "reverse" "expression" "arity-hash" (stack)

(sentence-less?) "sentence1" "sentence2"
comment:
(002) "null?" "sentence2"
"#f"

(sentence-less?) "sentence1" "sentence2"
comment:
(002) "null?" "sentence1"
"#t"

(sentence-less?) "sentence1" "sentence2"
comment:
(character-less?) (002) "car" "sentence1" (002) "car" "sentence2"
"#t"

(sentence-less?) "sentence1" "sentence2"
comment:
(character-less?) (002) "car" "sentence2" (002) "car" "sentence1"
"#f"

(sentence-less?) "sentence1" "sentence2"
comment:
#true
(sentence-less?) (002) "cdr" "sentence1" (002) "cdr" "sentence2"

(sentences!) "program" "collect1" "collect2"
comment:
(002) "null?" "program"
"collect2"

(sentences!) "program" "collect1" "collect2"
comment:
(003) "eqv?" #newline (002) "car" "program"
(sentences!) (002) "cdr" "program" nil (003) "cons" (002) "reverse" "collect1" "collect2"

(sentences!) "program" "collect1" "collect2"
comment:
#true
(sentences!) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect1" "collect2"

(sentences) "program"
comment:
#true
(002) "reverse" (sentences!) "program" nil nil

(sort!a) "jumble"
comment:
#true
(003) "map" "list" "jumble"

(sort!b) "comparator" "jumble"
comment:
(002) "null?" "jumble"
nil

(sort!b) "comparator" "jumble"
comment:
(002) "null?" (002) "cdr" "jumble"
"jumble"

(sort!b) "comparator" "jumble"
comment:
#true
(sort!b) "comparator" (003) "cons" (merge) "comparator" (002) "car" "jumble" (002) "cadr" "jumble" (sort!b) "comparator" (002) "cddr" "jumble"

(sort) "comparator" "jumble"
comment:
#true
(002) "car" (sort!b) "comparator" (sort!a) "jumble"

(space-newline!) "program" "collect"
comment:
(003) "or" (002) "null?" "program" (002) "null?" (002) "cdr" "program"
(003) "append" "program" "collect"

(space-newline!) "program" "collect"
comment:
(003) "and" (003) "eqv?" #space (002) "car" "program" (003) "eqv?" #newline (002) "cadr" "program"
(space-newline!) (002) "cdr" "program" "collect"

(space-newline!) "program" "collect"
comment:
#true
(space-newline!) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect"

(space-newline) "program"
comment:
#true
(002) "reverse" (space-newline!) "program" nil

(stack)
comment:
#true
nil

(tab-replace!) "program" "collect"
comment:
(002) "null?" "program"
"collect"

(tab-replace!) "program" "collect"
comment:
(003) "eqv?" #tab (002) "car" "program"
(tab-replace!) (002) "cdr" "program" (003) "cons" #space "collect"

(tab-replace!) "program" "collect"
comment:
#true
(tab-replace!) (002) "cdr" "program" (003) "cons" (002) "car" "program" "collect"

(tab-replace) "program"
comment:
#true
(002) "reverse" (tab-replace!) "program" nil

(tails) "number" "list"
comment:
(002) "null?" "list"
nil

(tails) "number" "list"
comment:
(002) "zero?" "number"
"list"

(tails) "number" "list"
comment:
(003) ">" "number" 0
(tails) (003) "-" "number" 1 (002) "cdr" "list"

(top) "stack"
comment:
#true
(002) "car" "stack"

(true?) "noun-list"
comment:
#true
(003) "equal?" "noun-list" (006) "list" ## #t #r #u #e

(verb) "verb-list"
comment:
(literal?) "verb-list"
(002) "list" (make-literal) "verb-list"

(verb) "verb-list"
comment:
#true
(002) "list" (make-ZED) "verb-list"

(write-all) "program"
comment:
(002) "null?" "program"
err

(write-all) "program"
comment:
#true
(write-all) (003) "begin" (002) "write-char" (002) "car" "program" (002) "cdr" "program"

(zed->scheme!) "value" "collect"
comment:
(002) "null?" "value"
(002) "reverse" "collect"

(zed->scheme!) "value" "collect"
comment:
#true
(zed->scheme!) (!) "value" (003) "cons" (zed->scheme) (1) "value" "collect"

(zed->scheme) "value"
comment:
(002) "not" (002) "pair?" "value"
"value"

(zed->scheme) "value"
comment:
#true
(zed->scheme!) "value" nil

tinyZED.scm

    (begin (define (ZED* ZEDnumber1 ZEDnumber2) (cond (#t (* ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED+ ZEDnumber1 ZEDnumber2) (cond (#t (+ ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED- ZEDnumber1 ZEDnumber2) (cond (#t (- ZEDnumber1 ZEDnumbe2)) (else err))) (define (ZED/ ZEDnumber1 ZEDnumber2) (cond (#t (/ ZEDnumber1 ZEDnumber2)) (else err))) (define (ZED= value1 value2) (cond (#t (eqv? value1 value2)) (else err))) (define (ZEDadd-between! item list collect) (cond ((null? list) collect) ((null? (cdr list)) (cons (car list) collect)) (#t (ZEDadd-between! item (cdr list) (cons item (cons (car list) collect)))) (else err))) (define (ZEDadd-between item list) (cond (#t (reverse (ZEDadd-between! item list (quote ())))) (else err))) (define (ZEDadd-between-ra list item) (cond (#t (reverse (ZEDadd-between! item list (quote ())))) (else err))) (define (ZEDalpha) (cond (#t (ZEDwrite-all (ZEDrd (quote ()) append (ZEDrd (quote ()) append (ZEDnewlines (ZEDby-four (ZEDfunction-sort (ZEDsentences (ZEDleading-newline (ZEDspace-newline (ZEDtab-replace (ZEDnewline-space-tab-repeats (ZEDnewline-space (ZEDfilter ZEDnot-return? (ZEDreplace-trailing-white-space (ZEDread-all)))))))))))))))) (else err))) (define (ZEDapplication? expression) (cond (#t (and (not (null? expression)) (pair? (car expression)) (null? (cdar expression)))) (else err))) (define (ZEDarity arity-hash function) (cond (#t (cdr (assoc function arity-hash))) (else err))) (define (ZEDarity-hash! clause) (cond (#t (cons (ZEDclause-name clause) (ZEDclause-arity clause))) (else err))) (define (ZEDarity-hash program) (cond (#t (append (map ZEDarity-hash! program) (append (list (cons (quote ZED1) 1) (cons (quote ZED!) 1) (cons (quote ZED001) 1) (cons (quote or) 2) (cons (quote and) 2) (cons (quote begin) 2) (cons (quote ZEDc) 2) (cons (quote quote) 1)) (list (cons (quote ZED002) 2) (cons (quote ZED003) 3) (cons (quote ZED004) 4) (cons (quote ZED005) 5) (cons (quote ZED006) 6) (cons (quote ZED007) 7) (cons (quote ZED008) 8) (cons (quote ZED009) 9) (cons (quote ZED010) 10) (cons (quote ZED011) 11) (cons (quote ZED012) 12) (cons (quote ZED013) 13) (cons (quote ZED014) 14) (cons (quote ZED015) 15) (cons (quote ZED016) 16) (cons (quote ZED017) 17) (cons (quote ZED018) 18) (cons (quote ZED019) 19) (cons (quote ZED020) 20) (cons (quote ZED021) 21) (cons (quote ZED022) 22) (cons (quote ZED023) 23) (cons (quote ZED024) 24) (cons (quote ZED025) 25) (cons (quote ZED026) 26) (cons (quote ZED027) 27) (cons (quote ZED028) 28) (cons (quote ZED029) 29) (cons (quote ZED030) 30) (cons (quote ZED031) 31) (cons (quote ZED032) 32) (cons (quote ZED033) 33) (cons (quote ZED034) 34) (cons (quote ZED035) 35) (cons (quote ZED036) 36) (cons (quote ZED037) 37) (cons (quote ZED038) 38) (cons (quote ZED039) 39) (cons (quote ZED040) 40) (cons (quote ZED041) 41) (cons (quote ZED042) 42) (cons (quote ZED043) 43) (cons (quote ZED044) 44) (cons (quote ZED045) 45) (cons (quote ZED046) 46) (cons (quote ZED047) 47) (cons (quote ZED048) 48) (cons (quote ZED049) 49) (cons (quote ZED050) 50) (cons (quote ZED051) 51) (cons (quote ZED052) 52) (cons (quote ZED053) 53) (cons (quote ZED054) 54) (cons (quote ZED055) 55) (cons (quote ZED056) 56) (cons (quote ZED057) 57) (cons (quote ZED058) 58) (cons (quote ZED059) 59) (cons (quote ZED060) 60) (cons (quote ZED061) 61) (cons (quote ZED062) 62) (cons (quote ZED063) 63) (cons (quote ZED064) 64) (cons (quote ZED065) 65) (cons (quote ZED066) 66) (cons (quote ZED067) 67) (cons (quote ZED068) 68) (cons (quote ZED069) 69) (cons (quote ZED070) 70) (cons (quote ZED071) 71) (cons (quote ZED072) 72) (cons (quote ZED073) 73) (cons (quote ZED074) 74) (cons (quote ZED075) 75) (cons (quote ZED076) 76) (cons (quote ZED077) 77) (cons (quote ZED078) 78) (cons (quote ZED079) 79) (cons (quote ZED080) 80) (cons (quote ZED081) 81) (cons (quote ZED082) 82) (cons (quote ZED083) 83) (cons (quote ZED084) 84) (cons (quote ZED085) 85) (cons (quote ZED086) 86) (cons (quote ZED087) 87) (cons (quote ZED088) 88) (cons (quote ZED089) 89) (cons (quote ZED090) 90) (cons (quote ZED091) 91) (cons (quote ZED092) 92) (cons (quote ZED093) 93) (cons (quote ZED094) 94) (cons (quote ZED095) 95) (cons (quote ZED096) 96) (cons (quote ZED097) 97) (cons (quote ZED098) 98) (cons (quote ZED099) 99))))) (else err))) (define (ZEDby-four! sentences collect) (cond ((null? sentences) collect) (#t (ZEDby-four! (cddddr sentences) (cons (list (car sentences) (cadr sentences) (caddr sentences) (cadddr sentences)) collect))) (else err))) (define (ZEDby-four sentences) (cond (#t (reverse (ZEDby-four! sentences (quote ())))) (else err))) (define (ZEDby-three! sentences collect) (cond ((null? sentences) collect) (#t (ZEDby-three! (cdddr sentences) (cons (list (car sentences) (cadr sentences) (caddr sentences)) collect))) (else err))) (define (ZEDby-three sentences) (cond (#t (reverse (ZEDby-three! sentences (quote ())))) (else err))) (define (ZEDcharacter-less? character1 character2) (cond (#t (< (char->integer character1) (char->integer character2))) (else err))) (define (ZEDclause-arguments clause) (cond (#t (cadr clause)) (else err))) (define (ZEDclause-arguments-agree clause1 clause2) (cond ((equal? (ZEDclause-arguments clause1) (ZEDclause-arguments clause2)) (ZEDclause-arguments clause1)) (else err))) (define (ZEDclause-arity clause) (cond (#t (length (ZEDclause-arguments clause))) (else err))) (define (ZEDclause-body clause) (cond (#t (cddr clause)) (else err))) (define (ZEDclause-less? clause1 clause2) (cond (#t (ZEDsentence-less? (car clause1) (car clause2))) (else err))) (define (ZEDclause-name clause) (cond (#t (car clause)) (else err))) (define (ZEDclause-name-agree clause1 clause2) (cond ((eq? (ZEDclause-name clause1) (ZEDclause-name clause2)) (ZEDclause-name clause1)) (else err))) (define (ZEDcombine-all! program collect) (cond ((null? program) collect) ((null? (cdr program)) (cons (car program) collect)) ((eq? (ZEDclause-name (car program)) (ZEDclause-name (cadr program))) (ZEDcombine-all! (ZEDcombine-head-clauses program) collect)) (#t (ZEDcombine-all! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDcombine-all program) (cond (#t (reverse (ZEDcombine-all! program (quote ())))) (else err))) (define (ZEDcombine-clauses clause1 clause2) (cond (#t (cons (ZEDclause-name-agree clause1 clause2) (cons (ZEDclause-arguments-agree clause1 clause2) (append (ZEDclause-body clause1) (ZEDclause-body clause2))))) (else err))) (define (ZEDcombine-head-clauses program) (cond (#t (cons (ZEDcombine-clauses (car program) (cadr program)) (cddr program))) (else err))) (define (ZEDcombine-program-clauses program) (cond (#t (ZEDcombine-all (ZEDready-program program))) (else err))) (define (ZEDcomp!) (cond (#t (ZEDcomp!a (ZEDcombine-program-clauses (ZEDby-three (ZEDread-sentences (ZEDdiscard-comments (ZEDfunction-sort (ZEDsentences (ZEDleading-newline (ZEDspace-newline (ZEDtab-replace (ZEDnewline-space-tab-repeats (ZEDnewline-space (ZEDfilter ZEDnot-return? (ZEDreplace-trailing-white-space (ZEDread-all)))))))))))))))) (else err))) (define (ZEDcomp!a combined) (cond (#t (ZEDcomp!aa (ZEDprogramize combined (ZEDarity-hash combined)))) (else err))) (define (ZEDcomp!aa programized) (cond (#t (write programized)) (else err))) (define (ZEDcomp) (cond (#t (ZEDcomp!)) (else err))) (define (ZEDcondefy! expressions collect) (cond ((null? expressions) collect) (#t (ZEDcondefy! (cddr expressions) (cons (append (car expressions) (cadr expressions)) collect))) (else err))) (define (ZEDcondefy expressions) (cond (#t (reverse (ZEDcondefy! expressions (quote ())))) (else err))) (define (ZEDcons ZEDvalue1 ZEDvalue2) (cond (#t (cons ZEDvalue1 ZEDvalue2)) (else err))) (define (ZEDcount ZEDnumber) (cond (#t (cons (delay ZEDnumber) (delay (ZEDcount (ZED+ ZEDnumber 1))))) (else err))) (define (ZEDcount-by ZEDstep ZEDnumber) (cond (#t (cons (delay ZEDnumber) (delay (ZEDcount-by ZEDstep (ZED+ ZEDnumber ZEDstep))))) (else err))) (define (ZEDdelay-wrap expression) (cond (#t (list (quote delay) expression)) (else err))) (define (ZEDdigit? character) (cond (#t (or (eqv? #\0 character) (eqv? #\1 character) (eqv? #\2 character) (eqv? #\3 character) (eqv? #\4 character) (eqv? #\5 character) (eqv? #\6 character) (eqv? #\7 character) (eqv? #\8 character) (eqv? #\9 character))) (else err))) (define (ZEDdiscard-comments! program collect) (cond ((null? program) collect) (#t (ZEDdiscard-comments! (cddddr program) (cons (cadddr program) (cons (caddr program) (cons (car program) collect))))) (else err))) (define (ZEDdiscard-comments program) (cond (#t (reverse (ZEDdiscard-comments! program (quote ())))) (else err))) (define (ZEDdr! value) (cond ((pair? value) (ZEDmp ZEDdr! (ZEDfirst 64 value))) (#t value) (else err))) (define (ZEDdr value) (cond (#t (begin (display (ZEDpr (ZEDdr! value))) (newline) (newline) value)) (else err))) (define (ZEDdrr value) (cond (#t (begin (display (ZEDpr value)) (newline) (newline) value)) (else err))) (define (ZEDfalse? noun-list) (cond (#t (equal? noun-list (list #\# #\f #\a #\l #\s #\e))) (else err))) (define (ZEDfi function list) (cond ((null? list) (quote ())) ((function (if (promise? (car list)) (force (car list)) (car list))) (cons (delay (if (promise? (car list)) (force (car list)) (car list))) (delay (ZEDfi function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))))) (#t (ZEDfi function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (else err))) (define (ZEDfilter! predicate list collect) (cond ((null? list) collect) ((predicate (car list)) (ZEDfilter! predicate (cdr list) (cons (car list) collect))) (#t (ZEDfilter! predicate (cdr list) collect)) (else err))) (define (ZEDfilter predicate list) (cond (#t (reverse (ZEDfilter! predicate list (quote ())))) (else err))) (define (ZEDfirst! integer list collect) (cond ((or (zero? integer) (null? list)) (reverse collect)) ((not (pair? list)) (reverse (cons list collect))) ((> integer 0) (ZEDfirst! (- integer 1) (if (promise? (cdr list)) (force (cdr list)) (cdr list)) (cons (if (promise? (car list)) (force (car list)) (car list)) collect))) (else err))) (define (ZEDfirst integer list) (cond ((not (pair? list)) list) (#t (ZEDfirst! integer list (quote ()))) (else err))) (define (ZEDflatten! ZEDlist ZEDsub-list-found? ZEDcollect) (cond ((and (ZEDnull? ZEDlist) (ZEDnot ZEDsub-list-found?)) (ZEDreverse ZEDcollect)) ((ZEDnull? ZEDlist) (ZEDflatten! (ZEDreverse ZEDcollect) #f (quote ()))) ((ZEDnot (ZEDpair? ZEDlist)) (ZEDflatten! (quote ()) ZEDsub-list-found? (ZEDcons ZEDlist ZEDcollect))) ((ZEDpair? (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist))) (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) #t (ZEDcons (if (promise? (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (force (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (cdr (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (ZEDcons (if (promise? (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (force (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) (car (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)))) ZEDcollect)))) ((ZEDnull? (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist))) (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) ZEDsub-list-found? ZEDcollect)) (#t (ZEDflatten! (if (promise? (cdr ZEDlist)) (force (cdr ZEDlist)) (cdr ZEDlist)) ZEDsub-list-found? (ZEDcons (if (promise? (car ZEDlist)) (force (car ZEDlist)) (car ZEDlist)) ZEDcollect))) (else err))) (define (ZEDflatten ZEDlist) (cond (#t (ZEDflatten! ZEDlist #f (quote ()))) (else err))) (define (ZEDfor-each ZEDeffect ZEDlist) (cond (#t (for-each ZEDeffect ZEDlist)) (else err))) (define (ZEDfunction expression) (cond (#t (caar expression)) (else err))) (define (ZEDfunction-sort sentences) (cond (#t (ZEDrd (quote ()) append (ZEDsort ZEDclause-less? (ZEDby-four sentences)))) (else err))) (define (ZEDfunctionize clause arity-hash) (cond (#t (list (quote define) (cons (ZEDclause-name clause) (ZEDclause-arguments clause)) (cons (quote cond) (append (ZEDcondefy (ZEDmap-with ZEDschemefy (ZEDclause-body clause) arity-hash)) (list (list (quote else) (quote err))))))) (else err))) (define (ZEDgather-count?! candidate) (cond (#t (and (= 6 (length candidate)) (eqv? #\Z (car candidate)) (eqv? #\E (cadr candidate)) (eqv? #\D (caddr candidate)) (eqv? #\0 (cadddr candidate)) (ZEDdigit? (car (cddddr candidate))) (ZEDdigit? (cadr (cddddr candidate))))) (else err))) (define (ZEDgather-count? symbol) (cond (#t (ZEDgather-count?! (string->list (symbol->string symbol)))) (else err))) (define (ZEDgather-noun sentence) (cond ((null? sentence) (quote ())) ((eqv? #\space (car sentence)) (quote ())) (#t (cons (car sentence) (ZEDgather-noun (cdr sentence)))) (else err))) (define (ZEDgather-verb sentence) (cond ((eqv? #\) (car sentence)) (quote ())) (#t (cons (car sentence) (ZEDgather-verb (cdr sentence)))) (else err))) (define (ZEDgr garbage value) (cond (#t (begin (ZEDdr garbage) value)) (else err))) (define (ZEDgrr garbage value) (cond (#t (begin (ZEDdrr garbage) value)) (else err))) (define (ZEDleading-newline program) (cond ((null? program) (quote ())) ((eqv? #\newline (car program)) (cdr program)) (#t program) (else err))) (define (ZEDliteral? literal-list) (cond (#t (eqv? #\" (car literal-list))) (else err))) (define (ZEDmake-ZED ZED-list) (cond ((equal? ZED-list (list #\e #\r #\r)) "'err") ((equal? ZED-list (list #\n #\i #\l)) "'()") ((equal? ZED-list (list #\a #\n #\d)) "and") ((equal? ZED-list (list #\o #\r)) "or") ((equal? ZED-list (list #\q #\u #\o #\t #\e)) "quote") ((equal? ZED-list (list #\s #\e)) "begin") (#t (list->string (append (list #\Z #\E #\D) ZED-list))) (else err))) (define (ZEDmake-character noun-list) (cond (#t (list->string (cons #\# (cons #\\ (cdr noun-list))))) (else err))) (define (ZEDmake-exact exact-list) (cond (#t (list->string (append (list #\# #\e) exact-list))) (else err))) (define (ZEDmake-literal literal-list) (cond (#t (list->string (cdr (reverse (cdr (reverse literal-list)))))) (else err))) (define (ZEDmake-number-character noun-list) (cond (#t (list->string (list #\# #\\ (integer->char (string->number (list->string (cddr noun-list))))))) (else err))) (define (ZEDmap-with! function list extra collect) (cond ((null? list) collect) (#t (ZEDmap-with! function (cdr list) extra (cons (function (car list) extra) collect))) (else err))) (define (ZEDmap-with function list extra) (cond (#t (reverse (ZEDmap-with! function list extra (quote ())))) (else err))) (define (ZEDmerge! comparator list1 list2 collect) (cond ((null? list2) (append (reverse collect) list1)) ((null? list1) (append (reverse collect) list2)) ((comparator (car list2) (car list1)) (ZEDmerge! comparator list1 (cdr list2) (cons (car list2) collect))) (#t (ZEDmerge! comparator (cdr list1) list2 (cons (car list1) collect))) (else err))) (define (ZEDmerge comparator list1 list2) (cond (#t (ZEDmerge! comparator list1 list2 (quote ()))) (else err))) (define (ZEDmp function list) (cond ((null? list) (quote ())) ((pair? list) (cons (delay (function (if (promise? (car list)) (force (car list)) (car list)))) (delay (ZEDmp function (if (promise? (cdr list)) (force (cdr list)) (cdr list)))))) (#t (function list)) (else err))) (define (ZEDnewline-space! program) (cond (#t (cons #\newline (ZEDnewline-space!a program))) (else err))) (define (ZEDnewline-space!a program) (cond (#t (ZEDnewline-space!aa program (reverse (ZEDnewline-space!ab program (quote ()))))) (else err))) (define (ZEDnewline-space!aa program transformed) (cond ((equal? program transformed) program) (#t (ZEDnewline-space!a transformed)) (else err))) (define (ZEDnewline-space!ab program collect) (cond ((null? program) collect) ((null? (cdr program)) (cons (car program) collect)) ((and (eqv? #\newline (car program)) (or (eqv? #\space (cadr program)) (eqv? #\ht (cadr program)))) (ZEDnewline-space!ab (cdr program) collect)) (#t (ZEDnewline-space!ab (cdr program) (cons (car program) collect))) (else err))) (define (ZEDnewline-space program) (cond (#t (ZEDnewline-space! program)) (else err))) (define (ZEDnewline-space-tab-repeats! program collect) (cond ((or (null? program) (null? (cdr program))) (append program collect)) ((and (eqv? #\newline (car program)) (eqv? #\newline (cadr program))) (ZEDnewline-space-tab-repeats! (cdr program) collect)) ((and (or (eqv? #\space (car program)) (eqv? #\ht (car program))) (or (eqv? #\space (cadr program)) (eqv? #\ht (cadr program)))) (ZEDnewline-space-tab-repeats! (cdr program) collect)) (#t (ZEDnewline-space-tab-repeats! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDnewline-space-tab-repeats program) (cond (#t (reverse (ZEDnewline-space-tab-repeats! program (quote ())))) (else err))) (define (ZEDnewlines clauses) (cond (#t (ZEDadd-between-ra (ZEDmap-with ZEDadd-between-ra clauses (list #\newline)) (list (list #\newline #\newline)))) (else err))) (define (ZEDnormal-character? noun-list) (cond (#t (eqv? (car noun-list) #\#)) (else err))) (define (ZEDnot ZEDvalue) (cond (#t (not ZEDvalue)) (else err))) (define (ZEDnot-return? character) (cond (#t (not (eqv? #\cr character))) (else err))) (define (ZEDnoun! noun-list number?) (cond (number? (ZEDmake-exact noun-list)) ((ZEDliteral? noun-list) (ZEDmake-literal noun-list)) ((ZEDtrue? noun-list) "#t") ((ZEDfalse? noun-list) "#f") ((ZEDnumber-character? noun-list) (ZEDmake-number-character noun-list)) ((ZEDnormal-character? noun-list) (ZEDmake-character noun-list)) (#t (ZEDmake-ZED noun-list)) (else err))) (define (ZEDnoun noun-list) (cond (#t (ZEDnoun! noun-list (string->number (list->string noun-list)))) (else err))) (define (ZEDnull? ZEDvalue) (cond (#t (null? ZEDvalue)) (else err))) (define (ZEDnumber-character? noun-list) (cond (#t (and (eqv? (car noun-list) #\#) (eqv? (cadr noun-list) #\0) (not (null? (cddr noun-list))))) (else err))) (define (ZEDpair? ZEDvalue) (cond (#t (pair? ZEDvalue)) (else err))) (define (ZEDpop stack) (cond (#t (cdr stack)) (else err))) (define (ZEDpr! value output-string) (cond (#t (begin (display (ZEDpr!a value (quote ())) output-string) (ZEDpr!b output-string (get-output-string output-string)))) (else err))) (define (ZEDpr!a value collect) (cond ((char? value) (ZEDpr!aa (list->string (list #\# value)) collect)) ((string? value) (ZEDpr!aa (string-append "\"" value "\"") collect)) ((symbol? value) (ZEDpr!aa (symbol->string value) collect)) ((number? value) (ZEDpr!aa (number->string value) collect)) ((and (boolean? value) value) (ZEDpr!aa "#true" collect)) ((boolean? value) (ZEDpr!aa "#false" collect)) ((null? value) (reverse collect)) (#t (ZEDpr!a (if (promise? (cdr value)) (force (cdr value)) (cdr value)) (cons (ZEDpr!a (if (promise? (car value)) (force (car value)) (car value)) (quote ())) collect))) (else err))) (define (ZEDpr!aa string collect) (cond ((null? collect) string) (#t (reverse (cons string (cons "." collect)))) (else err))) (define (ZEDpr!b output-string value) (cond (#t (begin (close-output-port output-string) value)) (else err))) (define (ZEDpr value) (cond (#t (ZEDpr! value (open-output-string))) (else err))) (define (ZEDprogramize program arity-hash) (cond (#t (cons (quote begin) (ZEDmap-with ZEDfunctionize program arity-hash))) (else err))) (define (ZEDpush object stack) (cond (#t (cons object stack)) (else err))) (define (ZEDrd! function list) (cond ((null? (if (promise? (cdr list)) (force (cdr list)) (cdr list))) (if (promise? (car list)) (force (car list)) (car list))) (#t (ZEDrd! function (cons (function (if (promise? (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (force (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (car (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (if (promise? (car list)) (force (car list)) (car list))) (if (promise? (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (force (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list)))) (cdr (if (promise? (cdr list)) (force (cdr list)) (cdr list))))))) (else err))) (define (ZEDrd final function list) (cond (#t (ZEDrd! function (cons final (reverse list)))) (else err))) (define (ZEDread-all! collect) (cond (#t (ZEDread-all!a (read-char) collect)) (else err))) (define (ZEDread-all!a character collect) (cond ((eof-object? character) collect) (#t (ZEDread-all! (cons character collect))) (else err))) (define (ZEDread-all) (cond (#t (reverse (ZEDread-all! (quote ())))) (else err))) (define (ZEDread-sentence!a sentence collect) (cond ((null? sentence) collect) ((eqv? #\space (car sentence)) (ZEDread-sentence!a (cdr sentence) collect)) ((eqv? #\( (car sentence)) (ZEDread-sentence!aa sentence (ZEDgather-verb (cdr sentence)) collect)) (#t (ZEDread-sentence!ab sentence (ZEDgather-noun sentence) collect)) (else err))) (define (ZEDread-sentence!aa sentence gather-verb collect) (cond (#t (ZEDread-sentence!a (ZEDtails (+ 2 (length gather-verb)) sentence) (cons (ZEDverb gather-verb) collect))) (else err))) (define (ZEDread-sentence!ab sentence gather-noun collect) (cond (#t (ZEDread-sentence!a (ZEDtails (length gather-noun) sentence) (cons (ZEDnoun gather-noun) collect))) (else err))) (define (ZEDread-sentence!b list output-string) (cond (#t (begin (display list output-string) (ZEDread-sentence!ba output-string (get-output-string output-string)))) (else err))) (define (ZEDread-sentence!ba output-string get-output-string) (cond (#t (begin (close-output-port output-string) (ZEDread-sentence!baa (open-input-string get-output-string)))) (else err))) (define (ZEDread-sentence!baa input-string) (cond (#t (ZEDread-sentence!baaa input-string (read input-string))) (else err))) (define (ZEDread-sentence!baaa input-string answer) (cond (#t (begin (close-input-port input-string) answer)) (else err))) (define (ZEDread-sentence sentence) (cond (#t (ZEDread-sentence!b (reverse (ZEDread-sentence!a sentence (quote ()))) (open-output-string))) (else err))) (define (ZEDread-sentences sentences) (cond (#t (map ZEDread-sentence sentences)) (else err))) (define (ZEDready-clause clause) (cond (#t (cons (caaar clause) (cons (cdar clause) (cdr clause)))) (else err))) (define (ZEDready-program program) (cond (#t (map ZEDready-clause program)) (else err))) (define (ZEDreplace-trailing-white-space! program) (cond ((null? program) (quote ())) ((or (eqv? (car program) #\space) (eqv? (car program) #\ht) (eqv? (car program) #\cr) (eqv? (car program) #\newline)) (ZEDreplace-trailing-white-space! (cdr program))) (#t (cons #\newline program)) (else err))) (define (ZEDreplace-trailing-white-space program) (cond (#t (reverse (ZEDreplace-trailing-white-space! (reverse program)))) (else err))) (define (ZEDreverse ZEDlist) (cond (#t (reverse ZEDlist)) (else err))) (define (ZEDschemefy! expression arity-hash stack) (cond ((null? expression) (ZEDtop stack)) ((ZEDapplication? expression) (ZEDschemefy!a expression arity-hash stack (ZEDfunction expression))) (#t (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (car expression) stack))) (else err))) (define (ZEDschemefy!a expression arity-hash stack function) (cond (#t (ZEDschemefy!aa expression arity-hash stack function (ZEDarity arity-hash function))) (else err))) (define (ZEDschemefy!aa expression arity-hash stack function arity) (cond ((ZEDgather-count? function) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (ZEDfirst arity stack) (ZEDtails arity stack)))) ((eq? function (quote ZED1)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (list (quote if) (list (quote promise?) (cons (quote car) (ZEDfirst arity stack))) (list (quote force) (cons (quote car) (ZEDfirst arity stack))) (cons (quote car) (ZEDfirst arity stack))) (ZEDtails arity stack)))) ((eq? function (quote ZED!)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (list (quote if) (list (quote promise?) (cons (quote cdr) (ZEDfirst arity stack))) (list (quote force) (cons (quote cdr) (ZEDfirst arity stack))) (cons (quote cdr) (ZEDfirst arity stack))) (ZEDtails arity stack)))) ((eq? function (quote ZEDc)) (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (cons (quote cons) (map ZEDdelay-wrap (ZEDfirst arity stack))) (ZEDtails arity stack)))) (#t (ZEDschemefy! (cdr expression) arity-hash (ZEDpush (cons function (ZEDfirst arity stack)) (ZEDtails arity stack)))) (else err))) (define (ZEDschemefy expression arity-hash) (cond (#t (list (ZEDschemefy! (reverse expression) arity-hash (ZEDstack)))) (else err))) (define (ZEDsentence-less? sentence1 sentence2) (cond ((null? sentence2) #f) ((null? sentence1) #t) ((ZEDcharacter-less? (car sentence1) (car sentence2)) #t) ((ZEDcharacter-less? (car sentence2) (car sentence1)) #f) (#t (ZEDsentence-less? (cdr sentence1) (cdr sentence2))) (else err))) (define (ZEDsentences! program collect1 collect2) (cond ((null? program) collect2) ((eqv? #\newline (car program)) (ZEDsentences! (cdr program) (quote ()) (cons (reverse collect1) collect2))) (#t (ZEDsentences! (cdr program) (cons (car program) collect1) collect2)) (else err))) (define (ZEDsentences program) (cond (#t (reverse (ZEDsentences! program (quote ()) (quote ())))) (else err))) (define (ZEDsort!a jumble) (cond (#t (map list jumble)) (else err))) (define (ZEDsort!b comparator jumble) (cond ((null? jumble) (quote ())) ((null? (cdr jumble)) jumble) (#t (ZEDsort!b comparator (cons (ZEDmerge comparator (car jumble) (cadr jumble)) (ZEDsort!b comparator (cddr jumble))))) (else err))) (define (ZEDsort comparator jumble) (cond (#t (car (ZEDsort!b comparator (ZEDsort!a jumble)))) (else err))) (define (ZEDspace-newline! program collect) (cond ((or (null? program) (null? (cdr program))) (append program collect)) ((and (eqv? #\space (car program)) (eqv? #\newline (cadr program))) (ZEDspace-newline! (cdr program) collect)) (#t (ZEDspace-newline! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDspace-newline program) (cond (#t (reverse (ZEDspace-newline! program (quote ())))) (else err))) (define (ZEDstack) (cond (#t (quote ())) (else err))) (define (ZEDtab-replace! program collect) (cond ((null? program) collect) ((eqv? #\ht (car program)) (ZEDtab-replace! (cdr program) (cons #\space collect))) (#t (ZEDtab-replace! (cdr program) (cons (car program) collect))) (else err))) (define (ZEDtab-replace program) (cond (#t (reverse (ZEDtab-replace! program (quote ())))) (else err))) (define (ZEDtails number list) (cond ((null? list) (quote ())) ((zero? number) list) ((> number 0) (ZEDtails (- number 1) (cdr list))) (else err))) (define (ZEDtop stack) (cond (#t (car stack)) (else err))) (define (ZEDtrue? noun-list) (cond (#t (equal? noun-list (list #\# #\t #\r #\u #\e))) (else err))) (define (ZEDverb verb-list) (cond ((ZEDliteral? verb-list) (list (ZEDmake-literal verb-list))) (#t (list (ZEDmake-ZED verb-list))) (else err))) (define (ZEDwrite-all program) (cond ((null? program) (quote err)) (#t (ZEDwrite-all (begin (write-char (car program)) (cdr program)))) (else err))) (define (ZEDzed->scheme! value collect) (cond ((null? value) (reverse collect)) (#t (ZEDzed->scheme! (if (promise? (cdr value)) (force (cdr value)) (cdr value)) (cons (ZEDzed->scheme (if (promise? (car value)) (force (car value)) (car value))) collect))) (else err))) (define (ZEDzed->scheme value) (cond ((not (pair? value)) value) (#t (ZEDzed->scheme! value (quote ()))) (else err))))