diff --git a/src/Control/Functor/HT.hs b/src/Control/Functor/HT.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Functor/HT.hs
@@ -0,0 +1,4 @@
+module Control.Functor.HT where
+
+void :: Functor f => f a -> f ()
+void = fmap (const ())
diff --git a/src/Data/Function/HT/Private.hs b/src/Data/Function/HT/Private.hs
--- a/src/Data/Function/HT/Private.hs
+++ b/src/Data/Function/HT/Private.hs
@@ -43,12 +43,3 @@
 
 powerAssociative1 op a0 a n =
    foldr op a0 (genericReplicate n a)
-
-
-infixl 0 $%
-
-{- |
-Flipped version of '($)'.
--}
-($%) :: a -> (a -> b) -> b
-($%) = flip ($)
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
@@ -54,6 +54,7 @@
    L.padRight,
    L.iterateAssociative,
    L.iterateLeaky,
+   L.lengthAtLeast,
    ) where
 
 import qualified Data.List.HT.Private as L
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
@@ -772,6 +772,12 @@
 -}
 
 
+lengthAtLeast :: Int -> [a] -> Bool
+lengthAtLeast n =
+   if n<=0
+     then const False
+     else not . null . drop (n-1)
+
 {-
 Iterate until elements start to cycle.
 This implementation is inspired by Elements of Programming
diff --git a/src/Data/List/Match/Private.hs b/src/Data/List/Match/Private.hs
--- a/src/Data/List/Match/Private.hs
+++ b/src/Data/List/Match/Private.hs
@@ -7,6 +7,8 @@
 
 import qualified Data.List as List
 
+import Control.Functor.HT (void, )
+
 import Prelude hiding (take, drop, splitAt, replicate, )
 
 
@@ -72,19 +74,19 @@
 but more efficient.
 -}
 compareLength :: [a] -> [b] -> Ordering
-compareLength (_:xs) (_:ys) = compareLength xs ys
-compareLength []     []     = EQ
-compareLength (_:_)  []     = GT
-compareLength []     (_:_)  = LT
+compareLength xs ys =
+   compare (void xs) (void ys)
 
-{- | efficient like compareLength, but without pattern matching -}
+{- | this one uses explicit recursion -}
 compareLength0 :: [a] -> [b] -> Ordering
-compareLength0 xs ys =
-   let boolList zs = replicate zs True ++ repeat False
-   -- we rely in the order of Bool constructors False and True here
-   in  uncurry compare (head
-          (dropWhile (uncurry (&&)) (zip (boolList xs) (boolList ys))))
+compareLength0 =
+   let recourse (_:xs) (_:ys) = recourse xs ys
+       recourse []     []     = EQ
+       recourse (_:_)  []     = GT
+       recourse []     (_:_)  = LT
+   in  recourse
 
+{- | strict comparison -}
 compareLength1 :: [a] -> [b] -> Ordering
 compareLength1 xs ys =
    compare (length xs) (length ys)
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.7.1
+Version:          0.0.8
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -19,7 +19,8 @@
   However, further splitting the base package might invalidate this statement.
   .
   Alternative packages: @Useful@, @MissingH@
-Tested-With:       GHC==6.8.2, GHC==6.10.4, GHC==6.12.3, GHC==7.0.2
+Tested-With:       GHC==6.8.2, GHC==6.10.4, GHC==6.12.3
+Tested-With:       GHC==7.0.2, GHC==7.2.2
 Cabal-Version:     >=1.10
 Build-Type:        Simple
 
@@ -39,7 +40,7 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/~thielema/utility/
-  tag:      0.0.7.1
+  tag:      0.0.8
 
 Library
   Build-Depends:
@@ -63,6 +64,7 @@
     Data.String.HT
     Data.Tuple.HT
     Control.Monad.HT
+    Control.Functor.HT
     Data.Strictness.HT
     Text.Read.HT
     Text.Show.HT