From c94dae01c4fe5e86761b8532f7656cfc37a28905 Mon Sep 17 00:00:00 2001 From: Brian Wignall Date: Wed, 20 Nov 2019 10:38:19 -0500 Subject: [PATCH] Fix easy-to-make typos --- NEWS | 2 +- doc/haskell-mode.texi | 6 +++--- haskell-cabal.el | 2 +- haskell-completions.el | 4 ++-- haskell-indentation.el | 2 +- haskell-interactive-mode.el | 4 ++-- haskell-process.el | 2 +- haskell-string.el | 2 +- haskell-utils.el | 6 +++--- 9 files changed, 15 insertions(+), 15 deletions(-) diff --git a/NEWS b/NEWS index e4d1a9940..fbc621f3d 100644 --- a/NEWS +++ b/NEWS @@ -42,7 +42,7 @@ This file uses Org mode. Some useful (default) key-bindings: - Added support for full complexity of backtick syntax -- Operators at the end or beggining of line force expression continuation in indentation +- Operators at the end or beginning of line force expression continuation in indentation - Map haskell-mode-format-imports to C-c C-, to avoid conflict with haskell-indent diff --git a/doc/haskell-mode.texi b/doc/haskell-mode.texi index 0de03958a..e59719abd 100644 --- a/doc/haskell-mode.texi +++ b/doc/haskell-mode.texi @@ -434,7 +434,7 @@ completion candidates from completion-at-point function (@code{company-capf} backend) and dynamic abbrevs. @code{company-mode} provides special backend for dabbrev code completions, namely @code{company-dabbrev-code}. To combine -completions from diffrent backends you can create grouped backends, it +completions from different backends you can create grouped backends, it is very easy — a grouped backend is just a list of backends, for example: @@ -1246,7 +1246,7 @@ Separate sessions per Cabal project @file{haskell-session.el}. @item A new inferior Haskell process handling code @file{haskell-process.el}. @item -New REPL implementation similiar to SLIME/IELM +New REPL implementation similar to SLIME/IELM @item Navigatable error overlays @file{haskell-interactive-mode.el}. @@ -2172,7 +2172,7 @@ The most common Cabal action is building, so that has a specific command: M-x haskell-process-cabal-build @end example -Or @kbd{C-c C-c}. When building, it will hide unneccessary output. +Or @kbd{C-c C-c}. When building, it will hide unnecessary output. For example, to build the `ace` package, the output is simply: diff --git a/haskell-cabal.el b/haskell-cabal.el index c6a718b9e..dda15f1ee 100644 --- a/haskell-cabal.el +++ b/haskell-cabal.el @@ -924,7 +924,7 @@ resulting buffer-content. Unmark line at the end." (defun haskell-cabal-line-filename () "Expand filename in current line according to the subsection type -Module names in exposed-modules and other-modules are expanded by replacing each dot (.) in the module name with a foward slash (/) and appending \".hs\" +Module names in exposed-modules and other-modules are expanded by replacing each dot (.) in the module name with a forward slash (/) and appending \".hs\" Example: Foo.Bar.Quux ==> Foo/Bar/Quux.hs diff --git a/haskell-completions.el b/haskell-completions.el index 59d2e2413..251218869 100644 --- a/haskell-completions.el +++ b/haskell-completions.el @@ -132,7 +132,7 @@ in this list.") (defun haskell-completions-can-grab-prefix () "Check if the case is appropriate for grabbing completion prefix. Returns t if point is either at whitespace character, or at -punctuation, or at line end and preceeding character is not a +punctuation, or at line end and preceding character is not a whitespace or new line, otherwise returns nil. Returns nil in presence of active region." @@ -253,7 +253,7 @@ identifier at point depending on result of function t) ;; but uppercase ident could occur after `as` keyword, or in ;; module imports after opening parenthesis, in this case - ;; restore identifier type again, it's neccessary to + ;; restore identifier type again, it's necessary to ;; distinguish the means of completions retrieval (setq type 'haskell-completions-identifier-prefix)))))) (when (nth 8 (syntax-ppss)) diff --git a/haskell-indentation.el b/haskell-indentation.el index 0ab735ff2..8fb034ec9 100644 --- a/haskell-indentation.el +++ b/haskell-indentation.el @@ -372,7 +372,7 @@ and indent when all of the following are true: ;; When the scope of this function ends, the variable is automatically ;; reverted to its old value. -;; This is basicly a performance hack. It would have been possible to +;; This is basically a performance hack. It would have been possible to ;; thread this state using a association-list through the parsers, but it ;; would be probably more complicated and slower due to the lack of real ;; closures in Emacs Lisp. diff --git a/haskell-interactive-mode.el b/haskell-interactive-mode.el index fc0212d57..9edfdffa9 100644 --- a/haskell-interactive-mode.el +++ b/haskell-interactive-mode.el @@ -48,7 +48,7 @@ "Mark used for the old beginning of the prompt.") (defun haskell-interactive-prompt-regex () - "Generate a regex for searching for any occurence of the prompt\ + "Generate a regex for searching for any occurrence of the prompt\ at the beginning of the line. This should prevent any interference with prompts that look like haskell expressions." (concat "^" (regexp-quote haskell-interactive-prompt))) @@ -104,7 +104,7 @@ Key bindings: (defvar haskell-interactive-mode-result-end nil "Mark used to figure out where the end of the current result output is. -Used to distinguish betwen user input.") +Used to distinguish between user input.") (defvar-local haskell-interactive-previous-buffer nil "Records the buffer to which `haskell-interactive-switch-back' should jump. diff --git a/haskell-process.el b/haskell-process.el index 6e922c61c..e5db3bd1d 100644 --- a/haskell-process.el +++ b/haskell-process.el @@ -324,7 +324,7 @@ Returns NIL when no completions found." (let ((cnt1 (match-string 1 h0)) (h1 (haskell-string-literal-decode (match-string 3 h0)))) (unless (= (string-to-number cnt1) (length cs)) - (error "Lengths inconsistent in `:complete' reponse")) + (error "Lengths inconsistent in `:complete' response")) (cons h1 cs))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/haskell-string.el b/haskell-string.el index 354956e89..7fb2bc473 100644 --- a/haskell-string.el +++ b/haskell-string.el @@ -172,7 +172,7 @@ See also `haskell-string-take'." str) (defun haskell-string-split-to-lines (str) - "Split STR to lines and return a list of strings with preceeding and + "Split STR to lines and return a list of strings with preceding and succeding space removed." (when (stringp str) (cl-mapcar #'haskell-string-chomp (split-string str "\n")))) diff --git a/haskell-utils.el b/haskell-utils.el index 1126a2614..1f1620e2b 100644 --- a/haskell-utils.el +++ b/haskell-utils.el @@ -97,7 +97,7 @@ buffer, point was not moved, etc. To collect data `post-command-hook' is used." "Clean up after async operation finished. This function takes care about cleaning up things made by `haskell-utils-async-watch-changes'. The BUFFER argument is a buffer where -`post-command-hook' should be disabled. This is neccessary, because +`post-command-hook' should be disabled. This is necessary, because it is possible that user will change buffer during async function execusion." (with-current-buffer buffer @@ -145,7 +145,7 @@ Returns one of the following symbols: ((string-match-p "^:" first-line) 'interactive-error) (t 'no-error))) - ;; in case of nil-ish reponse it's not clear is it error response or not + ;; in case of nil-ish response it's not clear is it error response or not 'no-error)) (defun haskell-utils-compose-type-at-command (pos) @@ -167,7 +167,7 @@ expression bounds." (setq end-l (line-number-at-pos)) (setq end-c (1+ (current-column))) (setq value (buffer-substring-no-properties start-p end-p)) - ;; supress multiline expressions + ;; suppress multiline expressions (let ((lines (split-string value "\n" t))) (when (and (cdr lines) (stringp (car lines)))