fixed some typos (#11012)

Author: badnikhil

etc/c/curl.d

@@ -1994,7 +1994,7 @@ extern (C) CURLcode  curl_easy_getinfo(CURL *curl, CURLINFO info,...);
  * Creates a new curl session handle with the same options set for the handle
  * passed in. Duplicating a handle could only be a matter of cloning data and
  * options, internal state info and things like persistant connections cannot
- * be transfered. It is useful in multithreaded applications when you can run
+ * be transferred. It is useful in multithreaded applications when you can run
  * curl_easy_duphandle() for each new thread to avoid a series of identical
  * curl_easy_setopt() invokes in every thread.
  */

phobos/sys/traits.d

@@ -2652,7 +2652,7 @@ template isEqual(alias lhs)
     static assert(!__traits(compiles, __traits(identifier, arr[0])));
 
     // Similarly, once an enum member from the AliasSeq is assigned to a
-    // variable, __traits(identifer, ...) operates on the variable, not the
+    // variable, __traits(identifier, ...) operates on the variable, not the
     // symbol from the AliasSeq or the value of the variable.
     auto var = uniqueMembers[0];
     static assert(__traits(identifier, var) == "var");

std/algorithm/setops.d

@@ -636,7 +636,7 @@ array of the occurrences and then selecting its top items, and also
 requires less memory (`largestPartialIntersection` builds its
 result directly in `tgt` and requires no extra memory).
 
-If at least one of the ranges is a multiset, then all occurences
+If at least one of the ranges is a multiset, then all occurrences
 of a duplicate element are taken into account. The result is
 equivalent to merging all ranges and picking the most frequent
 `tgt.length` elements.
@@ -714,7 +714,7 @@ import std.algorithm.sorting : SortOutput; // FIXME
 Similar to `largestPartialIntersection`, but associates a weight
 with each distinct element in the intersection.
 
-If at least one of the ranges is a multiset, then all occurences
+If at least one of the ranges is a multiset, then all occurrences
 of a duplicate element are taken into account. The result
 is equivalent to merging all input ranges and picking the highest
 `tgt.length`, weight-based ranking elements.
@@ -1063,7 +1063,7 @@ ranges must have a common type.
 
 
 In the case of multisets, considering that element `a` appears `x`
-times in `r1` and `y` times and `r2`, the number of occurences
+times in `r1` and `y` times and `r2`, the number of occurrences
 of `a` in the resulting range is going to be `x-y` if x > y or 0 otherwise.
 
 Params:
@@ -1188,8 +1188,8 @@ $(REF_ALTTEXT input ranges, isInputRange, std,range,primitives)
 types of the ranges must have a common type.
 
 In the case of multisets, the range with the minimum number of
-occurences of a given element, propagates the number of
-occurences of this element to the resulting range.
+occurrences of a given element, propagates the number of
+occurrences of this element to the resulting range.
 
 Params:
     less = Predicate the given ranges are sorted by.
@@ -1359,9 +1359,9 @@ ranges must have a common type.
 
 If both ranges are sets (without duplicated elements), the resulting
 range is going to be a set. If at least one of the ranges is a multiset,
-the number of occurences of an element `x` in the resulting range is `abs(a-b)`
-where `a` is the number of occurences of `x` in `r1`, `b` is the number of
-occurences of `x` in `r2`, and `abs` is the absolute value.
+the number of occurrences of an element `x` in the resulting range is `abs(a-b)`
+where `a` is the number of occurrences of `x` in `r1`, `b` is the number of
+occurrences of `x` in `r2`, and `abs` is the absolute value.
 
 If both arguments are ranges of L-values of the same type then
 `SetSymmetricDifference` will also be a range of L-values of

std/container/dlist.d

@@ -719,7 +719,7 @@ Complexity: $(BIGOH r.walkLength)
     alias stableLinearRemove = linearRemove;
 
 /**
-Removes the first occurence of an element from the list in linear time.
+Removes the first occurrence of an element from the list in linear time.
 
 Returns: True if the element existed and was successfully removed, false otherwise.
 

std/container/slist.d

@@ -628,7 +628,7 @@ Complexity: $(BIGOH n)
     alias stableLinearRemove = linearRemove;
 
 /**
-Removes the first occurence of an element from the list in linear time.
+Removes the first occurrence of an element from the list in linear time.
 
 Returns: True if the element existed and was successfully removed, false otherwise.
 

std/exception.d

@@ -1059,12 +1059,12 @@ false negatives:
 
 `doesPointTo` will return `true` if it is absolutely certain
 `source` points to `target`. It may produce false negatives, but never
-false positives. This function should be prefered when trying to validate
+false positives. This function should be preferred when trying to validate
 input data.
 
 `mayPointTo` will return `false` if it is absolutely certain
 `source` does not point to `target`. It may produce false positives, but never
-false negatives. This function should be prefered for defensively choosing a
+false negatives. This function should be preferred for defensively choosing a
 code path.
 
 Note: Evaluating $(D doesPointTo(x, x)) checks whether `x` has
@@ -1956,7 +1956,7 @@ Params:
     `Throwable` of type `E`. The handler must accept arguments of
     the form $(D E, ref IRange) and its return value is used as the primitive's
     return value whenever `E` is thrown. For `opIndex`, the handler can
-    optionally recieve a third argument; the index that caused the exception.
+    optionally receive a third argument; the index that caused the exception.
     input = The range to _handle.
 
 Returns: A wrapper `struct` that preserves the range interface of `input`.

std/file.d

@@ -2973,7 +2973,7 @@ Params:
 
 Throws:
     $(LREF FileException) on POSIX or $(LREF WindowsException) on Windows
-    if an error occured.
+    if an error occurred.
  */
 void mkdir(R)(R pathname)
 if (isSomeFiniteCharInputRange!R && !isConvertibleToString!R)

std/range/primitives.d

@@ -400,7 +400,7 @@ $(BOOKTABLE ,
 
 Tip: `put` should $(I not) be used "UFCS-style", e.g. `r.put(e)`.
 Doing this may call `R.put` directly, by-passing any transformation
-feature provided by `Range.put`. $(D put(r, e)) is prefered.
+feature provided by `Range.put`. $(D put(r, e)) is preferred.
  +/
 void put(R, E)(ref R r, E e)
 {

std/regex/internal/parser.d

@@ -179,7 +179,7 @@ struct CodeGen
     uint counterDepth = 0;         // current depth of nested counted repetitions
     CodepointSet[] charsets;       // sets for char classes
     const(CharMatcher)[] matchers; // matchers for char classes
-    uint[] backrefed;              // bitarray for groups refered by backref
+    uint[] backrefed;              // bitarray for groups referred by backref
     uint ngroup;                   // final number of groups (of all patterns)
 
     void start(uint length)

std/regex/internal/thompson.d

@@ -1055,7 +1055,7 @@ final:
     }
 
     /+
-        handle succesful threads
+        handle successful threads
     +/
     void finish(const(Thread!DataIndex)* t, Group!DataIndex[] matches, int code)
     {