Markus Mottl avatar Markus Mottl committed ce911bc

Fixed typos

Comments (0)

Files changed (1)

 ------------
 
 This OCaml-library consists of a set of modules which implement automatically
-resizing (= reallocating) datastructures that consume a contiguous part
+resizing (= reallocating) data structures that consume a contiguous part
 of memory.  This allows appending and removing of elements to/from arrays
 (both boxed and unboxed), strings (buffers), bit strings and weak arrays
 while still maintaining fast constant-time access to elements.
     strings) is often a prerequisite for short execution times of programs.
 
     Still, operations like adding and/or removing elements to/from the
-    end of such datastructures are often needed.  Unfortunately, having
+    end of such data structures are often needed.  Unfortunately, having
     both properties at the same time sometimes requires reallocating this
     contiguous part of memory.
 
     For example, the programmer might know that a consecutive series of
     operations will alternately add and remove large batches of elements.
     In such a case it would be wise to keep a high reserve of available slots
-    in the datastructure, because otherwise it will resize very often during
+    in the data structure, because otherwise it will resize very often during
     this procedure which requires a significant amount of time.
 
     By raising a corresponding threshold in appropriate places at runtime,
-    programmers can fine-tune the behaviour of e.g. their buffers for optimal
+    programmers can fine-tune the behavior of e.g. their buffers for optimal
     performance and set this parameter back later to save memory.
 
   * Because optimal reallocation strategies may be quite complex,
     it was also a design goal to have users supply their own ones (if
     required).
 
-    By using functors users can parameterize these datastructures with their
-    own reallocation strategies, giving them even more control over how and
-    when reallocations are triggered.
+    By using functors users can parameterize these data structures with
+    their own reallocation strategies, giving them even more control over
+    how and when reallocations are triggered.
 
   * Users may want to add support for additional low-level implementations
     that require reallocations.  In this case, too, it is fairly easy to
     implementation.
 
     All the interfaces of the corresponding low-level implementations of
-    datastructures (e.g. array, string) are fully supported and have been
+    data structures (e.g. array, string) are fully supported and have been
     extended with further functionality.  There is even a new buffer module
     which can be used in every context of the standard one.
 
     :::ocaml
     type 'a array = 'a Array.t
 
-If you create standard arrays with the builtin syntax, change lines like:
+If you create standard arrays with the built-in syntax, change lines like:
 
     :::ocaml
     let ar = [| 1; 2; 3; 4 |] in
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.