more minor typos

Author: rurban

README.md

@@ -201,7 +201,7 @@ would be 64 bits on a 64-bit machine. In Rune, only the string references are
 cache** during the traversal, improving memory load times, while simultaneously
 improving cache hit rates.
 
-This is why Rune's `binarytree.rn` code already runs faster than any other
+This is why Rune's `binary_trees.rn` code already runs faster than any other
 single-threaded result in the [Benchmark
 Games](https://benchmarksgame-team.pages.debian.net/benchmarksgame/index.html).
 (Rune is not yet multi-threaded). The only close competitor is C++, where the

TODO

@@ -1,13 +1,13 @@
 ## Short term
 Use concrete type constraints on variable assignments rather than "if false" type hints.
-In the bootstrap version of Rune, add support for autocasting return expresions
+In the bootstrap version of Rune, add support for autocasting return expressions
     to the type of other return expressions
 Add an option for generating SoA vs AoS memory layout so folks can do their own benchmarking.
 Write a C or C++ backend code generator for improved debugging of Rune, and so folks can benchmark with
     full front-end optimization of different C compilers for benchmarking.
 Enhance gdb pretty printer so that we don't have to generate show methods.
 Figure out when relationship transformers should run.  Right now it is in the order statements are bound so that module-level variables can be passed into the transformers, but we assume all transformers are run before binding a constructor, which is currently false.  Figure out the right thing and do it.
-Use concrete type constraints in binding.  This can help eleminate problems
+Use concrete type constraints in binding.  This can help eliminate problems
     in binding recursive functions, and also non-template classes.
 Don't allow generated fields to be written outside of generated code.
 Add an Object class that matches all types, so we can have case (Object, Object, Object).
@@ -18,25 +18,25 @@ Flesh out index overloading: write is not yet supported.
 Support Overloading method get/set methods.
 Improve safe mode:
     Throw error when destroying an object that has a reference on the stack.
-    Use overflow/underflow intrinsics in LLVM
+    Use overflow/underflow intrinsics in LLVM.
 Fix LLVM select for case when select bit is secret.
     Also, only evaluate one or the other when select is not secret.
 Add syntax for declaring volatile globals at specified addresses, so we can do memory-mapped I/O.  Consider using a global io array.
 Add good support for interop with C++, which is a key requirement for a language to replace C++ in prod:
     syntax for declaring extern "C++" functions, and deal with name mangling.
     Add support for calling C++ constructors and methods.
     Add support for c++ unique pointers, which are often returned.
-Add support for C pointer types, which can be returned by C functions declared extern"C".
+Add support for C pointer types, which can be returned by C functions declared extern "C".
 Add "unsafe" blocks where it is legal to dereference or index into a C pointer.
 Write all the Benchmark Games benchmarks twice: one single threaded and
-    honest, one multi-threaded and using similar trickes used by the others to win.
+    honest, one multi-threaded and using similar tricks used by the others to win.
 Implement dynamic class extensions.
 Implement inheritance via composition, using exclusive relationships.
 Return error codes for each deError call, which error tests can expect.
 Write initial language reference manual.
 Add LLVM compiler hints and optmizations as described at
     https://llvm.org/docs/Frontend/PerformanceTips.html#adding-to-this-document.
-Support named parameters, like Python
+Support named parameters, like Python.
 
 ## Medium Term
 Write tests to verify that constant time processing of secrets is achieved.  E.g. if (issecret(foo)...
@@ -50,7 +50,7 @@ Support full co-routines in iterators in the LLVM backend.
 Support tuple unpacking.
 Support overloading modular operations, so we can support modular polynomials, etc.
 Add multi-threading support.
-Add schema-level reuse statements
+Add schema-level reuse statements.
 Write a schema generator for Rune similar to the dataview program for DataDraw schemas.
 Flush out transformers's Rune code interpreter.
 Finish transition to memory pools, and allocation of global arrays with mmap of the memory available on the machine so large arrays never move.
@@ -65,9 +65,9 @@ Tune floating point operations: For some reason, clang is running C/C++ floating
 Rewrite heap to be more efficient for small passed-by-value objects like i32's.  The back-pointer and
   index are not needed for heaps of values.
 Save memory on 32-bit targets using 32-bit lengths.
-LLVM: generate switch rather than a chain of br.
+LLVM: generate switch rather than a chain of branches.
 Support tail recursion.
 Use existing uint32 or int32 field for nextFree to save memory for non-ref-counted classes.
 Identify fields that are always accessed together and merge them into tuples.
-  Generate array-of-structures for these tuples
+  Generate array-of-structures for these tuples.
 Support unions, like DataDraw, where the field is selected by an enumerated type.

benchmarks/results.md

@@ -1,9 +1,9 @@
 # Heap queues
 The C++ std::priority_queue is currently ~3X faster at sorting integers.
-However, this is basically useless as heapsort is very slow compared to mergsort
+However, this is basically useless as heapsort is very slow compared to mergesort
 or qsort.  A more interesting case is a heapq of objects.  Rune was the same
-speed once C++ had in-place objects containging a std::string and a uint32_t
-cost.  Objects with more fields are slower in C++, and should in stead be
+speed once C++ had in-place objects containing a std::string and a uint32_t
+cost.  Objects with more fields are slower in C++, and should instead be
 inserted as unique pointers.
 
 In C++, std::priority_queue does not yet support unique pointers, so I was not

bind/bindexpr.c

@@ -1561,7 +1561,7 @@ static bool bindDotExpression(deBlock scopeBlock, deExpression expression) {
     if (deDatatypeNullable(datatype)) {
       deString string = deMutableStringCreate();
       deDumpExpressionStr(string, expression);
-      deExprError(expression, "Cannot use  dot operator on nullable type: %s.",
+      deExprError(expression, "Cannot use dot operator on nullable type: %s.",
           deStringGetCstr(string));
     }
     classBlock = deClassGetSubBlock(deDatatypeGetClass(datatype));

bootstrap/database/block.rn

@@ -20,7 +20,7 @@ use function
 use location
 use statement
 
-// A liternal block statement.  All statements exist within a block.
+// A literal block statement.  All statements exist within a block.
 class Block(self, location: Location) {
   self.location = location
   // For dead code analysis.

bootstrap/database/expr.rn

@@ -117,7 +117,7 @@ enum ExprType {
   Namedparam  // Myclass(name = "me", profession = "hacker")
 }
 
-// Return the operator precedence.  This is similar to C, but fixes an acknowledge mistake:
+// Return the operator precedence.  This is similar to C, but fixes an acknowledged mistake:
 // bitwise operators should bind more tightly than relational operators.  By the time C's
 // authors realized this mistake, there was already too much C code that would break to fix it.
 // Example: "value & 1 == 0" should test that value is even, but in C the result is always 0.

builtin/hashed.rn

@@ -52,7 +52,7 @@ func hashInteger(value: Uint | Int) -> u64 {
 }
 
 func hashValue(value) -> u64 {
-  // Only one of these cases will be instatiated per func instantiation.
+  // Only one of these cases will be instantiated per func instantiation.
   typeswitch value {
     String => return hashString(value)
     Uint, Int => return hashInteger(value)

builtin/hashedclass.rn

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 // This is a one-to-many relation transformer that adds a hash table between
-// class A and B.  The hash table is always a power of 2, and dynamically grows
+// class A and B.  The hash table size is always a power of 2, and dynamically grows
 // as needed, when the number of hash table elements equals the size of the
 // table.  The child class B must have two methods: hash() -> u64, and
 // equals(other) which compares the two instances of class B and returns true

include/de.h

@@ -124,7 +124,7 @@ static inline uint32 deBlockFindVariableIndex(deBlock block,
     i++;
   }
   deEndBlockVariable;
-  utExit("Varaible not found on block");
+  utExit("Variable not found on block");
   return 0;  // Dummy return.
 }
 
@@ -263,7 +263,7 @@ static inline deExpression deExpresssionIndexExpression(deExpression expression,
     }
     i++;
   } deEndExpressionExpression;
-  utExit("Indexed past end of expression list");
+  utExit("Index past end of expression list");
   return deExpressionNull;
 }