trac_lang 0.1.0

data/examples/golf.trl

@@ -0,0 +1,113 @@
+
+Code Golf
+
+#(PS,Loading examples/golf.trl...)'
+
+TRAC is never going to win a Code Golf competition.  It's lack of primitives
+makes it difficult to do anything under a hundred characters.  However, trying
+to figure out how to write certain things in TRAC does help you learn the ins
+and outs of the language.  Below are a few of my attempts at some of the Code 
+Golf challenges.
+
+-------------------------------------------------------------------------------
+The Curious Case of Steve Ballmer - 158 characters
+
+#(DS,x,Steve Ballmer still does not know;what he did;wrong;with mobile)#(SS,x,;)#(DS,,(#(PS,(a.
+))#(EQ,b,.,,(#(,a b,#(CS,x,.))))))#(SS,,a,b)#(,#(CS,x),#(CS,x))'
+
+Ungolfed Version:
+
+(
+#(DS,sentence,Steve Ballmer still does not know;what he did;wrong;with mobile)
+#(SS,sentence,;)
+#(DS,print-phrase,
+  (#(PS,(<phrase>.
+))#(EQ,<next-phrase>,*END*,,(
+   #(print-phrase,<phrase> <next-phrase>,#(CS,sentence,*END*)))
+)))
+#(SS,print-phrase,<phrase>,<next-phrase>)
+#(print-phrase,#(CS,sentence),#(CS,sentence))
+)
+
+-------------------------------------------------------------------------------
+Am I A Secondary Taxi? - 219 characters
+
+#(DS,3,(#(ML,n,#(ML,n,n))))#(SS,3,n)#(DS,,(#(EQ,#(AD,#(3,i),#(3,j)),n,(#(DS,+,#(AD,1,#(+)))))))#(SS,,n,i,j)#(DS,x,(#(,n,i,j)#(EQ,j,n,(#(GR,#(+),1,T,F)),(#(EQ,i,n,(#(,n,1,#(AD,1,j))),(#(,n,#(AD,1,i),j)))))))#(SS,x,n,i,j)'
+
+Ungolfed version:
+
+(
+#(DS,cube,
+  (#(ML,<n>,#(ML,<n>,<n>))))
+#(SS,cube,<n>)
+
+#(DS,test,
+  (#(EQ,<n>,#(AD,#(cube,<i>),#(cube,<j>)),
+      (#(DS,total,#(AD,1,#(total)))))))
+#(SS,test,n,i,j)
+
+#(DS,taxi,
+  (#(test,<n>,<i>,<j>)
+   #(EQ,<j>,<n>,
+     (#(GR,#(total),1,T,F)),
+     (#(EQ,<i>,<n>,
+       (#(test,<n>,1,#(AD,1,<j>))),
+       (#(test,<n>,#(AD,1,<i>),<j>)))))))
+#(SS,taxi,<n>,<i>,<j>)
+)
+
+-------------------------------------------------------------------------------
+Unique Is Cheap - 99 characters
+
+Assume string to test is contained in form s:
+
+#(DS,$,(#(EQ,c,**,+,(#(DS,c,#(AD,1,#(c)))#($,#(CC,s,**),#(AD,+,#(c)))))))#(SS,$,c,+)#($,#(CC,s,**))'
+
+Ungolfed version:
+
+Assume string to test is contained in form "string":
+
+(
+#(DS,cost,
+(#(EQ,<c>,**,<total>,
+  (#(DS,<c>,#(AD,1,#(<c>)))
+   #(cost,#(CC,string,**),#(AD,<total>,#(<c>)))
+  )
+)))
+#(SS,cost,<c>,<total>)
+#(cost,#(CC,string,**))
+)
+
+-------------------------------------------------------------------------------
+Fewest (distinct) characters for Turing Completeness - 6 characters
+
+hash, open-paren, close-paren, comma, D and S
+
+With these six characters, you have the commands DS, SS, and DD.  
+
+How do you define branching?  We can use the fact that when you define a form
+with the same name as an existing form, the existing form is replaced.  This
+technique comes from page 19 of Chapter 9 of the Beginner's Manual for TRAC
+Language:
+
+https://web.archive.org/web/20050214150205/http://tracfoundation.org:80/trac64/T64manual.htm
+(
+#(DS,DDD,(#(DS,(DDS),(SDD))#(DS,(DSD),(DSS))#((DDS))))
+#(SS,DDD,DDS,DSD,DSS,SDD)
+)
+Ungolfed version:
+(
+#(DS,"eq",
+  (#(DS,(a),(F))
+   #(DS,(b),(T))
+   #((a))
+))
+#(SS,"eq",a,b,T,F)
+)
+
+If a equals b, then the definition of b will overwrite the definition of a, and
+T will be returned.  Otherwise, F will be returned.
+
+
+#(PS,(success!
+))'

data/examples/list.trl

@@ -0,0 +1,125 @@
+
+List Processing
+
+#(PS,Loading examples/list.trl...)'
+
+Basics
+------
+
+We need another anonymous form class for creating the links that make up lists.
+
+#(anonymous,link)'
+   
+We define nil as an empty list, containing nothing.
+
+#(DS,nil)'
+
+Now we can define the list primitives.  These are basically the same as used in
+Lisp.  Notice that I use the dot special character for delimiting, so that
+lists can contain any data.
+
+The cons form has some error checking because it's very easy to forget to put
+in the final nil when you're constructing a list.
+
+#(DS,cons,(
+  #(EQ,(list),,(
+    #(link,#(.),(value)#(.)nil)
+  ),(
+    #(link,#(.),(value)#(.)(list))
+  ))
+))
+#(sss,cons,(value,list))'
+#(DS,car,(#(CS,list)#(CR,list)))
+#(SS,car,list)'
+#(DS,cdr,(#(CS,list,,#(CS,list))#(CR,list)))
+#(SS,cdr,list)'
+
+#(DS,null?,(#(EQ,list,nil,(T),(F))))
+#(SS,null?,list,T,F)'
+
+Pair? is just a synonym for link?, the test that checks if the given value is a
+defined link.  Atom? is an antonym for link?.
+
+#(DS,pair?,(#(link?,item,(T),(F))))
+#(SS,pair?,item,T,F)'
+
+#(DS,atom?,(#(link?,item,(F),(T))))
+#(SS,atom?,item,T,F)'
+
+List is our synatic sugar for repeated cons'ing.  
+
+#(DS,list,(
+  #(DS,args,(objs))
+  #(SS,args,(,))
+  #(DS,[list],(
+    #(EQ,(value),#(.),nil,(
+      #(cons,(value),#([list],##(CS,args,#(.))))
+    ))
+  ))
+  #(SS,[list],value)
+  #([list],#(CS,args,#(.)))#(DD,args,[list])
+))
+#(sss,list,objs)'
+
+You use it like this:
+(
+    #(list,(1/2,1/3,1/4))
+)
+And it would be nice to be able to display the contents of our lists:
+
+#(DS,print-list,(
+  #(null?,<list>,nil,(
+    #(car,<list>)(,)#(print-list,#(cdr,<list>))
+  ))
+))
+#(sss,print-list,<list>)'
+
+
+List Functions
+--------------
+
+Now with the basics of list handling defined, we can define some functions on
+lists.  These definitions are practically the same that you would see in any
+version of Lisp.  I got these definitions from section 2.2 of Structure and
+Interpretation of Programs.
+
+#(DS,length,(#(null?,list,count,(#(length,#(cdr,list),#(AD,1,count))))))
+#(SS,length,list,count)'
+
+#(DS,append,(
+  #(null?,list1,list2,(
+    #(cons,#(car,list1),#(append,#(cdr,list1),list2))
+  ))
+))
+#(sss,append,(list1,list2))'
+
+#(DS,map,(
+  #(null?,items,nil,(
+    #(cons,#(proc,#(car,items)),#(map,proc,#(cdr,items)))
+  ))
+))
+#(sss,map,(proc,items))'
+
+#(DS,accumulate,(
+  #(null?,seq,init,(
+    #(op,#(car,seq),#(accumulate,op,init,#(cdr,seq)))
+  ))
+))
+#(sss,accumulate,(op,init,seq))'
+
+#(DS,interval,(
+  #(GR,low,high,nil,(
+    #(cons,low,#(interval,#(AD,1,low),high))
+  ))
+))
+#(sss,interval,(low,high))'
+
+Here's an example use.  Give the decimal expansion of the sum of the first five
+terms of the harmonic series:  1/1, 1/2, 1/3, etc.
+(
+   #(DVD,#(argr,#(accumulate,addr,0,#(map,rcpr,#(interval,1,5))))) => 2.283333333
+)
+
+
+#(PS,(success!
+))'

