[DOC-CVS] [doc-en] master: Fix grammar in language/types (#5746)
[email protected] (Kamil Tekiela via GitHub)
| Newsgroups | php.doc.cvs |
|---|---|
| Message-ID | <[email protected]> |
Author: Kamil Tekiela (kamil-tekiela)
Committer: GitHub (web-flow)
Pusher: kamil-tekiela
Date: 2026-08-07T15:53:56+01:00
Commit: https://github.com/php/doc-en/commit/7132d8833a86604aa2d10c16c0470d0ef1a0fdfb
Raw diff: https://github.com/php/doc-en/commit/7132d8833a86604aa2d10c16c0470d0ef1a0fdfb.diff
Fix grammar in language/types (#5746)
Changed paths:
M language/types/array.xml
M language/types/callable.xml
M language/types/declarations.xml
M language/types/float.xml
M language/types/integer.xml
M language/types/iterable.xml
M language/types/mixed.xml
M language/types/never.xml
M language/types/null.xml
M language/types/numeric-strings.xml
M language/types/object.xml
M language/types/relative-class-types.xml
M language/types/resource.xml
M language/types/singleton.xml
M language/types/string.xml
M language/types/type-juggling.xml
M language/types/type-system.xml
M language/types/void.xml
Diff:
diff --git a/language/types/array.xml b/language/types/array.xml
index a81ce3188f44..d6330168f11a 100644
--- a/language/types/array.xml
+++ b/language/types/array.xml
@@ -478,16 +478,16 @@ $arr[] = <replaceable>value</replaceable>;
// <replaceable>key</replaceable> may be an <type>int</type> or <type>string</type>
// <replaceable>value</replaceable> may be any value of any type</synopsis>
- <para>
+ <simpara>
If <varname>$arr</varname> doesn't exist yet or is set to &null; or &false;, it will be created, so this is
also an alternative way to create an <type>array</type>. This practice is
however discouraged because if <varname>$arr</varname> already contains
some value (e.g. <type>string</type> from request variable) then this
- value will stay in the place and <literal>[]</literal> may actually stand
+ value will stay in place and <literal>[]</literal> may actually stand
for <link linkend="language.types.string.substr">string access
operator</link>. It is always better to initialize a variable by a direct
assignment.
- </para>
+ </simpara>
<note>
<simpara>
As of PHP 7.1.0, applying the empty index operator on a string throws a fatal
@@ -1052,17 +1052,17 @@ $error_descriptions[8] = "This is just an informal notice";
<literal>array($scalarValue)</literal>.
</para>
- <para>
+ <simpara>
If an <type>object</type> is converted to an <type>array</type>, the result
is an <type>array</type> whose elements are the <type>object</type>'s
properties. The keys are the member variable names, with a few notable
- exceptions: integer properties are unaccessible;
+ exceptions: integer properties are inaccessible;
private variables have the class name prepended to the variable
name; protected variables have a '*' prepended to the variable name. These
prepended values have <literal>NUL</literal> bytes on either side.
Uninitialized <link linkend="language.oop5.properties.typed-properties">typed properties</link>
are silently discarded.
- </para>
+ </simpara>
<example>
<title>Converting to an Array</title>
diff --git a/language/types/callable.xml b/language/types/callable.xml
index 71df364a1bcb..a5530d55bf5d 100644
--- a/language/types/callable.xml
+++ b/language/types/callable.xml
@@ -142,7 +142,7 @@ print implode(' ', $new_numbers);
<simpara>
Static class methods can be used without instantiating an
- <type>object</type> of that class by either, creating an array with
+ <type>object</type> of that class by either creating an array with
the class name at index 0 and the method name at index 1, or by using
the special syntax with the scope resolution operator
<literal>::</literal>, as in <literal>'ClassName::methodName'</literal>.
@@ -196,7 +196,7 @@ print implode(' ', $new_numbers);
<example>
<title>
- Calling various types of callables with <function>call_user_function</function>
+ Calling various types of callables with <function>call_user_func</function>
</title>
<programlisting role="php">
<![CDATA[
diff --git a/language/types/declarations.xml b/language/types/declarations.xml
index 03fc89f0b984..63718d4f020e 100644
--- a/language/types/declarations.xml
+++ b/language/types/declarations.xml
@@ -10,12 +10,12 @@
otherwise a <classname>TypeError</classname> is thrown.
</para>
- <para>
+ <simpara>
Every single type that PHP supports, with the exception of
- <type>resource</type> can be used within a user-land type declaration.
+ <type>resource</type>, can be used within a user-land type declaration.
This page contains a changelog of availability of the different types
and documentation about usage of them in type declarations.
- </para>
+ </simpara>
<note>
<para>
@@ -137,7 +137,7 @@
<title>Atomic Types Usage Notes</title>
<simpara>
- Atomic types have straight forward behaviour with some minor caveats which
+ Atomic types have straightforward behaviour with some minor caveats which
are described in this section.
</simpara>
@@ -219,7 +219,8 @@ function &test(): void {}
If a pass-by-reference parameter has a type declaration, the type of the
variable is <emphasis>only</emphasis> checked on function entry, at the
beginning of the call, but not when the function returns.
- This means that a function can change the type of variable reference.
+ This means that a function can change the type of the variable
+ passed by reference.
</simpara>
<example>
<title>Typed pass-by-reference Parameters</title>
@@ -307,7 +308,7 @@ Stack trace:
<simpara>
It is also possible to achieve nullable arguments by making
&null; the default value.
- This is not recommended as if the default value is changed in a child
+ This is not recommended because if the default value is changed in a child
class a type compatibility violation will be raised as the
<type>null</type> type will need to be added to the type declaration.
This behavior is also deprecated since PHP 8.4.
diff --git a/language/types/float.xml b/language/types/float.xml
index 2abe101d3729..65a0d1661c17 100644
--- a/language/types/float.xml
+++ b/language/types/float.xml
@@ -1,12 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<sect1 xml:id="language.types.float" xmlns:xlink="http://www.w3.org/1999/xlink">
- <title>Floating point numbers</title>
+ <title>Floating-point numbers</title>
- <para>
- Floating point numbers (also known as "floats", "doubles", or "real numbers")
+ <simpara>
+ Floating-point numbers (also known as "floats", "doubles", or "real numbers")
can be specified using any of the following syntaxes:
- </para>
+ </simpara>
<informalexample>
<programlisting role="php">
@@ -42,36 +42,36 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
</para>
<warning xml:id="warn.float-precision">
- <title>Floating point precision</title>
+ <title>Floating-point precision</title>
- <para>
- Floating point numbers have limited precision. Although it depends on the
+ <simpara>
+ Floating-point numbers have limited precision. Although it depends on the
system, PHP typically uses the IEEE 754 double precision format, which will
give a maximum relative error due to rounding in the order of 1.11e-16.
- Non elementary arithmetic operations may give larger errors, and, of course,
+ Non-elementary arithmetic operations may give larger errors, and, of course,
error propagation must be considered when several operations are
compounded.
- </para>
+ </simpara>
- <para>
- Additionally, rational numbers that are exactly representable as floating
- point numbers in base 10, like <literal>0.1</literal> or
- <literal>0.7</literal>, do not have an exact representation as floating
- point numbers in base 2, which is used internally, no matter the size of
+ <simpara>
+ Additionally, rational numbers that are exactly representable as floating-point
+ numbers in base 10, like <literal>0.1</literal> or
+ <literal>0.7</literal>, do not have an exact representation as floating-point
+ numbers in base 2, which is used internally, no matter the size of
the mantissa. Hence, they cannot be converted into their internal binary
counterparts without a small loss of precision. This can lead to confusing
results: for example, <literal>floor((0.1+0.7)*10)</literal> will usually
return <literal>7</literal> instead of the expected <literal>8</literal>,
since the internal representation will be something like
<literal>7.9999999999999991118...</literal>.
- </para>
+ </simpara>
- <para>
- So never trust floating number results to the last digit, and do not compare
- floating point numbers directly for equality. If higher precision is
+ <simpara>
+ So never trust floating-point number results to the last digit, and do not compare
+ floating-point numbers directly for equality. If higher precision is
necessary, the <link linkend="ref.bc">arbitrary precision math functions</link>
and <link linkend="ref.gmp">gmp</link> functions are available.
- </para>
+ </simpara>
<para>
For a "simple" explanation, see the <link xlink:href="&url.floating.point.guide;">floating point guide</link>
@@ -117,18 +117,18 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
<sect2 xml:id="language.types.float.comparison">
<title>Comparing floats</title>
- <para>
- As noted in the warning above, testing floating point values for equality is
+ <simpara>
+ As noted in the warning above, testing floating-point values for equality is
problematic, due to the way that they are represented internally. However,
- there are ways to make comparisons of floating point values that work around
+ there are ways to make comparisons of floating-point values that work around
these limitations.
- </para>
+ </simpara>
- <para>
- To test floating point values for equality, an upper bound on the relative
+ <simpara>
+ To test floating-point values for equality, an upper bound on the relative
error due to rounding is used. This value is known as the machine epsilon,
or unit roundoff, and is the smallest acceptable difference in calculations.
- </para>
+ </simpara>
<para>
<varname>$a</varname> and <varname>$b</varname> are equal to 5 digits of
diff --git a/language/types/integer.xml b/language/types/integer.xml
index 426abf6545c8..ef2256093f0c 100644
--- a/language/types/integer.xml
+++ b/language/types/integer.xml
@@ -12,7 +12,7 @@
&reftitle.seealso;
<para>
<simplelist>
- <member><link linkend="language.types.float">Floating point numbers</link></member>
+ <member><link linkend="language.types.float">Floating-point numbers</link></member>
<member><link linkend="book.bc">Arbitrary precision / BCMath</link></member>
<member><link linkend="book.gmp">Arbitrary length integer / GMP</link></member>
</simplelist>
@@ -29,12 +29,12 @@
can be used to denote a negative <type>int</type>.
</simpara>
- <para>
+ <simpara>
To use octal notation, precede the number with a <literal>0</literal> (zero).
As of PHP 8.1.0, octal notation can also be preceded with <literal>0o</literal> or <literal>0O</literal>.
- To use hexadecimal notation precede the number with <literal>0x</literal>.
- To use binary notation precede the number with <literal>0b</literal>.
- </para>
+ To use hexadecimal notation, precede the number with <literal>0x</literal>.
+ To use binary notation, precede the number with <literal>0b</literal>.
+ </simpara>
<para>
As of PHP 7.4.0, integer literals may contain underscores (<literal>_</literal>) between digits,
@@ -125,13 +125,13 @@ var_dump(PHP_INT_MAX + 1); // 32-bit system: float(2147483648)
<sect2 xml:id="language.types.integer.division">
<title>Integer division</title>
- <para>
- There is no <type>int</type> division operator in PHP, to achieve this
+ <simpara>
+ There is no <type>int</type> division operator in PHP. To achieve this,
use the <function>intdiv</function> function.
<literal>1/2</literal> yields the <type>float</type> <literal>0.5</literal>.
The value can be cast to an <type>int</type> to round it towards zero, or
the <function>round</function> function provides finer control over rounding.
- </para>
+ </simpara>
<example>
<title>Divisions</title>
@@ -185,7 +185,8 @@ var_dump(round(25/7)); // float(4)
<simpara>
When converting from <type>float</type> to <type>int</type>, the number
will be rounded <emphasis>towards zero</emphasis>.
- As of PHP 8.1.0, a deprecation notice is emitted when implicitly converting a non-integral &float; to &integer; which loses precision.
+ As of PHP 8.1.0, a deprecation notice is emitted when implicitly converting
+ a non-integral &float; to an &integer; which loses precision.
</simpara>
<example>
diff --git a/language/types/iterable.xml b/language/types/iterable.xml
index 6e8471131e20..c0319347c933 100644
--- a/language/types/iterable.xml
+++ b/language/types/iterable.xml
@@ -3,19 +3,19 @@
<sect1 xml:id="language.types.iterable">
<title>Iterables</title>
- <para>
- <type>Iterable</type> is a built-in compile time type alias for
+ <simpara>
+ <type>Iterable</type> is a built-in compile-time type alias for
<!-- Need to improve rendering of free-standing type elements in PhD
<type class="union"><type>array</type><type>Traversable</type></type>.
-->
<literal>array|Traversable</literal>.
From its introduction in PHP 7.1.0 and prior to PHP 8.2.0,
<type>iterable</type> was a built-in pseudo-type that acted as the
- aforementioned type alias and can be used as a type declaration.
+ aforementioned type alias and could be used as a type declaration.
An iterable type can be used in &foreach; and with
<command>yield from</command> within a
<link linkend="language.generators">generator</link>.
- </para>
+ </simpara>
<note>
<para>
diff --git a/language/types/mixed.xml b/language/types/mixed.xml
index 3d65f66ddb25..d595d7986cb4 100644
--- a/language/types/mixed.xml
+++ b/language/types/mixed.xml
@@ -15,10 +15,10 @@
Available as of PHP 8.0.0.
</para>
- <para>
- <type>mixed</type> is, in type theory parlance, the top type.
- Meaning every other type is a subtype of it.
- </para>
+ <simpara>
+ <type>mixed</type> is, in type theory parlance, the top type,
+ meaning every other type is a subtype of it.
+ </simpara>
</sect1>
<!-- Keep this comment at the end of the file
diff --git a/language/types/never.xml b/language/types/never.xml
index c7b1703516cc..2b84103606b7 100644
--- a/language/types/never.xml
+++ b/language/types/never.xml
@@ -10,11 +10,11 @@
<link linkend="language.types.type-system.composite.union">union type</link>
declaration. Available as of PHP 8.1.0.
</para>
- <para>
- <type>never</type> is, in type theory parlance, the bottom type.
- Meaning it is the subtype of every other type and can replace any other
+ <simpara>
+ <type>never</type> is, in type theory parlance, the bottom type,
+ meaning it is the subtype of every other type and can replace any other
return type during inheritance.
- </para>
+ </simpara>
</sect1>
<!-- Keep this comment at the end of the file
diff --git a/language/types/null.xml b/language/types/null.xml
index 0acaa42bd8de..90fc1ff29d0e 100644
--- a/language/types/null.xml
+++ b/language/types/null.xml
@@ -8,10 +8,10 @@
&null;.
</para>
- <para>
- Undefined, and <function>unset</function> variables will resolve to the
+ <simpara>
+ Undefined and <function>unset</function> variables resolve to the
value &null;.
- </para>
+ </simpara>
<sect2 xml:id="language.types.null.syntax">
<title>Syntax</title>
diff --git a/language/types/numeric-strings.xml b/language/types/numeric-strings.xml
index 5f36aab79958..ff787af10544 100644
--- a/language/types/numeric-strings.xml
+++ b/language/types/numeric-strings.xml
@@ -54,7 +54,7 @@ var_dump("2E1" == "020"); // true, "2E1" is 2 * (10 ^ 1), or 20
<sect2 xml:id="language.types.numeric-string.conversion">
<title>Strings used in numeric contexts</title>
<para>
- When a <type>string</type> needs to be evaluated as number (e.g. arithmetic
+ When a <type>string</type> needs to be evaluated as a number (e.g. arithmetic
operations, <type>int</type> type declaration, etc.) the following
steps are taken to determine the outcome:
@@ -81,7 +81,7 @@ var_dump("2E1" == "020"); // true, "2E1" is 2 * (10 ^ 1), or 20
</listitem>
<listitem>
<simpara>
- The <type>string</type> is not numeric, throw a
+ If the <type>string</type> is not numeric, throw a
<classname>TypeError</classname>.
</simpara>
</listitem>
@@ -91,12 +91,12 @@ var_dump("2E1" == "020"); // true, "2E1" is 2 * (10 ^ 1), or 20
<sect2 xml:id="language.types.numeric-string.prior">
<title>Behavior prior to PHP 8.0.0</title>
- <para>
- Prior to PHP 8.0.0, a <type>string</type> was considered numeric only if it
- had <emphasis>leading</emphasis> whitespaces, if it had
+ <simpara>
+ Prior to PHP 8.0.0, a <type>string</type> was considered numeric if it only
+ had <emphasis>leading</emphasis> whitespaces. If it had
<emphasis>trailing</emphasis> whitespaces then the string was considered to
be leading numeric.
- </para>
+ </simpara>
<para>
Prior to PHP 8.0.0, when a string was used in a numeric context it would
@@ -110,7 +110,7 @@ var_dump("2E1" == "020"); // true, "2E1" is 2 * (10 ^ 1), or 20
</listitem>
<listitem>
<simpara>
- If the string is not numeric, an <constant>E_WARNING</constant> was
+ If the string was not numeric, an <constant>E_WARNING</constant> was
raised and the value <literal>0</literal> would be returned.
</simpara>
</listitem>
diff --git a/language/types/object.xml b/language/types/object.xml
index 771b29f0b2ef..10ebd474e455 100644
--- a/language/types/object.xml
+++ b/language/types/object.xml
@@ -41,15 +41,15 @@ $bar->do_foo();
<sect2 xml:id="language.types.object.casting">
<title>Converting to object</title>
- <para>
+ <simpara>
If an <type>object</type> is converted to an <type>object</type>, it is not
modified. If a value of any other type is converted to an
<type>object</type>, a new instance of the <classname>stdClass</classname>
built-in class is created. If the value was &null;, the new instance will be
empty. An <type>array</type> converts to an <type>object</type> with properties
- named by keys and corresponding values. Note that in this case before PHP 7.2.0 numeric keys
- have been inaccessible unless iterated.
- </para>
+ named by keys and with their corresponding values.
+ Prior to PHP 7.2.0, numeric keys would have been inaccessible unless iterated.
+ </simpara>
<example>
<title>Casting to an Object</title>
diff --git a/language/types/relative-class-types.xml b/language/types/relative-class-types.xml
index 565bae8d685f..90218ab4235d 100644
--- a/language/types/relative-class-types.xml
+++ b/language/types/relative-class-types.xml
@@ -3,9 +3,9 @@
<sect1 xml:id="language.types.relative-class-types">
<title>Relative class types</title>
- <para>
- These types declarations can only be used within classes.
- </para>
+ <simpara>
+ These type declarations can only be used within classes.
+ </simpara>
<sect2 xml:id="language.types.relative-class-types.self">
<title><type>self</type></title>
diff --git a/language/types/resource.xml b/language/types/resource.xml
index 3ddceb720485..09fcbb858b4f 100644
--- a/language/types/resource.xml
+++ b/language/types/resource.xml
@@ -27,12 +27,12 @@
<sect2 xml:id="language.types.resource.self-destruct">
<title>Freeing resources</title>
- <para>
- Thanks to the reference-counting system being part of Zend Engine,
+ <simpara>
+ Thanks to the reference-counting system being part of the Zend Engine,
a <type>resource</type> with no more references to it is detected
automatically, and it is freed by the garbage collector. For this reason, it
is rarely necessary to free the memory manually.
- </para>
+ </simpara>
<note>
<simpara>
diff --git a/language/types/singleton.xml b/language/types/singleton.xml
index a5d15bc36e4c..6f71013e8f4e 100644
--- a/language/types/singleton.xml
+++ b/language/types/singleton.xml
@@ -12,7 +12,7 @@
<warning>
<simpara>
- Prior to PHP 8.2.0 the <type>false</type> type
+ Prior to PHP 8.2.0, the <type>false</type> type
could only be used as part of a
<link linkend="language.types.type-system.composite.union">union type</link>.
</simpara>
diff --git a/language/types/string.xml b/language/types/string.xml
index fcfb74084454..2013b079d4c5 100644
--- a/language/types/string.xml
+++ b/language/types/string.xml
@@ -13,8 +13,8 @@
<note>
<simpara>
- On 32-bit builds, a <type>string</type> can be as large as up to 2GB
- (2147483647 bytes maximum)
+ On 32-bit builds, a <type>string</type> can be up to 2GB (2147483647 bytes)
+ in length.
</simpara>
</note>
@@ -264,7 +264,8 @@ c
</example>
<simpara>
- If the closing identifier is indented further than any lines of the body, then a <classname>ParseError</classname> will be thrown:
+ If the closing identifier is indented further than any lines of the body,
+ then a <exceptionname>ParseError</exceptionname> will be thrown:
</simpara>
<example>
@@ -288,23 +289,24 @@ Parse error: Invalid body indentation level (expecting an indentation level of a
</example>
<simpara>
- If the closing identifier is indented, tabs can be used as well, however,
- tabs and spaces <emphasis>must not</emphasis> be intermixed regarding
- the indentation of the closing identifier and the indentation of the body
- (up to the closing identifier). In any of these cases, a <classname>ParseError</classname> will be thrown.
+ If the closing identifier is indented, tabs can be used as well. However,
+ tabs and spaces <emphasis>must not</emphasis> be intermixed.
+ The indentation of the body and the closing identifier must use one or the
+ other consistently. If tabs and spaces are mixed,
+ then a <exceptionname>ParseError</exceptionname> will be thrown.
These whitespace constraints have been included because mixing tabs and
spaces for indentation is harmful to legibility.
</simpara>
<example>
- <title>Different indentation for body (spaces) closing identifier</title>
+ <title>Different indentation for body and closing identifier</title>
<programlisting role="php" annotations="non-interactive">
<![CDATA[
<?php
-// All the following code do not work.
+// All of the following code does not work.
-// different indentation for body (spaces) ending marker (tabs)
+// different indentation for body (spaces) and ending marker (tabs)
{
echo <<<END
a
@@ -370,13 +372,13 @@ array(2) {
<warning>
<simpara>
- If the closing identifier was found at the start of a line, then
- regardless of whether it was a part of another word, it may be considered
- as the closing identifier and causes a <classname>ParseError</classname>.
+ If the closing identifier is found at the start of a line, then
+ regardless of whether it is a part of another word, it is considered
+ as the closing identifier and causes a <exceptionname>ParseError</exceptionname>.
</simpara>
<example>
- <title>Closing identifier in body of the string tends to cause ParseError</title>
+ <title>Closing identifier in body of the string tends to cause <exceptionname>ParseError</exceptionname></title>
<programlisting role="php">
<![CDATA[
<?php
@@ -590,15 +592,15 @@ FOOBAR;
<sect3 xml:id="language.types.string.syntax.nowdoc">
<title>Nowdoc</title>
- <para>
+ <simpara>
Nowdocs are to single-quoted strings what heredocs are to double-quoted
strings. A nowdoc is specified similarly to a heredoc, but <emphasis>no
- String interpolation is done</emphasis> inside a nowdoc. The construct is ideal for
+ string interpolation is done</emphasis> inside a nowdoc. The construct is ideal for
embedding PHP code or other large blocks of text without the need for
escaping. It shares some features in common with the SGML
<literal><![CDATA[ ]]></literal> construct, in that it declares a
block of text which is not for parsing.
- </para>
+ </simpara>
<para>
A nowdoc is identified with the same <literal><<<</literal>
@@ -804,7 +806,7 @@ string(3) "bar"
<note>
<simpara>
If it is not possible to form a valid name the dollar sign remains
- as verbatim in the string:
+ verbatim in the string:
</simpara>
<informalexample>
<programlisting role="php">
@@ -873,8 +875,8 @@ Object value: string.
</note>
<simpara>
- As of PHP 7.1.0 also <emphasis>negative</emphasis> numeric indices are
- supported.
+ As of PHP 7.1.0, <emphasis>negative</emphasis> numeric indices are
+ supported too.
</simpara>
<example><title>Negative numeric indices</title>
@@ -991,7 +993,7 @@ echo "C:\\directory\\{$great}.txt" . PHP_EOL;
<note>
<simpara>
- As this syntax allows arbitrary expressions it is possible to use
+ As this syntax allows arbitrary expressions, it is possible to use
<link linkend="language.variables.variable">variable variables</link>
within the advanced syntax.
</simpara>
@@ -1032,9 +1034,9 @@ echo "C:\\directory\\{$great}.txt" . PHP_EOL;
<warning>
<simpara>
- Writing to an out of range offset pads the string with spaces.
- Non-integer types are converted to integer.
- Illegal offset type emits <constant>E_WARNING</constant>.
+ Writing to an out-of-range offset pads the string with spaces.
+ Non-integer types are converted to an integer.
+ An illegal offset type emits <constant>E_WARNING</constant>.
Only the first character of an assigned string is used.
As of PHP 7.1.0, assigning an empty string throws a fatal error. Formerly,
it assigned a NULL byte.
@@ -1213,12 +1215,12 @@ string(1) "b"
forth between <type>bool</type> and <type>string</type> values.
</para>
- <para>
+ <simpara>
An <type>int</type> or <type>float</type> is converted to a
<type>string</type> representing the number textually (including the
- exponent part for <type>float</type>s). Floating point numbers can be
+ exponent part for <type>float</type>s). Floating-point numbers can be
converted using exponential notation (<literal>4.1E+6</literal>).
- </para>
+ </simpara>
<note>
<para>
@@ -1278,29 +1280,29 @@ string(1) "b"
<title>Details of the String Type</title>
- <para>
+ <simpara>
The <type>string</type> in PHP is implemented as an array of bytes and an
integer indicating the length of the buffer. It has no information about how
those bytes translate to characters, leaving that task to the programmer.
There are no limitations on the values the string can be composed of; in
particular, bytes with value <literal>0</literal> (“NUL bytes”) are allowed
- anywhere in the string (however, a few functions, said in this manual not to
+ anywhere in the string. However, a few functions, said in this manual not to
be “binary safe”, may hand off the strings to libraries that ignore data
- after a NUL byte.)
- </para>
+ after a NUL byte.
+ </simpara>
<para>
This nature of the string type explains why there is no separate “byte” type
in PHP – strings take this role. Functions that return no textual data – for
instance, arbitrary data read from a network socket – will still return
strings.
</para>
- <para>
+ <simpara>
Given that PHP does not dictate a specific encoding for strings, one might
wonder how string literals are encoded. For instance, is the string
<literal>"á"</literal> equivalent to <literal>"\xE1"</literal> (ISO-8859-1),
<literal>"\xC3\xA1"</literal> (UTF-8, C form),
<literal>"\x61\xCC\x81"</literal> (UTF-8, D form) or any other possible
- representation? The answer is that string will be encoded in whatever fashion
+ representation? The answer is that the string will be encoded in whatever fashion
it is encoded in the script file. Thus, if the script is written in
ISO-8859-1, the string will be encoded in ISO-8859-1 and so on. However,
this does not apply if Zend Multibyte is enabled; in that case, the script
@@ -1313,7 +1315,7 @@ string(1) "b"
UTF-8 or ISO-8859-1. Note, however, that state-dependent encodings where
the same byte values can be used in initial and non-initial shift states
may be problematic.
- </para>
+ </simpara>
<para>
Of course, in order to be useful, functions that operate on text may have to
make some assumptions about how the string is encoded. Unfortunately, there
@@ -1324,17 +1326,17 @@ string(1) "b"
<simpara>
Some functions assume that the string is encoded in some (any) single-byte
encoding, but they do not need to interpret those bytes as specific
- characters. This is case of, for instance, <function>substr</function>,
+ characters. This is the case of, for instance, <function>substr</function>,
<function>strpos</function>, <function>strlen</function> or
<function>strcmp</function>. Another way to think of these functions is
- that operate on memory buffers, i.e., they work with bytes and byte
+ that they operate on memory buffers, i.e., they work with bytes and byte
offsets.
</simpara>
</listitem>
<listitem>
<simpara>
- Other functions are passed the encoding of the string, possibly they also
- assume a default if no such information is given. This is the case of
+ Other functions receive the encoding of the string as a parameter or
+ assume a default when it's not provided. This is the case of
<function>htmlentities</function> and the majority of the
functions in the <link linkend="book.mbstring">mbstring</link> extension.
</simpara>
diff --git a/language/types/type-juggling.xml b/language/types/type-juggling.xml
index 6c4efcb7aa15..09cd47b5903f 100644
--- a/language/types/type-juggling.xml
+++ b/language/types/type-juggling.xml
@@ -58,13 +58,13 @@
</simpara>
<simpara>
- In this context if either operand is a <type>float</type> (or not
+ In this context, if either operand is a <type>float</type> (or not
interpretable as an <type>int</type>), both operands are interpreted as
<type>float</type>s, and the result will be a <type>float</type>.
Otherwise, the operands will be interpreted as <type>int</type>s,
and the result will also be an <type>int</type>.
- As of PHP 8.0.0, if one of the operands cannot be interpreted a
- <classname>TypeError</classname> is thrown.
+ As of PHP 8.0.0, if one of the operands cannot be interpreted, a
+ <exceptionname>TypeError</exceptionname> is thrown.
</simpara>
</sect2>
@@ -80,8 +80,8 @@
</simpara>
<simpara>
- In this context the value will be interpreted as <type>string</type>.
- If the value cannot be interpreted a <classname>TypeError</classname> is thrown.
+ In this context, the value will be interpreted as <type>string</type>.
+ If the value cannot be interpreted, a <exceptionname>TypeError</exceptionname> is thrown.
Prior to PHP 7.4.0, an <constant>E_RECOVERABLE_ERROR</constant> was raised.
</simpara>
</sect2>
@@ -96,7 +96,7 @@
</simpara>
<simpara>
- In this context the value will be interpreted as <type>bool</type>.
+ In this context, the value will be interpreted as <type>bool</type>.
</simpara>
</sect2>
@@ -109,12 +109,12 @@
</simpara>
<simpara>
- In this context if all operands are of type <type>string</type> the result
+ In this context, if all operands are of type <type>string</type>, the result
will also be a <type>string</type>.
Otherwise, the operands will be interpreted as <type>int</type>s,
and the result will also be an <type>int</type>.
- As of PHP 8.0.0, if one of the operands cannot be interpreted a
- <classname>TypeError</classname> is thrown.
+ As of PHP 8.0.0, if one of the operands cannot be interpreted, a
+ <exceptionname>TypeError</exceptionname> is thrown.
</simpara>
</sect2>
@@ -141,24 +141,24 @@
or returned from a function which declares a return type.
</simpara>
- <para>
- In this context the value must be a value of the type.
- Two exceptions exist, the first one is: if the value is of type
+ <simpara>
+ In this context, the value must be a value of the type.
+ Two exceptions exist. The first one is: if the value is of type
<type>int</type> and the declared type is <type>float</type>, then the
integer is converted to a floating point number.
The second one is: if the declared type is a <emphasis>scalar</emphasis>
<!-- e.g. An object that implements __toString will pass a string type -->
- type, the value is convertable to a scalar type,
+ type, the value is convertible to a scalar type,
and the coercive typing mode is active
(the default), the value may be converted to an accepted scalar value.
See below for a description of this behaviour.
- </para>
+ </simpara>
<warning>
<simpara>
<link linkend="functions.internal">Internal functions</link>
- automatically coerce &null; to scalar types,
- this behaviour is <emphasis>DEPRECATED</emphasis> as of PHP 8.1.0.
+ automatically coerce &null; to scalar types.
+ This behaviour is <emphasis>DEPRECATED</emphasis> as of PHP 8.1.0.
</simpara>
</warning>
@@ -173,14 +173,14 @@
<listitem>
<simpara>
<type>int</type> type declaration: value is interpreted as <type>int</type>
- if the conversion is well-defined. For example the string is
+ if the conversion is well-defined. For example, the string is
<link linkend="language.types.numeric-strings">numeric</link>.
</simpara>
</listitem>
<listitem>
<simpara>
<type>float</type> type declaration: value is interpreted as <type>float</type>
- if the conversion is well-defined. For example the string is
+ if the conversion is well-defined. For example, the string is
<link linkend="language.types.numeric-strings">numeric</link>.
</simpara>
</listitem>
@@ -240,12 +240,12 @@
</caution>
<note>
- <para>
+ <simpara>
Types that are not part of the above preference list are not eligible
- targets for implicit coercion. In particular no implicit coercions to
+ targets for implicit coercion. In particular, no implicit coercions to
the <type>null</type>, <type>false</type>, and <type>true</type>
types occur.
- </para>
+ </simpara>
</note>
<example>
@@ -352,7 +352,7 @@ var_dump($bar);
<caution>
<simpara>
- The <literal>(binary)</literal> cast and <literal>b</literal> prefix exists
+ The <literal>(binary)</literal> cast and <literal>b</literal> prefix exist
for forward support. Currently <literal>(binary)</literal> and
<literal>(string)</literal> are identical, however this may change and
should not be relied upon.
diff --git a/language/types/type-system.xml b/language/types/type-system.xml
index db9f2a9fd673..2d361c3ec609 100644
--- a/language/types/type-system.xml
+++ b/language/types/type-system.xml
@@ -16,10 +16,10 @@
<sect2 xml:id="language.types.type-system.atomic">
<title>Atomic types</title>
- <para>
+ <simpara>
Some atomic types are built-in types which are tightly integrated with the
- language and cannot be reproduced with user defined types.
- </para>
+ language and cannot be reproduced with user-defined types.
+ </simpara>
<para>
The list of base types is:
@@ -159,14 +159,14 @@
<sect3 xml:id="language.types.type-system.composite.intersection">
<title>Intersection types</title>
- <para>
- An intersection type accepts values which satisfies multiple
+ <simpara>
+ An intersection type accepts values which satisfy multiple
class-type declarations, rather than a single one.
Individual types which form the intersection type are joined by the
<literal>&</literal> symbol. Therefore, an intersection type comprised
of the types <literal>T</literal>, <literal>U</literal>, and
<literal>V</literal> will be written as <literal>T&U&V</literal>.
- </para>
+ </simpara>
</sect3>
<sect3 xml:id="language.types.type-system.composite.union">
@@ -179,7 +179,7 @@
of the types <literal>T</literal>, <literal>U</literal>, and
<literal>V</literal> will be written as <literal>T|U|V</literal>.
If one of the types is an intersection type, it needs to be bracketed
- with parenthesis for it to be written in <acronym>DNF</acronym>:
+ with parentheses for it to be written in <acronym>DNF</acronym>:
<literal>T|(X&Y)</literal>.
</simpara>
</sect3>
@@ -188,13 +188,13 @@
<sect2 xml:id="language.types.type-system.alias">
<title>Type aliases</title>
- <para>
+ <simpara>
PHP supports two type aliases: <type>mixed</type> and
- <type>iterable</type> which corresponds to the
+ <type>iterable</type> which correspond to the
<link linkend="language.types.type-system.composite.union">union type</link>
of <literal>object|resource|array|string|float|int|bool|null</literal>
and <literal>Traversable|array</literal> respectively.
- </para>
+ </simpara>
<note>
<simpara>
diff --git a/language/types/void.xml b/language/types/void.xml
index 5f3bd1025955..60352d2f3e51 100644
--- a/language/types/void.xml
+++ b/language/types/void.xml
@@ -12,8 +12,8 @@
<note>
<simpara>
- Even if a function has a return type of <type>void</type> it will
- still return a value, this value is always &null;.
+ Even if a function has a return type of <type>void</type>, it will
+ still return a value. This value is always &null;.
</simpara>
</note>