be more specific

Signed-off-by: Marcus Müller <marcus@hostalia.de>

Author: marcusmueller

grep-9999-tag-sensitivity-list.md

@@ -31,25 +31,28 @@ This GREP is licensed as CC-BY-4.0; original author as stated above.
 It is commonly requested feature to be able to set the property of a block,
 accessible through setters, through stream tags.
 
-The implementation of that would under current circumstances not quite
+The implementation of that would, under current circumstances, be not quite
 straightforward. To illustrate the steps and decisions to be made in such a
 situation, let's discuss how one would extend a simple block like "Interpolating
 FIR Filter" block with both stream tag and message port setters accepting PMT
 uniform vectors.
 
 1. Implement thread-safe native and message handling setters. This can either be
    achieved by:
-   - Having a `private` thread-unsafe native setter; acquiring the
-     `block::d_setlock` mutex in a `public` setter and in the critical part of
-     `work` and a PMT-accepting setter, both calling the thread-unsafe native
-     setter. Register the PMT-accepting setter as message handler.
-   - Implementing and registering a `private` message handler method, which
-     accepts a PMT, extracts the native type from the that and is called by GNU
-     Radio only when `work` is not currently running. Implement a native setter
-     method, which converts the `std::vector` of taps to a PMT vector and posts
-     it as a message to the own message port.
-
-In both cases, the developer implements both a "native" and a "PMT" type setter,
+   - Having a `private` thread-unsafe native setter
+     `set_taps_unsafe(std::vector<tap_t>)`; acquiring the `block::d_setlock`
+     mutex in a `public` setter `set_taps(std::vector<tap_t>)` and in the
+     critical part of `work` and a PMT-accepting setter `set_taps(const
+     pmt_t&)`, both calling the thread-unsafe native setter. Register the
+     PMT-accepting setter as message handler.
+   - Implementing and registering a `private` message handler method
+     `set_taps(const pmt_t&)`, which accepts a PMT, extracts the native type
+     from the that and is called by GNU Radio only when `work` is not currently
+     running. Implement a native setter `set_taps(std::vector<tap_t>)` method,
+     which converts the `std::vector` of taps to a PMT vector and posts it as a
+     message to the own message port. 
+
+In both cases, the developer implements *both* a "native" and a "PMT" type setter,
 with one just being boilerplate code invoking the other. Both options have their
 potential performance downsides, with overly coarse granularity, i.e. `work`
 call granularity, in case of the message handler, or a mutex acquisition
@@ -86,13 +89,13 @@ Add a protected `std::unordered_set<gr::property_setter> sensitivity_list`
 member to `gr::sync_block` (later extension to `gr::block` nonwithstanding).
 
 The set contains elements of a yet to be implemented type `gr::property_setter`.
-Its constructor takes a `const std::string& key` as well as a reference to a
+Its constructor takes a `const std::string& key` as well as a
 `std::function<bool(const type_of_property&)> underlying_setter`. It has an
 `operator(const type_of_property&)`, which actually calls the thread-unsafe
 setter. Furthermore, it has an `operator(const pmt_t&)`, which automatically
 converts the PMT to the field type prior to setting the field. The hashing and
 comparison methods necessary for `unordered_set` of the type are delegated to
-the PMT  `pmt::symbol(key)`.
+the PMT `pmt::symbol(key)`.
 
 If `sensitivity_list` is not empty, the GNU Radio scheduling algorithm
 (`run_one_iteration`), instead of directly calling into work, looks only for the
@@ -137,7 +140,7 @@ class sensitive_blk_impl : public sensitive_blk
 };
 ```
 
-    ## #Proposed Implementation of Types
+### Proposed Implementation of Types
 
 ```c++ namespace gnuradio::gr
 {
@@ -169,13 +172,13 @@ class sensitive_blk_impl : public sensitive_blk
                                                    setter_type underlying_setter)
             : property_setter(owner, key), setter(underlying_setter)
         {
-            owner->set_msg_handler([](const pmt_t& val) { this->operator(val); });
+            owner->set_msg_handler([](const pmt_t& val) { this->operator()(val); });
         }
 
         bool operator(const property_type& value) const
         {
             if (!setter(value)) {
-            GR_LOG_WARN(owner->d_logger, key + " property_setter: failed setting"
+                owner->d_logger->warn("{} property_setter: failed setting", key);
                 return false;
             }
             return true;
@@ -185,6 +188,7 @@ class sensitive_blk_impl : public sensitive_blk
         // int…
         // Most elegant would be to have a templated pmt_basic::to<target_type>()
         // operator?
+        // Does pmtf solve this?
         /*
         bool operator(const pmt::pmt_t& polymorph) const
         {