(1) Renamed the functions for encoding Very-Long Integer byte strings in the "Dao.String" and "Dao.Binary" modules so the names would not conflict.
(2) Had to modify the 'Dao.Binary.PrefixTable" data type and related instantiations and functions in order to make it work correctly. Prior to these changes, using 'Data.Monoid.mconcat' would create a 'Dao.Binary.PrefixTable' that would always backtrack when evaluated with 'Dao.Binary.runPrefixTable'. The reason was, 'Data.Monoid.mconcat' always uses 'Data.Monoid.mempty' as the final element, and the instantiation of 'Dao.Binary.PrefixTable' into the 'Data.Monoid.mappend' class was programmed to always use the prefix parser of the second parameter, which was an 'Control.Monad.mzero' parser if the 'Dao.Binary.PrefixTable' was constructed with 'Data.Monoid.mempty'. Now, the prefix parser stored in a 'Dao.Binary.PrefixTable' is wrapped in a 'Data.Maybe.Maybe' data type, and the instantiation of 'Data.Monoid.mappend' will use which ever parser is not 'Data.Maybe.Nothing'. If both are 'Data.Maybe.Nothing', 'runPrefixTable' can still infer the 'Dao.Binary.Get' function to use from the data type of the prefix. It may be a good idea to simply never store any reference to the prefix parser in the 'Dao.Binary.PrefixTable' data type and always infer the prefix parser from the type.
(3) Worked out a few more bugs in the binary protocol. This includes prefixing every list element when encoding a list in the event that the list contains 'Prelude.Integer's or 'Dao.String.UStr's which have no prefix and could be encoded as a single null (0x00) byte which would be confused with the lists null terminator. I have provided a new API 'Dao.Binary.putUnwrapped' and 'Dao.Binary.getUnwrapped' to allow for encoding/decoding lists where every element is known to have a non-null prefix.
Corrected a simple mistake in the test error reporting: it was outputting the pretty-printed randomly generated data structure twice. What it should have done, what it does now, is pretty-print the data structure using 'Dao.PPrint.prettyShow' and once with 'Prelude.Show'.
Instantiated 'Dao.Object.T_type' into the 'Dao.Random.HasRandGen' class.
The Makefile is a bit of a hack in that it does not actually do anything to check the dependencies of the targets, it only checks if there are any files with a ".hs" extension that are newer than the Makefile itself, and then passes these files to "ghc --make". I had to modify it to only search for files with a ".hs" extension that start with a capital letter because it was selecting various test programs I had written and passing them to "ghc --make" along with the "src/dao-main.hs" file.  This was confusing GHC because the test program was a "Main" module program and "src/dao-main.hs" is also a "Main" module program, and GHC cannot compile two modules of the same name. By searching for only files starting with a capital letter, only non-"Main" module program files are selected because these file names must match the module name which must always start with a capital letter.
Commented-out of some functions that are no longer used because of the recent changes to the 'Dao.Runtime.Runtime' data types.
Corrected a bug in the instantiation of 'delLocation' for 'Dao.Object.IfElseExpr', 'Dao.Object.ElseExpr', 'Dao.Object.AST.AST_If', and 'Dao.Object.AST_Else'.
Fixed a few bugs in the random syntax tree generator. I modified 'Dao.Random.randListOf' so that it no longer increments the recursion depth. This is because if the function receives a value greater than 1 for it's first parameter it is expected to generate a non-empty list, but the recursive depth limit was returning an empty list if the depth limit had been exceeded. This made a few of the functions that I had written behave unexpectedly because I wrote them with the assumption that the 'Dao.Random.randListOf' function always return a non-null list. The random syntax tree generator is still generating syntax trees that are impossible to parse from their pretty-printed form, it will need some more tweaking.
I perhaps ought to use the "Data.Generic" modules to program the various instances of 'Dao.Token.delLocation' because I have found several data types where I had made mistakes in the instantiation due to the tedium of writing such generic instances. Anyway, for now most of these instances have been corrected.
Fixed a few more bugs in the pretty-printer and parser. The changes made to the parser are mostly removing keywords which are no longer keywords, but were still being tokenized as keywords.  Expressions like "list{}" and "data{}" will now be evaluated by the the 'Dao.Object.InitExpr' data structure which will call an evaluator selected by the 'Dao.String.Name' value "list" or "data".
I have created a new test program, "Dao.SingleTest" that works similar to "Dao.Test" but can evaluate any test ID specified as arguments on the command line. "Dao.Test" lets you execute test IDs specified on the command line as well, but the test execution is pretty complicated and inflexible. I can make changes to "Dao.SingleTest" very easily. It is programmed mostly using the "Dao.Prelude" APIs and is much easier to modify than "Dao.Test", it is much more flexible and can be adapted to most any kind of debugging situation that has come up so far. It has made debugging much easier for me.
Removed the last of the references to the old debugger.