Spilling misteaks and gradma changes in doco

Author: bbakerman

README.md

@@ -204,15 +204,15 @@ For example, let's assume you want to load users from a database, you could prob
 ```
 
  Given say 10 user id keys you might only get 7 results back.  This can be more naturally represented in a map
- than in an order list of values when returning values from the batch loader function.
+ than in an ordered list of values from the batch loader function.
 
  You can use `org.dataloader.MappedBatchLoader` for this purpose. 
 
  When the map is processed by the `DataLoader` code, any keys that are missing in the map
- will be replaced with null values.  The semantics that the number of `DataLoader.load` requests
- are matched with values is kept.
+ will be replaced with null values.  The semantic that the number of `DataLoader.load` requests
+ are matched with an equal number of values is kept.
 
- Your keys provided MUST be first class keys since they will be used to examine the returned map and
+ The keys provided MUST be first class keys since they will be used to examine the returned map and
  create the list of results, with nulls filling in for missing values.
 
 ```java

src/main/java/org/dataloader/BatchLoaderEnvironment.java

@@ -2,7 +2,7 @@
 
 /**
  * This object is passed to a batch loader as calling context.  It could contain security credentials
- * of the calling users say or database connection parameters that allow the data layer call to succeed.
+ * of the calling users for example or database parameters that allow the data layer call to succeed.
  */
 public class BatchLoaderEnvironment {
 

src/main/java/org/dataloader/BatchLoaderWithContext.java

@@ -15,7 +15,7 @@ public interface BatchLoaderWithContext<K, V> {
     /**
      * Called to batch load the provided keys and return a promise to a list of values.  This default
      * version can be given an environment object to that maybe be useful during the call.  A typical use case
-     * is passing in security credentials or database connection details say.
+     * is passing in security credentials or database details for example.
      *
      * @param keys        the collection of keys to load
      * @param environment an environment object that can help with the call

src/main/java/org/dataloader/DataLoader.java

@@ -57,7 +57,7 @@
  */
 public class DataLoader<K, V> {
 
-    private final DataLoaderHelper<K,V> helper;
+    private final DataLoaderHelper<K, V> helper;
     private final DataLoaderOptions loaderOptions;
     private final CacheMap<Object, CompletableFuture<V>> futureCache;
     private final List<SimpleImmutableEntry<K, CompletableFuture<V>>> loaderQueue;
@@ -96,10 +96,12 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadF
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
      *
-     * This allows you to capture both the value that might be returned and also whether exception that might have occurred getting that individual value.  If its important you to
-     * know the exact status of each item in a batch call and whether it threw exceptions when fetched then
+     * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
      *
+     * Using Try objects allows you to capture a value returned or an exception that might
+     * have occurred trying to get a value. .
+     *
      * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
      * @param <K>               the key type
      * @param <V>               the value type
@@ -162,10 +164,12 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V>
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
      *
-     * This allows you to capture both the value that might be returned and also whether exception that might have occurred getting that individual value.  If its important you to
-     * know the exact status of each item in a batch call and whether it threw exceptions when fetched then
+     * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
      *
+     * Using Try objects allows you to capture a value returned or an exception that might
+     * have occurred trying to get a value. .
+     *
      * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
      * @param <K>               the key type
      * @param <V>               the value type
@@ -227,10 +231,12 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
      *
-     * This allows you to capture both the value that might be returned and also whether exception that might have occurred getting that individual value.  If its important you to
-     * know the exact status of each item in a batch call and whether it threw exceptions when fetched then
+     * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
      *
+     * Using Try objects allows you to capture a value returned or an exception that might
+     * have occurred trying to get a value. .
+     *
      * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
      * @param <K>               the key type
      * @param <V>               the value type
@@ -293,10 +299,12 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithC
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
      *
-     * This allows you to capture both the value that might be returned and also whether exception that might have occurred getting that individual value.  If its important you to
-     * know the exact status of each item in a batch call and whether it threw exceptions when fetched then
+     * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
      *
+     * Using Try objects allows you to capture a value returned or an exception that might
+     * have occurred trying to get a value. .
+     *
      * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
      * @param <K>               the key type
      * @param <V>               the value type
@@ -352,7 +360,7 @@ private DataLoader(Object batchLoadFunction, DataLoaderOptions options) {
         this.loaderQueue = new ArrayList<>();
         this.stats = nonNull(this.loaderOptions.getStatisticsCollector());
 
-        this.helper = new DataLoaderHelper<>(this, batchLoadFunction,this.loaderOptions, futureCache, loaderQueue, stats);
+        this.helper = new DataLoaderHelper<>(this, batchLoadFunction, this.loaderOptions, futureCache, loaderQueue, stats);
     }
 
     @SuppressWarnings("unchecked")

src/main/java/org/dataloader/MappedBatchLoader.java

@@ -42,16 +42,16 @@
  * </pre>
  *
  * Given say 10 user id keys you might only get 7 results back.  This can be more naturally represented in a map
- * than in an order list of values when returning values from the batch loader function.
+ * than in an ordered list of values from the batch loader function.
  *
  * When the map is processed by the {@link org.dataloader.DataLoader} code, any keys that are missing in the map
- * will be replaced with null values.  The semantics that the number of {@link org.dataloader.DataLoader#load(Object)} requests
- * are matched with values is kept.
+ * will be replaced with null values.  The semantic that the number of {@link org.dataloader.DataLoader#load(Object)} requests
+ * are matched with and equal number of values is kept.
  *
- * This means that if 10 keys are asked for then {@link DataLoader#dispatch()} will return a promise 10 value results and each
+ * This means that if 10 keys are asked for then {@link DataLoader#dispatch()} will return a promise of 10 value results and each
  * of the {@link org.dataloader.DataLoader#load(Object)} will complete with a value, null or an exception.
  *
- * When caching is disabled, its possible for the same key to be presented in the list of keys more than once.  You map
+ * When caching is disabled, its possible for the same key to be presented in the list of keys more than once.  Your map
  * batch loader function needs to be resilient to this situation.
  *
  * @param <K> type parameter indicating the type of keys to use for data load requests.

src/main/java/org/dataloader/MappedBatchLoaderWithContext.java

@@ -22,8 +22,8 @@
 
 /**
  * This form of {@link MappedBatchLoader} is given a {@link org.dataloader.BatchLoaderEnvironment} object
- * that encapsulates the calling context.  A typical use case is passing in security credentials or database connection details
- * say.
+ * that encapsulates the calling context.  A typical use case is passing in security credentials or database details
+ * for example.
  *
  * See {@link MappedBatchLoader} for more details on the design invariants that you must implement in order to
  * use this interface.