Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 25)
+++ lemon/maps.h	(revision 26)
@@ -248,5 +248,7 @@
   /// are stored in a \c std::vector<T>  container. It can be used with
   /// some data structures, for example \c UnionFind, \c BinHeap, when 
-  /// the used items are small integer numbers.
+  /// the used items are small integer numbers. 
+  ///
+  /// \todo Revise its name
   template <typename T>
   class IntegerMap {
@@ -347,6 +349,7 @@
   
 
-  ///Convert the \c Value of a map to another type.
-
+  ///\brief Convert the \c Value of a map to another type using
+  ///the default conversion.
+  ///
   ///This \c concepts::ReadMap "read only map"
   ///converts the \c Value of a maps to type \c T.
@@ -369,6 +372,4 @@
     ///
     /// The subscript operator.
-    /// \param k The key
-    /// \return The target of the arc 
     Value operator[](const Key& k) const {return m[k];}
   };
@@ -389,4 +390,6 @@
   ///combined with simple read maps. This map adaptor wraps the given
   ///map to simple read map.
+  ///
+  /// \todo Revise the misleading name
   template<typename M> 
   class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
@@ -406,8 +409,10 @@
   ///Simple writeable wrapping of the map
 
-  ///This \c concepts::ReadMap "read only map" returns the simple
+  ///This \c concepts::WriteMap "write map" returns the simple
   ///wrapping of the given map. Sometimes the reference maps cannot be
   ///combined with simple read-write maps. This map adaptor wraps the
   ///given map to simple read-write map.
+  ///
+  /// \todo Revise the misleading name
   template<typename M> 
   class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {
@@ -494,5 +499,5 @@
   };
 
-  ///Shift a map with a constant.
+  ///Shift a map with a constant. This map is also writable.
 
   ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
@@ -550,5 +555,6 @@
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-
+  ///
+  /// \todo Revise the misleading name
   template<typename M1, typename M2> 
   class SubMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -642,5 +648,5 @@
   };
 
-  ///Scales a maps with a constant.
+  ///Scales a maps with a constant (ReadWrite version).
 
   ///This \c concepts::ReadWriteMap "read-write map" returns the value of the
@@ -859,5 +865,5 @@
   };
   
-  ///Negative value of a map
+  ///Negative value of a map (ReadWrite version)
 
   ///This \c concepts::ReadWriteMap "read-write map" returns the negative
@@ -906,16 +912,4 @@
   ///operator must be defined for it, of course.
   ///
-  ///\bug We need a unified way to handle the situation below:
-  ///\code
-  ///  struct _UnConvertible {};
-  ///  template<class A> inline A t_abs(A a) {return _UnConvertible();}
-  ///  template<> inline int t_abs<>(int n) {return abs(n);}
-  ///  template<> inline long int t_abs<>(long int n) {return labs(n);}
-  ///  template<> inline long long int t_abs<>(long long int n) {return ::llabs(n);}
-  ///  template<> inline float t_abs<>(float n) {return fabsf(n);}
-  ///  template<> inline double t_abs<>(double n) {return fabs(n);}
-  ///  template<> inline long double t_abs<>(long double n) {return fabsl(n);}
-  ///\endcode
-  
 
   template<typename M> 
@@ -1042,4 +1036,6 @@
   ///The \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
+  ///
+  /// \todo Why is it needed?
   template<typename  M1, typename M2> 
   class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -1125,5 +1121,5 @@
   };
 
-  ///Logical 'not' of a map with writing possibility
+  ///Logical 'not' of a map (ReadWrie version)
   
   ///This bool \c concepts::ReadWriteMap "read-write map" returns the 
@@ -1188,7 +1184,7 @@
   
 
-  /// \brief Writable bool map for store each true assigned elements.
-  ///
-  /// Writable bool map to store each true assigned elements. It will
+  /// \brief Writable bool map for logging each true assigned elements
+  ///
+  /// Writable bool map for logging each true assigned elements, i.e it
   /// copies all the keys set to true to the given iterator.
   ///
@@ -1196,5 +1192,6 @@
   /// for each element.
   ///
