fix docstrings markup for docs

Author: artemisart

fn/immutable/heap.py

@@ -40,11 +40,12 @@ class SkewHeap(_MergeBased):
     done in O(log n).
 
     Skew heaps may be described with the following recursive definition:
-    * a heap with only one element is a skew heap
-    * the result of skew merging two skew heaps is also a skew heap
+     * a heap with only one element is a skew heap
+     * the result of skew merging two skew heaps is also a skew heap
 
-    In Haskell type definition it should looks like following:
-    data Skew a = Empty | Node a (Skew a) (Skew a)
+    In Haskell type definition it should looks like following::
+
+        data Skew a = Empty | Node a (Skew a) (Skew a)
 
     More information on Wikipedia:
     [1] http://en.wikipedia.org/wiki/Skew_heap
@@ -91,7 +92,7 @@ def extract(self):
         * minimum (or maximum regarding to given compare function)
         * new skew heap without extracted element
 
-        Or None and empty heap if self is an empty heap.
+        Or ``None`` and empty heap if ``self`` is an empty heap.
         """
         if not self:
             return None, self._make_heap()
@@ -121,17 +122,17 @@ class PairingHeap(_MergeBased):
     property requires that all the root elements of the subheaps in the list
     are not smaller (bigger) than the root element of the heap.
 
-    In Haskell type definition it should looks like following:
-    data Pairing a = Empty | Node a [Pairing a]
+    In Haskell type definition it should looks like following::
+
+        data Pairing a = Empty | Node a [Pairing a]
 
     Pairing heap has and excellent practical amortized performance. The
     amortized time per extract is less than O(log n), find-min/find-max, merge
     and insert are O(1).
 
     More information about performance bounds you can find here:
     "The Pairing Heap: A New Form of Self-Adjusting Heap"
-    [1]
-http://www.cs.cmu.edu/afs/cs.cmu.edu/user/sleator/www/papers/pairing-heaps.pdf
+    [1] http://www.cs.cmu.edu/afs/cs.cmu.edu/user/sleator/www/papers/pairing-heaps.pdf
 
     More general information on Wikipedia:
     [2] http://en.wikipedia.org/wiki/Pairing_heap
@@ -176,8 +177,8 @@ def insert(self, el):
 
     def extract(self):
         """Returns pair of values:
-        * minimum (or maximum regarding to given compare function)
-        * new pairing heap without extracted element
+         * minimum (or maximum regarding to given compare function)
+         * new pairing heap without extracted element
 
         Or None and empty heap if self is an empty heap.
         """

fn/monad.py

@@ -5,7 +5,7 @@
 and get rid of many ``if/else`` blocks. See usage examples below.
 
 Assume that you have ``Request`` class that gives you parameter
-value by its name. To get uppercase notation for non-empty striped value:
+value by its name. To get uppercase notation for non-empty striped value::
 
     class Request(dict):
         def parameter(self, name):
@@ -23,7 +23,7 @@ def parameter(self, name):
             fixed = param.upper()
 
 
-Hmm, looks ugly.. Update code with ``fn.monad.Option``:
+Hmm, looks ugly.. Update code with ``fn.monad.Option``::
 
     from operator import methodcaller
     from fn.monad import optionable
@@ -43,7 +43,7 @@ def parameter(self, name):
 ``fn.monad.Option.or_call`` is good method for trying several
 variant to end computation. I.e. use have ``Request`` class
 with optional attributes ``type``, ``mimetype``, ``url``.
-You need to evaluate "request type" using at least on attribute:
+You need to evaluate "request type" using at least on attribute::
 
     from fn.monad import Option
 

fn/op.py

@@ -52,11 +52,12 @@ def foldl(f, init=None):
     using passed function as reducer.
 
     Usage:
-    >>> print foldl(_ + _)([0,1,2,3,4])
-    10
-    >>> print foldl(_ * _, 1)([1,2,3])
-    6
+        >>> print foldl(_ + _)([0,1,2,3,4])
+        10
+        >>> print foldl(_ * _, 1)([1,2,3])
+        6
     """