data/examples/math.trl

@@ -0,0 +1,351 @@
+
+Mathematics
+
+#(PS,Loading examples/math.trl...)'
+
+
+One of the things you have to be careful with TRAC numbers is the fact that any
+string is a number.  If the string doesn't have any numeric characters at the
+end of it, it's considered zero.  That means that abc, --0 and the empty string
+are all equal to zero.  Because of this property, you can't normally use EQ to
+test numbers.
+
+
+Negate
+------
+
+Notice I negate a negative number by multiplying by negative one.  The order in
+the #(ML) command is important to preserve any prefix the number might have.
+
+#(DS,-,(#(ML,n,-1)))
+#(SS,-,n)'
+
+
+Absolute Value
+--------------
+
+Negate if you're less than zero.
+
+#(DS,abs,(#(GR,0,n,#(-,n),n)))
+#(SS,abs,n)'
+
+
+Sign
+----
+
+Determine the sign of the given number.  Returns one, zero or negative one
+depending.  Because these numbers don't have text prefixes, they can be
+compared with EQ.
+
+#(DS,sgn,(
+  #(GR,0,n,-1,(
+    #(GR,n,0,1,0)
+  ))
+))
+#(sss,sgn,n)'
+
+
+Sign Case
+---------
+
+This creates a control statement which executes different code depending on
+what sign the given number is.  This simplifies some of our later code.  
+
+#(DS,sgn?,(
+  #(GR,<a>,0,(P),(
+    #(GR,0,<a>,(N),(Z))
+  ))
+))
+#(sss,sgn?,(<a>,P,Z,N))
+
+We use this as follows:
+(
+    #(sgn?,#(a),positive!,zero.,negative)
+)
+
+
+Numeric Equal
+-------------
+
+The EQ command in TRAC compares strings, not numbers.  To compare numbers you
+need to use the GR command.  If neither of two numbers is greater then they
+must be equal.  It looks really weird to test if a > b and b > a, but because
+of the short-circuit propery of and, it works.  
+
+#(DS,eqn,(
+  #(and,(GR,a,b),(GR,b,a),(F),(T))
+))
+#(sss,eqn,(a,b,T,F))'
+
+
+Modulo
+------
+
+Division in TRAC is floored division, so the modulo always has the same sign
+as the divisor.  The "mod+" script calculates the modulo for positive numbers, 
+while the "mod" script calculates it for all numbers.  If there was a way to
+change the sign of TRAC numbers without using multiplication, then all 
+multiplication could be eliminated here.
+
+The "Z" parameter is returned when "b" is zero.  The "mod+" script does not 
+check for a "b" of zero, so will go into an infinite loop if you give it such
+a "b".
+
+#(DS,mod+,(
+  #(GR,<a>,<b>,(
+    #(mod+,#(SU,<a>,<b>),<b>)
+  ),(
+    #(GR,<b>,<a>,<a>,0)
+  ))
+))
+#(sss,mod+,(<a>,<b>))
+
+Check all the combinations of sign "a" and "b" can have, including an "a" or
+"b" of zero.  If "a" is zero, just return "a", since anything modulo zero is
+zero.  This is consistent with DV so that:
+(
+  #(AD,#(ML,b,#(DV,a,b)),#(mod,a,b))  ==  a
+)
+
+#(DS,mod,(
+  #(sgn?,<a>,(
+    #(sgn?,<b>,(
+      #(mod+,<a>,<b>)
+    ),(
+      Z
+    ),(
+      #(AD,<b>,#(mod+,<a>,#(abs,<b>)))
+    ))
+  ),(
+    <a>
+  ),(
+    #(sgn?,<b>,(
+      #(SU,<b>,#(mod+,#(abs,<a>),<b>))
+    ),(
+      Z
+    ),(
+      #(-,#(mod+,#(abs,<a>),#(abs,<b>),(Z)))
+    ))
+  ))
+))
+#(sss,mod,(<a>,<b>,Z))'
+
+
+Divides
+-------
+
+Test if one number divides another.  The "Z" parameter is returned if "a" is
+zero.
+
+#(DS,div?,(
+  #(eqn,0,<a>,(Z),(
+    #(eqn,0,(#(mod,<b>,<a>)),(T),(F))
+  ))
+))
+#(sss,div?,(<a>,<b>,T,F,Z))'
+
+
+Greatest Common Divisor
+-----------------------
+
+Standard definition of greatest common divisor.  The [gcd] form tests positive
+integers, while the gcd form works for all integers.
+
+#(DS,[gcd],(
+  #(eqn,<b>,0,<a>,(
+    #(gcd,<b>,#(mod,<a>,<b>))
+  ))
+))
+#(sss,[gcd],(<a>,<b>))'
+
+#(DS,gcd,(
+  #(sgn?,#(SU,<a>,<b>),(
+    #([gcd],<a>,<b>)
+  ),(
+    <a>
+  ),(
+    #([gcd],<b>,<a>)
+  ))
+))
+#(sss,gcd,(<a>,<b>))'
+
+
+Ceiling
+-------
+
+TRAC division takes the floor of the division.  But sometimes you need the
+ceiling.  The "Z" parameter is returned if "b" is zero.
+
+#(DS,ceil,(
+  #(div?,<b>,<a>,(
+    #(DV,<a>,<b>)
+  ),(
+    #(AD,1,#(DV,<a>,<b>))
+  ),(
+    Z
+  ))
+))
+#(sss,ceil,(<a>,<b>,Z))'
+
+
+Euclidean Division
+------------------
+
+This division will truncate toward zero, instead of truncating down like normal
+TRAC division does.  The Z parameter is returned if b is zero.
+
+#(DS,DV0,(
+  #(sgn?,<b>,(
+    #(sgn?,<a>,(
+      #(DV,<a>,<b>)
+    ),(
+      <a>
+    ),(
+      #(-,#(DV,#(-,<a>),<b>))
+    ))
+  ),(
+    Z
+  ),(
+    #(sgn?,<a>,(
+      #(-,#(DV,<a>,#(-,<b>)))
+    ),(
+      <a>
+    ),(
+      #(DV,#(-,<a>),#(-,<b>))
+    ))
+  ))
+))
+#(sss,DV0,(<a>,<b>,Z))'
+
+
+Euclidean Modulo
+----------------
+
+Here's a modulo compatible with Euclidean division.  The Z parameter is
+returned if b is zero.
+
+#(DS,mod0,(
+  #(SU,<a>,#(ML,<b>,#(DV0,<a>,<b>,(Z))))
+))
+#(sss,mod0,(<a>,<b>,Z))'
+
+
+Decimal to Octal
+----------------
+Recursively convert a decimal number to octal.  This will go into an infinite
+loop if you try in on negative numbers.  That's because TRAC doesn't have a 
+specific word size, so a negative octal number has an infinite number of 7's
+in front of it.
+
+#(DS,to_oct,(#(eqn,<dec>,0,,(#(to_oct,#(DV,<dec>,8))#(mod,<dec>,8)))))
+#(SS,to_oct,<dec>)'
+
+
+Octal to Decimal
+----------------
+This one is more string-based.  Since I can't do numeric calculations with
+octals, I have to read the octal number as a string, character by character,
+and then interpret each character as a number.
+
+#(DS,to_dec,(
+  #(DS,[octal],<octal>)
+  #(DS,[to_dec],(
+    #(EQ,<digit>,--,
+      (#(DD,[octal],[to_dec])<result>),
+      (#([to_dec],##(CC,[octal],--),#(AD,<digit>,#(ML,8,<result>))))
+    )
+  ))
+  #(SS,[to_dec],<digit>,<result>)
+  #([to_dec],##(CC,[octal],--))
+))
+#(sss,to_dec,<octal>)'
+
+
+Random
+------
+
+Now we can define a random number generator.  This is a linear congruential
+generator from Wikipedia, using the Borland C/C++ multiplier.
+
+    https://en.wikipedia.org/wiki/Linear_congruential_generator
+
+Remember to define the seed value to an octal number before you call random the
+first time.
+
+#(DS,random,(
+  #(DS,seed,
+    #(BS,#(to_oct,
+      #(AD,1,#(ML,22695477,#(to_dec,#(seed))))
+    ),-16)
+  )
+  #(DS,seed,#(BI,#(seed),177777))
+  #(seed)
+))
+#(scrub,random)'
+
+One interesting thing to notice in this definition.  The "seed" is a number,
+not a script.  So I don't use protecting parentheses around its definition
+because I want the definition calculated immediately.  This is different from
+almost every other definition I've written in these files, which is why I 
+mention it.
+
+
+Power
+-----
+
+Recursive definition of raising a number to a given power.  Negative powers
+will return zero.
+
+#(DS,power,(
+  #(GR,0,<n>,0,(
+    #(GR,<n>,0,(
+      #(ML,<base>,#(power,<base>,#(SU,<n>,1)))
+    ),1)
+  ))
+))
+#(scrub,power)
+#(SS,power,<base>,<n>)'
+
+
+Power of Two
+------------
+
+This should be much faster than calling the usual power script.
+
+#(DS,power2,(#(to_dec,1#(times,n,0))))
+#(SS,power2,n)'
+
+
+Power of Ten
+------------
+
+A power of ten is just a one with a bunch of zeros after it.
+
+#(DS,power10,(1#(times,n,0)))
+#(SS,power10,n)'
+
+
+Divide Into Decimal
+-------------------
+
+This gives you a decimal expansion of a division.  By using the Euclidean
+division defined above, it works with both negative and positive numbers.
+
+#(DS,decimal-places,10)'
+
+#(DS,[DVD],(
+  #(GR,<p>,#(decimal-places),,(
+    #(DV,<a>,<b>)
+    #([DVD],#(ML,10,#(mod,<a>,<b>)),<b>,#(AD,<p>,1))
+  ))
+))
+#(sss,[DVD],(<a>,<b>,<p>))'
+
+#(DS,DVD,(
+  #(DV0,<a>,<b>,Z).#([DVD],#(ML,10,#(mod,#(abs,<a>),#(abs,<b>))),#(abs,<b>))
+))
+#(sss,DVD,(<a>,<b>,Z))'
+
+
+#(PS,(success!
+))'