-  /// The next example shows how can you write the nodes directly
+  /// The following example shows how you can write the edges found by the Prim
+  /// algorithm directly
   /// to the standard output.
   ///\code
@@ -1210,4 +1207,6 @@
   /// prim(graph, cost, writerMap);
   ///\endcode
+  ///
+  ///\todo Revise the name of this class and the relates ones.
   template <typename _Iterator, 
             typename _Functor =
@@ -1227,10 +1226,10 @@
       : _begin(it), _end(it), _functor(functor) {}
 
-    /// Gives back the given iterator set for the first time.
+    /// Gives back the given iterator set for the first key
     Iterator begin() const {
       return _begin;
     }
  
-    /// Gives back the iterator after the last set operation.
+    /// Gives back the the 'after the last' iterator
     Iterator end() const {
       return _end;
@@ -1250,12 +1249,12 @@
   };
 
-  /// \brief Writable bool map for store each true assigned elements in 
-  /// a back insertable container.
-  ///
-  /// Writable bool map for store each true assigned elements in a back 
-  /// insertable container. It will push back all the keys set to true into
-  /// the container. It can be used to retrieve the items into a standard
-  /// container. The next example shows how can you store the undirected
-  /// arcs in a vector with prim algorithm.
+  /// \brief Writable bool map for logging each true assigned elements in 
+  /// a back insertable container
+  ///
+  /// Writable bool map for logging each true assigned elements by pushing
+  /// back them into a back insertable container.
+  /// It can be used to retrieve the items into a standard
+  /// container. The next example shows how you can store the
+  /// edges found by the Prim algorithm in a vector.
   ///
   ///\code
@@ -1289,8 +1288,8 @@
   };
 
-  /// \brief Writable bool map for store each true assigned elements in 
+  /// \brief Writable bool map for storing each true assignments in 
   /// a front insertable container.
   ///
-  /// Writable bool map for store each true assigned elements in a front 
+  /// Writable bool map for storing each true assignment in a front 
   /// insertable container. It will push front all the keys set to \c true into
   /// the container. For example see the BackInserterBoolMap.
@@ -1320,10 +1319,12 @@
   };
 
-  /// \brief Writable bool map for store each true assigned elements in 
+  /// \brief Writable bool map for storing each true assigned elements in 
   /// an insertable container.
   ///
-  /// Writable bool map for store each true assigned elements in an 
+  /// Writable bool map for storing each true assigned elements in an 
   /// insertable container. It will insert all the keys set to \c true into
-  /// the container. If you want to store the cut arcs of the strongly
+  /// the container.
+  ///
+  /// For example, if you want to store the cut arcs of the strongly
   /// connected components in a set you can use the next code:
   ///
@@ -1370,5 +1371,5 @@
   /// the container.
   ///
-  /// The next code finds the connected components of the undirected digraph
+  /// The following code finds the connected components of a graph
   /// and stores it in the \c comp map:
   ///\code
@@ -1418,5 +1419,5 @@
     } 
 
-    /// Setter function of the map
+    /// Set function of the map
     void set(const Key& key, Value value) {
       if (value) {
@@ -1431,9 +1432,10 @@
 
 
-  /// \brief Writable bool map which stores for each true assigned elements  
-  /// the setting order number.
-  ///
+  /// \brief Writable bool map which stores the sequence number of 
+  /// true assignments.  
+  /// 
   /// Writable bool map which stores for each true assigned elements  
-  /// the setting order number. It make easy to calculate the leaving
+  /// the sequence number of this setting.
+  /// It makes it easy to calculate the leaving
   /// order of the nodes in the \c Dfs algorithm.
   ///
@@ -1454,7 +1456,7 @@
   ///\endcode
   ///
-  /// The discovering order can be stored a little harder because the
+  /// The storing of the discovering order is more difficult because the
   /// ReachedMap should be readable in the dfs algorithm but the setting
-  /// order map is not readable. Now we should use the fork map:
+  /// order map is not readable. Thus we must use the fork map:
   ///
   ///\code
