diff --git a/Util.hs b/Util.hs
--- a/Util.hs
+++ b/Util.hs
@@ -3,14 +3,17 @@
 import Control.Applicative
 import Control.Category
 import Control.Monad
+import Control.Monad.Fix
+import Control.Monad.Trans.State (state, evalState)
 import Data.Bool
 import Data.Foldable hiding (maximumBy, minimumBy)
-import Data.Function (flip)
+import Data.Function (($), flip)
 import Data.Functor.Classes
 import Data.List.NonEmpty (NonEmpty (..))
 import qualified Data.List.NonEmpty as NE
 import Data.Maybe
 import Data.Semigroup
+import Data.Tuple (snd)
 import Data.Monoid (Monoid (..))
 import Numeric.Natural
 
@@ -173,6 +176,9 @@
 iterateM 0 _ x = pure (x:|[])
 iterateM k f x = (x NE.<|) <$> (f x >>= iterateM (pred k) f)
 
+loopM :: MonadFix m => (a -> m (a, b)) -> m b
+loopM f = fmap snd . mfix $ \ (a, _) -> f a
+
 infixl 3 <|, |>
 
 (<|) :: Alternative f => a -> f a -> f a
@@ -180,3 +186,9 @@
 
 (|>) :: Alternative f => f a -> a -> f a
 xs |> x = xs <|> pure x
+
+count :: (Traversable f, Enum n) => f a -> f (n, a)
+count = countFrom (toEnum 0)
+
+countFrom :: (Traversable f, Enum n) => n -> f a -> f (n, a)
+countFrom n = flip evalState n . traverse (\ a -> state $ \ k -> ((k, a), succ k))
diff --git a/Util/Bits.hs b/Util/Bits.hs
--- a/Util/Bits.hs
+++ b/Util/Bits.hs
@@ -1,9 +1,13 @@
 module Util.Bits where
 
 import Control.Applicative
+import Control.Category
 import Data.Bits
 import Data.Bool
-import Prelude ((==), (+), fromIntegral, id)
+import Data.Foldable (Foldable (..))
+import Data.List ((++), concat, repeat, take, transpose)
+import Data.Maybe (Maybe (..), fromMaybe)
+import Prelude (($), (==), (+), (-), compare, fmap, fromIntegral)
 import qualified Prelude
 import Util
 
@@ -14,3 +18,26 @@
 setBits = altMap pure ∘ go 0
   where go n a | zeroBits == a `shiftR` fromIntegral n = []
                | True = bool id (n:) (testBit a (fromIntegral n)) (go (n+1) a)
+
+interleaveBits :: (Bits a, Bits b) => [a] -> b
+interleaveBits = fromListLE . concat . transpose . pad False . fmap toListLE
+  where
+    pad :: a -> [[a]] -> [[a]]
+    pad a₀ ass = [take l $ as ++ repeat a₀ | as <- ass]
+      where l = fromMaybe 0 $ maximumBy compare (length <$> ass)
+
+fromListLE :: Bits a => [Bool] -> a
+fromListLE = foldr (\ b a -> bool zeroBits (bit 0) b .|. shiftL a 1) zeroBits
+
+toListLE :: Bits a => a -> [Bool]
+toListLE a | Just l <- bitSizeMaybe a = testBit a <$> [0..l-1]
+           | otherwise = go a
+  where
+    go a | zeroBits == a = []
+         | otherwise = testBit a 0 : go (shiftR a 1)
+
+fromListBE :: Bits a => [Bool] -> a
+fromListBE = foldl' (\ a b -> shiftL a 1 .|. bool zeroBits (bit 0) b) zeroBits
+
+toListBE :: FiniteBits a => a -> [Bool]
+toListBE a = [testBit a (l - k) | let l = finiteBitSize a, k <- [1..l]]
diff --git a/util.cabal b/util.cabal
--- a/util.cabal
+++ b/util.cabal
@@ -1,5 +1,5 @@
 name:                util
-version:             0.1.13.0
+version:             0.1.14.0
 synopsis:            Utilities
 -- description:         
 license:             BSD3
@@ -19,10 +19,12 @@
   -- other-modules:       
   -- other-extensions:    
   build-depends:       base >=4.9 && <5
+                     , transformers >=0.0.1 && <0.6
   -- hs-source-dirs:      
   default-language:    Haskell2010
   default-extensions:  NoImplicitPrelude
                      , LambdaCase
+                     , MonadComprehensions
                      , GeneralizedNewtypeDeriving
                      , DeriveFunctor
                      , DeriveFoldable