diff --git a/src/Control/Monad/HT.hs b/src/Control/Monad/HT.hs
--- a/src/Control/Monad/HT.hs
+++ b/src/Control/Monad/HT.hs
@@ -3,6 +3,16 @@
 import Control.Monad (liftM, liftM2, )
 import Prelude hiding (repeat, until, )
 
+
+infixr 1 <=<
+
+{- |
+Also present in newer versions of the 'base' package.
+-}
+(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
+(<=<) f g = (f =<<) . g
+
+
 {- |
 Monadic 'List.repeat'.
 -}
diff --git a/src/Data/List/HT.hs b/src/Data/List/HT.hs
--- a/src/Data/List/HT.hs
+++ b/src/Data/List/HT.hs
@@ -6,6 +6,8 @@
    L.group,
    L.unzip,
    L.partition,
+   L.span,
+   L.break,
    -- * Split
    L.chop,
    L.breakAfter,
diff --git a/src/Data/List/HT/Private.hs b/src/Data/List/HT/Private.hs
--- a/src/Data/List/HT/Private.hs
+++ b/src/Data/List/HT/Private.hs
@@ -10,7 +10,7 @@
 import qualified Data.List.Key.Private   as Key
 import qualified Data.List.Match.Private as Match
 
-import Prelude hiding (unzip, )
+import Prelude hiding (unzip, break, span, )
 
 
 -- * Improved standard functions
@@ -114,7 +114,24 @@
            else (y, x : z))
       ([],[])
 
+{- |
+It is @Data.List.span f undefined = undefined@,
+whereas @span f undefined = (undefined, undefined)@.
+-}
+span, break :: (a -> Bool) -> [a] -> ([a],[a])
+span p =
+   let recourse xt =
+          forcePair $
+          fromMaybe ([],xt) $
+          do (x,xs) <- viewL xt
+             guard $ p x
+             return $ mapFst (x:) $ recourse xs
+   in  recourse
 
+break p =  span (not . p)
+
+
+
 -- * Split
 
 {- |
@@ -123,13 +140,19 @@
 This is a generalization of 'words'.
 -}
 chop :: (a -> Bool) -> [a] -> [[a]]
