Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 1540)
+++ lemon/graph_utils.h	(revision 1547)
@@ -194,5 +194,5 @@
   /// \brief Copy a map.
   ///
-  /// Thsi function copies the \c source map to the \c target map. It uses the
+  /// This function copies the \c source map to the \c target map. It uses the
   /// given iterator to iterate on the data structure and it uses the \c ref
   /// mapping to convert the source's keys to the target's keys.
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1449)
+++ lemon/kruskal.h	(revision 1547)
@@ -46,5 +46,5 @@
 
   /// This function runs Kruskal's algorithm to find a minimum cost tree.
-  /// \param G The graph the algorithm runs on. The algorithm considers the
+  /// \param g The graph the algorithm runs on. The algorithm considers the
   /// graph to be undirected, the direction of the edges are not used.
   ///
@@ -77,5 +77,5 @@
   template <class GR, class IN, class OUT>
   typename IN::value_type::second_type
-  kruskal(GR const& G, IN const& in, 
+  kruskal(GR const& g, IN const& in, 
 		 OUT& out)
   {
@@ -84,5 +84,5 @@
     typedef typename GR::Node Node;
 
-    NodeIntMap comp(G, -1);
+    NodeIntMap comp(g, -1);
     UnionFind<Node,NodeIntMap> uf(comp); 
       
@@ -90,6 +90,6 @@
     for (typename IN::const_iterator p = in.begin(); 
 	 p!=in.end(); ++p ) {
-      if ( uf.join(G.target((*p).first),
-		   G.source((*p).first)) ) {
+      if ( uf.join(g.target((*p).first),
+		   g.source((*p).first)) ) {
 	out.set((*p).first, true);
 	tot_cost += (*p).second;
@@ -110,5 +110,5 @@
   ///
   /// A typical examle is the following call:
-  /// <tt>kruskal(G, some_input, makeSequenceOutput(iterator))</tt>.
+  /// <tt>kruskal(g, some_input, makeSequenceOutput(iterator))</tt>.
   /// Here, the third argument is a temporary object (which wraps around an
   /// iterator with a writable bool map interface), and thus by rules of C++
@@ -131,8 +131,8 @@
   inline
   typename IN::value_type::second_type
-  kruskal(GR const& G, IN const& edges, OUT const& out_map)
+  kruskal(GR const& g, IN const& edges, OUT const& out_map)
   {
     NonConstMapWr<OUT> map_wr(out_map);
-    return kruskal(G, edges, map_wr);
+    return kruskal(g, edges, map_wr);
   }  
 
@@ -176,7 +176,7 @@
     template<class _GR>
     typename enable_if<typename _GR::UndirTag,void>::type
-    fillWithEdges(const _GR& G, const Map& m,dummy<0> = 0) 
+    fillWithEdges(const _GR& g, const Map& m,dummy<0> = 0) 
     {
-      for(typename GR::UndirEdgeIt e(G);e!=INVALID;++e) 
+      for(typename GR::UndirEdgeIt e(g);e!=INVALID;++e) 
 	push_back(value_type(typename GR::Edge(e,true), m[e]));
     }
@@ -184,7 +184,7 @@
     template<class _GR>
     typename disable_if<typename _GR::UndirTag,void>::type
-    fillWithEdges(const _GR& G, const Map& m,dummy<1> = 1) 
+    fillWithEdges(const _GR& g, const Map& m,dummy<1> = 1) 
     {
-      for(typename GR::EdgeIt e(G);e!=INVALID;++e) 
+      for(typename GR::EdgeIt e(g);e!=INVALID;++e) 
 	push_back(value_type(e, m[e]));
     }
@@ -197,6 +197,6 @@
     }
 
-    KruskalMapInput(GR const& G, Map const& m) {
-      fillWithEdges(G,m); 
+    KruskalMapInput(GR const& g, Map const& m) {
+      fillWithEdges(g,m); 
       sort();
     }
@@ -212,5 +212,5 @@
   /// want to use the function kruskalEdgeMap() instead.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param m An edge map containing the cost of the edges.
   ///\par
@@ -224,7 +224,7 @@
   template<class GR, class Map>
   inline
-  KruskalMapInput<GR,Map> makeKruskalMapInput(const GR &G,const Map &m)
+  KruskalMapInput<GR,Map> makeKruskalMapInput(const GR &g,const Map &m)
   {
-    return KruskalMapInput<GR,Map>(G,m);
+    return KruskalMapInput<GR,Map>(g,m);
   }
   
@@ -292,5 +292,5 @@
   /// Input is from an edge map, output is a plain bool map.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param in An edge map containing the cost of the edges.
   ///\par
@@ -311,9 +311,9 @@
   inline
   typename IN::Value
-  kruskalEdgeMap(GR const& G,
+  kruskalEdgeMap(GR const& g,
 		 IN const& in,
 		 RET &out) {
-    return kruskal(G,
-		   KruskalMapInput<GR,IN>(G,in),
+    return kruskal(g,
+		   KruskalMapInput<GR,IN>(g,in),
 		   out);
   }
@@ -325,5 +325,5 @@
   /// Input is from an edge map, output is an STL Sequence.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param in An edge map containing the cost of the edges.
   ///\par
@@ -336,15 +336,15 @@
   /// <tt>GR::Edge</tt> as its <tt>value_type</tt>.
   /// The algorithm copies the elements of the found tree into this sequence.
-  /// For example, if we know that the spanning tree of the graph \c G has
+  /// For example, if we know that the spanning tree of the graph \c g has
   /// say 53 edges then
   /// we can put its edges into a STL vector \c tree with a code like this.
   /// \code
   /// std::vector<Edge> tree(53);
-  /// kruskalEdgeMap_IteratorOut(G,cost,tree.begin());
+  /// kruskalEdgeMap_IteratorOut(g,cost,tree.begin());
   /// \endcode
   /// Or if we don't know in advance the size of the tree, we can write this.
   /// \code
   /// std::vector<Edge> tree;
-  /// kruskalEdgeMap_IteratorOut(G,cost,std::back_inserter(tree));
+  /// kruskalEdgeMap_IteratorOut(g,cost,std::back_inserter(tree));
   /// \endcode
   ///
@@ -356,10 +356,10 @@
   inline
   typename IN::Value
-  kruskalEdgeMap_IteratorOut(const GR& G,
+  kruskalEdgeMap_IteratorOut(const GR& g,
 			     const IN& in,
 			     RET out)
   {
     KruskalSequenceOutput<RET> _out(out);
-    return kruskal(G, KruskalMapInput<GR,IN>(G, in), _out);
+    return kruskal(g, KruskalMapInput<GR,IN>(g, in), _out);
   }
 
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1537)
+++ lemon/maps.h	(revision 1547)
@@ -222,11 +222,9 @@
   };
 
-  ///Convert the \c Value of a maps to another type.
+  ///Convert the \c Value of a map to another type.
 
   ///This \ref concept::ReadMap "read only map"
   ///converts the \c Value of a maps to type \c T.
-  ///Its \c Value is inherited from \c M.
-  ///
-  ///\bug wrong documentation
+  ///Its \c Key is inherited from \c M.
   template<class M, class T> 
   class ConvertMap {
@@ -305,5 +303,5 @@
   }
 
-  ///Shift a maps with a constant.
+  ///Shift a map with a constant.
 
   ///This \ref concept::ReadMap "read only map" returns the sum of the
@@ -315,5 +313,5 @@
   ///  ShiftMap<X> sh(x,v);
   ///\endcode
-  ///it is equivalent with
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
@@ -356,5 +354,5 @@
 
   ///This \ref concept::ReadMap "read only map" returns the difference
-  ///of the values returned by the two
+  ///of the values of the two
   ///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.
@@ -392,5 +390,5 @@
 
   ///This \ref concept::ReadMap "read only map" returns the product of the
-  ///values returned by the two
+  ///values of the two
   ///given
   ///maps. Its \c Key and \c Value will be inherited from \c M1.
@@ -425,8 +423,8 @@
   }
  
-  ///Scale a maps with a constant.
+  ///Scales a maps with a constant.
 
   ///This \ref concept::ReadMap "read only map" returns the value of the
-  ///given map multipied with a constant value.
+  ///given map multiplied with a constant value.
   ///Its \c Key and \c Value is inherited from \c M.
   ///
@@ -435,5 +433,5 @@
   ///  ScaleMap<X> sc(x,v);
   ///\endcode
-  ///it is equivalent with
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
@@ -476,5 +474,5 @@
 
   ///This \ref concept::ReadMap "read only map" returns the quotient of the
-  ///values returned by the two
+  ///values of the two
   ///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.
@@ -553,12 +551,12 @@
   }
   
-  ///Combine of two maps using an STL (binary) functor.
-
-  ///Combine of two maps using an STL (binary) functor.
-  ///
-  ///
-  ///This \ref concept::ReadMap "read only map" takes to maps and a
+  ///Combines of two maps using an STL (binary) functor.
+
+  ///Combines of two maps using an STL (binary) functor.
+  ///
+  ///
+  ///This \ref concept::ReadMap "read only map" takes two maps and a
   ///binary functor and returns the composition of
-  ///two
+  ///the two
   ///given maps unsing the functor. 
   ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
@@ -790,5 +788,5 @@
 
 
-  ///Apply all map setting operations to two maps
+  ///Applies all map setting operations to two maps
 
   ///This map has two \ref concept::WriteMap "writable map"
