Typo fixes and a few readability improvements.

5 files changed, 9 insertions, 9 deletions

diff --git a/_doc/api.ryd b/_doc/api.ryd
index 6a94044..bd4985d 100644
--- a/_doc/api.ryd
+++ b/_doc/api.ryd
@@ -37,7 +37,7 @@ preserve quotes.
 
 Up to 0.15.0, the dumpers (``dump()``, ``safe_dump``,
 ``round_trip_dump()``, ``dump_all()``, etc.) had a plethora of
-arguments, some inhereted from ``PyYAML``, some added in
+arguments, some inherited from ``PyYAML``, some added in
 ``ruamel.yaml``. The only required argument is the ``data`` to be
 dumped. If the stream argument is not provided to the dumper, then a
 string representation is build up in memory and returned to the
@@ -45,7 +45,7 @@ caller.
 
 Starting with 0.15.0 ``load()`` and ``dump()`` are methods on a
 ``YAML`` instance and only take the stream,
-resp. the data and stram argument. All other parameters  are set on the instance
+resp. the data and stream argument. All other parameters are set on the instance
 of ``YAML`` before calling ``load()`` or ``dump()``
 
 Before 0.15.0::
@@ -212,7 +212,7 @@ Reason for API change
 +++++++++++++++++++++
 
 ``ruamel.yaml`` inherited the way of doing things from ``PyYAML``. In
-particular when calling the function ``load()`` or ``dump()`` a
+particular when calling the function ``load()`` or ``dump()``
 temporary instances of  ``Loader()`` resp. ``Dumper()``  were
 created that were discarded on termination of the function.
 
diff --git a/_doc/basicuse.ryd b/_doc/basicuse.ryd
index 36da2d4..c4a744d 100644
--- a/_doc/basicuse.ryd
+++ b/_doc/basicuse.ryd
@@ -33,7 +33,7 @@ yaml.load(doc)
 in this ``doc`` can be a file pointer (i.e. an object that has the
 ``.read()`` method, a string or a ``pathlib.Path()``. ``typ='safe'``
 accomplishes the same as what ``safe_load()`` did before: loading of a
-document without resolving unknow tags. Provide  ``pure=True`` to
+document without resolving unknown tags. Provide  ``pure=True`` to
 enforce using the pure Python implementation (faster C libraries will be used
 when possible/available)
 
diff --git a/_doc/detail.ryd b/_doc/detail.ryd
index ea976e1..ca245e0 100644
--- a/_doc/detail.ryd
+++ b/_doc/detail.ryd
@@ -95,7 +95,7 @@ this advice **might lead to invalid output**.
 Inconsistently indented YAML
 ++++++++++++++++++++++++++++
 
-If your input is inconsistently indented, such indentation cannot be preserverd.
+If your input is inconsistently indented, such indentation cannot be preserved.
 The first round-trip will make it consistent/normalize it. Here are some
 inconsistently indented YAML examples.
 
diff --git a/_doc/dumpcls.ryd b/_doc/dumpcls.ryd
index de00d16..0327f96 100644
--- a/_doc/dumpcls.ryd
+++ b/_doc/dumpcls.ryd
@@ -14,7 +14,7 @@ Only ``yaml = YAML(typ='unsafe')`` loads and dumps Python objects out-of-the-box
 since it loads **any** Python object, this can be unsafe.
 
 If you have instances of some class(es) that you want to dump or load, it is
-easy to allow the YAML instance to that explicitly. You can either registering the
+easy to allow the YAML instance to do that explicitly. You can either register the
 class with the ``YAML`` instance or decorate the class.
 
 Registering is done with ``YAML.register_class()``::
diff --git a/_doc/example.ryd b/_doc/example.ryd
index 58a5a1e..2943d54 100644
--- a/_doc/example.ryd
+++ b/_doc/example.ryd
@@ -183,14 +183,14 @@ stream parameter to one of the ``dump()`` variants, in order to get a monolithic
 representation of the stream back.
 
 Apart from being memory inefficient and slow, quite often people using this did not
-realiase that ``print(round_trip_dump(dict(a=1, b=2)))`` gets you an extra,
+realise that ``print(round_trip_dump(dict(a=1, b=2)))`` gets you an extra,
 empty, line after ``b: 2``.
 
-The real quesiton is why is this functionality, which is seldom really
+The real question is why this functionality, which is seldom really
 necessary, is available in the old API (and in PyYAML) in the first place. One
 explanation you get by looking at what someone would need to do to make this
 available if it weren't there already. Apart from subclassing the ``Serializer``
-and providing a new ``dump`` method,which would ten or so lines, another
+and providing a new ``dump`` method, which would ten or so lines, another
 **hundred** lines, essentially the whole ``dumper.py`` file, would need to be
 copied and to make use of this serializer.