+
     def fold(it):
         args = [f, it]
         if init is not None:
@@ -72,9 +73,10 @@ def foldr(f, init=None):
     from iterator from right-to-left).
 
     Usage:
-    >>> print foldr(call, 10)([lambda s: s**2, lambda k: k+10])
-    400
+        >>> print foldr(call, 10)([lambda s: s**2, lambda k: k+10])
+        400
     """
+
     def fold(it):
         args = [flip(f), reversed(it)]
         if init is not None:
@@ -88,15 +90,17 @@ def unfold(f):
     """Return function to unfold value into stream using
     passed function as values producer. Passed function should
     accept current cursor and should return:
+
       * tuple of two elements (value, cursor), value will be added
         to output, cursor will be used for next function call
       * None in order to stop producing sequence
 
     Usage:
-    >>> doubler = unfold(lambda x: (x*2, x*2))
-    >>> list(islice(doubler(10), 0, 10))
-    [20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240]
+        >>> doubler = unfold(lambda x: (x*2, x*2))
+        >>> list(islice(doubler(10), 0, 10))
+        [20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240]
     """
+
     def _unfolder(start):
         value, curr = None, start
         while 1:

fn/recur.py

@@ -13,13 +13,13 @@ class tco(object):
      * (func, args) or (func, kwargs) - will repeat loop with new callable
                                         and new arguments
 
-    Usage example:
+    Usage example::
 
-    @recur.tco
-    def accumulate(origin, f=operator.add, acc=0):
-        n = next(origin, None)
-        if n is None: return False, acc
-        return True, (origin, f, f(acc, n))
+        @recur.tco
+        def accumulate(origin, f=operator.add, acc=0):
+            n = next(origin, None)
+            if n is None: return False, acc
+            return True, (origin, f, f(acc, n))
 
     Idea was described on python mailing list:
     http://mail.python.org/pipermail/python-ideas/2009-May/004486.html
@@ -57,42 +57,42 @@ class stackless(object):
 
     Usage examples:
 
-    Tail call optimised recursion with tailcall():
-
-    @recur.stackless
-    def fact(n, acc=1):
-        if n == 0:
-            yield acc
-            return
-        yield fact.tailcall(n-1, n*acc)
-
-    Non-tail recursion with call() uses heap space so won't overflow:
-
-    @recur.stackless
-    def fib(n):
-        if n == 0:
-            yield 1
-            return
-        if n == 1:
-            yield 1
-            return
-        yield (yield fib.call(n-1)) + (yield fib.call(n-2))
-
-    Mutual recursion also works:
-
-    @recur.stackless
-    def is_odd(n):
-        if n == 0:
-            yield False
-            return
-        yield is_even.tailcall(n-1)
-
-    @recur.stackless
-    def is_even(n):
-        if n == 0:
-            yield True
-            return
-        yield is_odd.tailcall(n-1)
+    Tail call optimised recursion with tailcall()::
+
+        @recur.stackless
+        def fact(n, acc=1):
+            if n == 0:
+                yield acc
+                return
+            yield fact.tailcall(n-1, n*acc)
+
+    Non-tail recursion with call() uses heap space so won't overflow::
+
+        @recur.stackless
+        def fib(n):
+            if n == 0:
+                yield 1
+                return
+            if n == 1:
+                yield 1
+                return
+            yield (yield fib.call(n-1)) + (yield fib.call(n-2))
+
+    Mutual recursion also works::
+
+        @recur.stackless
+        def is_odd(n):
+            if n == 0:
+                yield False
+                return
+            yield is_even.tailcall(n-1)
+
+        @recur.stackless
+        def is_even(n):
+            if n == 0:
+                yield True
+                return
+            yield is_odd.tailcall(n-1)
 
     """