Try to clarify wording

_posts/2018-02-15-totw-142.md

@@ -75,18 +75,23 @@ object, no confusion arises from this affordance.
 
 ## Constructors That Do More
 
-Implicitly calling a constructor isn’t such a good idea if its output is a
-different value than its input, or if it might have preconditions.
+Implicitly calling a constructor isn’t such a good idea if the new object is a
+different value than its inputs (that is, the input and output are not in an
+“is” relationship, either by inheritance or conversion) or if the constructor
+might have preconditions.
 
 Consider a `Request` class with a constructor `Request(Server*, Connection*)`.
 There’s no sense in which the value of the request object “is” the server and
-connection — it’s just that we can create a request that uses them. There could
-be many semantically different types that can be constructed from `{server,
-connection}`, such as a `Response`. Such a constructor should be `explicit`, so
-that we can’t pass `{server, connection}` to a function that accepts a `Request`
-(or `Response`) parameter. In such cases marking the constructor as `explicit`
-makes the code clearer for readers by requiring the target type to be named when
-it’s instantiated and helps to avoids bugs caused by unintended conversions.
+connection that simply get converted into a request object. Rather, we use this 
+constructor to create a request that uses the inputs -- a “has” relationship.
+
+There could be many semantically different types that can be constructed 
+from `{server, connection}`, such as a `Response`. Such a constructor 
+should be `explicit`, so that we can’t pass `{server, connection}` to 
+a function that accepts a `Request` (or `Response`) parameter. In such 
+cases marking the constructor as `explicit` makes the code clearer for 
+readers by requiring the target type to be named when it’s 
+instantiated and helps to avoids bugs caused by unintended conversions. 
 
 ```c++
 // A line is defined by two distinct points.
@@ -167,4 +172,4 @@ If the recommendations in this tip were applied, that constructor would be
 `explicit`, because the value of a `std::vector<char>` is not two iterators
 (rather, it’s a sequence of characters). As it is, `explicit` was omitted, and
 this example code gives undefined behavior as the second iterator is not
-reachable from the first.
+reachable from the first.