-chop p s =
-   let (l, s') = break p s
-   in  l : case s' of
-           [] -> []
-           (_:rest) -> chop p rest
+chop p =
+   uncurry (:) .
+   foldr (\ x ~(y,ys) -> if p x then ([],y:ys) else ((x:y),ys) ) ([],[])
 
+chop' :: (a -> Bool) -> [a] -> [[a]]
+chop' p =
+   let recourse =
+          uncurry (:) .
+          mapSnd (switchL [] (const recourse)) .
+          break p
+   in  recourse
 
+
 chopAtRun :: (Eq a) => (a -> Bool) -> [a] -> [[a]]
 chopAtRun p =
    let recourse [] = [[]]
@@ -372,6 +395,9 @@
 
 {- |
 Partition a list into elements which evaluate to @Just@ or @Nothing@ by @f@.
+
+It holds @mapMaybe f == fst . partitionMaybe f@
+and @partition p == partitionMaybe (\ x -> toMaybe (p x) x)@.
 -}
 partitionMaybe :: (a -> Maybe b) -> [a] -> ([b], [a])
 partitionMaybe f =
@@ -727,6 +753,10 @@
 isAscendingLazy :: (Ord a) => [a] -> [Bool]
 isAscendingLazy = mapAdjacent (<=)
 
+{- |
+This function combines every pair of neighbour elements
+in a list with a certain function.
+-}
 mapAdjacent :: (a -> a -> b) -> [a] -> [b]
 mapAdjacent f xs = zipWith f xs (tail xs)
 
diff --git a/src/Data/List/Key/Private.hs b/src/Data/List/Key/Private.hs
--- a/src/Data/List/Key/Private.hs
+++ b/src/Data/List/Key/Private.hs
@@ -101,10 +101,11 @@
 
 mergeBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
 mergeBy p =
-   let recourse xl@(x:xs) yl@(y:ys) =
-         if p x y
-           then x : recourse xs yl
-           else y : recourse xl ys
-       recourse [] yl = yl
+   let recourse [] yl = yl
        recourse xl [] = xl
+       recourse xl@(x:xs) yl@(y:ys) =
+         uncurry (:) $
+         if p x y
+           then (x, recourse xs yl)
+           else (y, recourse xl ys)
    in  recourse
diff --git a/src/Data/Maybe/HT.hs b/src/Data/Maybe/HT.hs
--- a/src/Data/Maybe/HT.hs
+++ b/src/Data/Maybe/HT.hs
@@ -1,8 +1,44 @@
 module Data.Maybe.HT where
 
+import Data.Maybe (fromMaybe, )
+import Control.Monad (msum, )
+
+
 {- | Returns 'Just' if the precondition is fulfilled. -}
 {-# INLINE toMaybe #-}
 toMaybe :: Bool -> a -> Maybe a
 toMaybe False _ = Nothing
 toMaybe True  x = Just x
 
+
+infixl 6 ?->
+
+{- |
+This is an infix version of 'fmap'
+for writing 'Data.Bool.HT.select' style expressions
+using test functions, that produce 'Maybe's.
+
+The precedence is chosen to be higher than '(:)',
+in order to allow:
+
+> alternatives default $
+>    checkForA ?-> (\a -> f a) :
+>    checkForB ?-> (\b -> g b) :
+>    []
+
+The operation is left associative
+in order to allow to write
+
+> checkForA ?-> f ?-> g
+
+which is equivalent to
+
+> checkForA ?-> g . f
+
+due to the functor law.
+-}
+(?->) :: Maybe a -> (a -> b) -> Maybe b
+(?->) = flip fmap
+
+alternatives :: a -> [Maybe a] -> a
+alternatives deflt = fromMaybe deflt . msum
diff --git a/src/Data/String/HT.hs b/src/Data/String/HT.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/String/HT.hs
@@ -0,0 +1,8 @@
+module Data.String.HT where
+
+import Data.Char (isSpace, )
+import Data.List.HT (dropWhileRev, )
+
+-- | remove leading and trailing spaces
+trim :: String -> String
+trim = dropWhileRev isSpace . dropWhile isSpace
diff --git a/src/Data/Tuple/HT.hs b/src/Data/Tuple/HT.hs
--- a/src/Data/Tuple/HT.hs
+++ b/src/Data/Tuple/HT.hs
@@ -2,7 +2,16 @@
 
 -- * Pair
 
--- | '(Control.Arrow.***)'
+{- | Cf. '(Control.Arrow.***)'.
+
+Apply two functions on corresponding values in a pair,
+where the pattern match on the pair constructor is lazy.
+This is crucial in recursions such as the of 'partition'.
+-}
+{-
+Instead of pattern matching with \code{(x,y)}
+we may use \function{fst} and \function{snd}.
+-}
 {-# INLINE mapPair #-}
 mapPair :: (a -> c, b -> d) -> (a,b) -> (c,d)
 mapPair ~(f,g) ~(x,y) = (f x, g y)
diff --git a/utility-ht.cabal b/utility-ht.cabal
--- a/utility-ht.cabal
+++ b/utility-ht.cabal
@@ -1,5 +1,5 @@
 Name:             utility-ht
-Version:          0.0.3
+Version:          0.0.4
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -27,7 +27,7 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/~thielema/utility/
-  tag:      0.0.3
+  tag:      0.0.4
 
 
 Library
@@ -47,6 +47,7 @@
     Data.Record.HT
     Data.Tuple.HT
     Control.Monad.HT
+    Data.String.HT
     Text.Read.HT
     Text.Show.HT
   Other-Modules: