doc: Extend README

acl/prefix.lisp

@@ -14,7 +14,7 @@
 (defmacro define-prefixes (&body body)
   "Defines a series of prefixes by reading the list as a plist.
 
-The car is assumed to be a keyward and the cadr is assumed to be the expanded string."
+The car is assumed to be a keyword and the cadr is assumed to be the expanded string."
   `(progn ,@(loop for (prefix expansion) on body
                   by #'cddr
                   collect `(define-prefix ,prefix ,expansion))))

cache/types.lisp

@@ -242,7 +242,7 @@ COMPLETE-P is to be understood as by DERIVE-TYPE-FROM-PREFIX-FUNCTION."
                    else
                      do
                         (push (cons uri graph) missing-uri-graph-combinations)))
-    ;; now find which uri graph combitations are missing
+    ;; now find which uri graph combinations are missing
     ;; query all missing uri graph combinations
     (let* ((grouped-by-uri (support:group-by missing-uri-graph-combinations #'string= :key #'car))
            (uri-graphs-combinations (loop for ((uri . graph) . rest) in grouped-by-uri

connection/client.lisp

@@ -13,12 +13,13 @@
 (defparameter *max-concurrent-connections* 8
   "The maximum amount of concurrent queries sent to a sparql endpoint.")
 
-(defparameter *log-sparql-query-roundtrip* nil)
+(defparameter *log-sparql-query-roundtrip* nil
+  "When set to non-nil, we log both the outgoing query sent to and response received from the sparql endpoint.")
 
-(defparameter *aquire-db-semaphore-timeout* 55
-  "Amount of time (in seconds) to wait to aquire the semaphore (default is now 55).
+(defparameter *acquire-db-semaphore-timeout* 55
+  "Amount of time (in seconds) to wait to acquire the semaphore (default is now 55).
 
-NIL symolizes to wait forever.")
+NIL symbolizes to wait forever.")
 
 ;; Overriding the default values here for now.  Ideally these get calculated based on how much time we have left.
 (setf dexador.util:*default-connect-timeout* 60)
@@ -144,7 +145,7 @@ When the VERBOSE keyword is truethy, output is written to STDOUT."
 (defun query (string &key (send-to-single nil))
   "Sends a query to the backend and responds with the response body.
 
-When SEND-TO-SINGLE is truethy and multple endpoints are available, the request is sent to only one of them."
+When SEND-TO-SINGLE is truethy and multiple endpoints are available, the request is sent to only one of them."
   (ensure-backends-variable)
   (let* ((selected-endpoints
            (if send-to-single
@@ -157,7 +158,7 @@ When SEND-TO-SINGLE is truethy and multple endpoints are available, the request
     ;; - a single failing endpoint will bring the whole setup down in this implementation
     ;; - the implementation does not fire off the queries in parallel, we may want a thread per semaphore for that
     ;; - a full-fledged and parallel implementation likely means rewriting this whole logic and the construction of the sparql-endpoint struct
-    (support:with-multiple-semaphores ((mapcar #'sparql-endpoint-semaphore selected-endpoints) :timeout *aquire-db-semaphore-timeout*)
+    (support:with-multiple-semaphores ((mapcar #'sparql-endpoint-semaphore selected-endpoints) :timeout *acquire-db-semaphore-timeout*)
       (let ((post-handler (lambda () nil))) ; overwritten with handler on error
         (unwind-protect
              (support:with-exponential-backoff-retry

packages.lisp

@@ -380,7 +380,7 @@
                 #:operation-data-subfield
                 #:operation-type
                 #:operation-data)
-  (:import-from #:sparql-parser 
+  (:import-from #:sparql-parser
                 #:make-match
                 #:terminal-match-string)
   (:import-from #:sparql-manipulation

reasoner/take-1/prefixes.lisp

@@ -3,7 +3,7 @@
 ;;;; Prefixes extraction
 ;;;;
 ;;;; Many URIs are expressed using prefixes.  This module extracts
-;;;; perfixes from a query and provides a cache-based variant to use
+;;;; prefixes from a query and provides a cache-based variant to use
 ;;;; them.
 ;;;;
 ;;;; This module is not thread-safe and assumes prefixes are constructed

sparql-ast/terminals.lisp

@@ -8,7 +8,7 @@
 ;;;; this library was optimized to understand whether a Lisp based
 ;;;; variant would be sufficiently fast in the interpretation of the
 ;;;; queries or whether it would be too slow.  for this many parsers
-;;;; have to approaches available: a regular expression and hand-rolled
+;;;; have two approaches available: a regular expression and hand-rolled
 ;;;; interpretation.  further optimizations seem possible but the
 ;;;; approach here has shown sufficient promise to verify the desired
 ;;;; performance.
@@ -935,7 +935,7 @@ failure."
 (defmacro with-internal-runtime-processing ((var &optional (activep t)) (&rest operations) &body body)
   "Run code and do something with the time it took after processing.
 
-  The consumed time willb e stored in VAR.
+  The consumed time will be stored in VAR.
   The timed operations are BODY.
   The cleanup processing are OPERATIONS."
   (if activep

updates/quad-operations-to-quads.lisp

@@ -148,7 +148,7 @@ variables are missing this will not lead to a pattern."
                                 (ebnf::|ValuesClause|))))))))
 
 (defun quads-for-construct-bindings (bindings)
-  "Ceates a series of quads fo the constructed bindings."
+  "Creates a series of quads fo the constructed bindings."
   (loop for binding in bindings
         for subject = (jsown:val binding "s")
         for predicate = (jsown:val binding "p")