Merge pull request #2511 from n8sh/apostrophe-plural

Don't pluralize with apostrophe s, plus a few other apostrophe fixes
merged-on-behalf-of: Nicholas Wilson <thewilsonator@users.noreply.github.com>

Author: dlang-bot

articles/cpptod.dd

@@ -179,7 +179,7 @@ $(H2 $(LNAME2 typedefs, Creating a new typedef'd type))
 
 $(H4 The C++ Way)
 
-        Typedef's in C++ are weak, that is, they really do not introduce
+        Typedefs in C++ are weak, that is, they really do not introduce
         a new type. The compiler doesn't distinguish between a typedef
         and its underlying type.
 

articles/d-array-article.dd

@@ -148,21 +148,21 @@ $(H2 $(LNAME2 determinism, Determinism))
 
 $(P There is one caveat with slice appending that can bite inexperienced, and even experienced D coders: the apparent non-deterministic behavior of appending.)
 
-$(P Let's say we have a function which is passed a buffer, and writes some number of A's to the buffer (appending if necessary), returning the filled buffer:)
+$(P Let's say we have a function which is passed a buffer, and writes some number of 'A's to the buffer (appending if necessary), returning the filled buffer:)
 
 ------
 import std.stdio;
 
 char[] fillAs(char[] buf, size_t num)
 {
     if (buf.length < num)
-        buf.length = num; // increase buffer length to be able to hold the A's
+        buf.length = num; // increase buffer length to be able to hold the 'A's
     buf[0..num] = 'A';    // assign A to all the elements
     return buf[0..num];   // return the result
 }
 ------
 
-$(P What's wrong with the $(D fillAs) function?  Nothing really, but what happens if increasing the length forces the buffer to be reallocated?  In that case, the buffer passed in is $(I not) overwritten with A's, only the reallocated buffer is.  This can be surprising if you were expecting to continue to use the same buffer in further operations, or if you expected the original buffer to be filled with A's.  The end result, depending on whether the block referenced by $(D buf[]) can be appended in place, is the caller's slice might be overwritten with A's, or it might not be.)
+$(P What's wrong with the $(D fillAs) function?  Nothing really, but what happens if increasing the length forces the buffer to be reallocated?  In that case, the buffer passed in is $(I not) overwritten with 'A's, only the reallocated buffer is.  This can be surprising if you were expecting to continue to use the same buffer in further operations, or if you expected the original buffer to be filled with 'A's.  The end result, depending on whether the block referenced by $(D buf[]) can be appended in place, is the caller's slice might be overwritten with 'A's, or it might not be.)
 
 ------
 // continued example...

articles/d-floating-point.dd

@@ -274,7 +274,7 @@ $(P All IEEE-compiliant processors include special status bits that indicate whe
 $(P Here's a list of the weird things that can be detected:)
 
 $(DL
-$(DT invalid) $(DD This is set if any NaN's have been generated. This can happen with $(INFIN) - $(INFIN), $(INFIN) * 0, 0 * $(INFIN), 0/0, $(INFIN)/$(INFIN), $(INFIN)%$(INFIN), or $(D x%0), for any number $(D x). Several other operations, such as sqrt(-1), can also generate a NaN. The $(I invalid) condition is also set when a 'signalling NaN' is accessed, indicating use of an uninitialized variable. This almost always indicates a programming error.)
+$(DT invalid) $(DD This is set if any NaNs have been generated. This can happen with $(INFIN) - $(INFIN), $(INFIN) * 0, 0 * $(INFIN), 0/0, $(INFIN)/$(INFIN), $(INFIN)%$(INFIN), or $(D x%0), for any number $(D x). Several other operations, such as sqrt(-1), can also generate a NaN. The $(I invalid) condition is also set when a 'signalling NaN' is accessed, indicating use of an uninitialized variable. This almost always indicates a programming error.)
 
 $(DT overflow) $(DD Set if $(INFIN) was generated by adding or multiplying two numbers that were so large that the sum was greater than $(D real.max). This almost always indicates that the result is incorrect; and corrective action needs to be taken.)
 

articles/hijack.dd

@@ -214,7 +214,7 @@ void abc()
 
 $(P and no error is generated. The difference here is that the user
 deliberately combined the overload sets in X and Y, and so presumably
-both knows what he's doing and is willing to check the $(CODE foo)'s when
+both knows what he's doing and is willing to check the $(CODE foo)s when
 X or Y is updated.
 )
 

articles/rationale.dd

@@ -162,7 +162,7 @@ infinity of a floating point type, rather than doing it in a library like C++:
         implying $(DOUBLEQUOTE the language and compiler don't know anything about IEEE 754
         floating point - so it cannot be relied on.) And in fact
         many otherwise excellent C++ compilers
-        do not handle NaN's correctly in floating point comparisons.
+        do not handle NaNs correctly in floating point comparisons.
         (Digital Mars C++ does do it correctly.)
         C++98 doesn't say anything about NaN or Infinity handling in expressions
         or library functions. So it must be assumed it doesn't work.
@@ -222,7 +222,7 @@ int test()
 ------
     )
 
-    $(LI Static if's can appear where only declarations are allowed:
+    $(LI Static ifs can appear where only declarations are allowed:
 
 ------
 class Foo
@@ -233,7 +233,7 @@ class Foo
 ------
     )
 
-    $(LI Static if's can declare new type aliases:
+    $(LI Static ifs can declare new type aliases:
 
 ------
 static if (0 || is(int T)) T x;

articles/regular-expression.dd

@@ -210,7 +210,7 @@ $(D_S $(TITLE),
     not our intention. Breaking down this example, (?<=[.?!]) part looks behind for first ., ? or !.
     This get us half way to our goal because \s* also matches between elements of punctuation like "?!",
     so a negative lookahead is introduced $(I inside lookbehind) to make sure we are past all of the punctuation marks.
-    Admittedly, barrage of ? and ! makes this regex rather obscure, more then it's actually is.
+    Admittedly, barrage of ? and ! makes this regex rather obscure, more then it actually is.
     Observe that there are no restrictions on contents of lookaround expressions,
     one can go for lookahead inside lookbehind and so on.
     However in general it's recommended to use them sparingly, keeping them as the weapon of last resort.

articles/templates-revisited.dd

@@ -453,7 +453,7 @@ template factorial(int n)
 
 $(P
 reducing 13 lines of code to an arguably much cleaner 7 lines.
-$(D static if)'s are the equivalent of C++'s $(D #if).
+$(D static if)s are the equivalent of C++'s $(D #if).
 But $(D #if) cannot access template
 arguments, so all template conditional compilation must be handled with
 partial and explicitly specialized templates.

articles/variadic-function-templates.dd

@@ -195,7 +195,7 @@ $(H3 The Static If Solution)
 
         $(P It would be nice to encapsulate all the logic into a
         single function. One way to do that is by using
-        static if's, which provide for conditional compilation:
+        $D(static if)s, which provide for conditional compilation:
         )
 
 ---

changelog/2.054.dd

@@ -78,7 +78,7 @@ $(VERSION Jul 10, 2011, =================================================,
     $(DMDBUGSFIXED
         $(LI $(BUGZILLA 693): 'this' can't be used as an alias parameter for a mixin)
         $(LI $(BUGZILLA 1373): typeof(func).stringof fails when func has parameters.)
-        $(LI $(BUGZILLA 1411): ref Tuple should transform to Tuple of ref's)
+        $(LI $(BUGZILLA 1411): ref Tuple should transform to Tuple of refs)
         $(LI $(BUGZILLA 1570): Wrong return for address operator)
         $(LI $(BUGZILLA 2180): filename error with #line)
         $(LI $(BUGZILLA 2521): Not possible to return immutable value by ref)

changelog/2.063.dd

@@ -712,7 +712,7 @@ void main()
 $(LI $(LNAME2 attribinference, Methods of templated aggregates can now infer attributes:)
 
 $(P If a function with some attributes instantiates a templated aggregate,
-    it's member functions will infer those attributes:)
+    its member functions will infer those attributes:)
 
 ---------
 struct S(T)
@@ -1005,7 +1005,7 @@ void test()
 }
 ---------
 
-$(P Allowing $(D template)'s inside of functions will enable better encapsulation and avoid the
+$(P Allowing $(D template)s inside of functions will enable better encapsulation and avoid the
     pollution of module-scoped symbol names.)
 
 $(LI $(LNAME2 ufcslocalimport, UFCS now works with scoped local imports:)