diff --git a/data-extra.cabal b/data-extra.cabal
--- a/data-extra.cabal
+++ b/data-extra.cabal
@@ -1,10 +1,10 @@
 name:                data-extra
-version:             2.2.0
+version:             2.3.0
 synopsis:            Extra utilities for working on Data.* types.
 description:         Extra utilities for working on Data.* types.
 license:             BSD3
 license-file:        LICENSE
-author:              Chris Done
+author:              Chris Done, Sam Levy
 maintainer:          chrisdone@gmail.com
 copyright:           2013 Chris Done
 category:            Data
diff --git a/src/Data/Number/Extra.hs b/src/Data/Number/Extra.hs
--- a/src/Data/Number/Extra.hs
+++ b/src/Data/Number/Extra.hs
@@ -2,6 +2,62 @@
 
 module Data.Number.Extra where
 
--- | Shorter-hand for fromIntegral.
+{-# INLINE towardZero          #-}
+{-# INLINE towardInf           #-}
+{-# INLINE towardNegInf        #-}
+{-# INLINE awayFromZero        #-}
+{-# INLINE nearestTowardZero   #-}
+{-# INLINE nearestTowardInf    #-}
+{-# INLINE nearestTowardNegInf #-}
+{-# INLINE nearestAwayFromZero #-}
+{-# INLINE nearestBanker       #-}
+
+-- | Round toward zero (truncate).
+towardZero :: (Integral b, RealFrac a) => a -> b
+towardZero = truncate
+
+-- | Round upwards (ceiling).
+towardInf :: (Integral b, RealFrac a) => a -> b
+towardInf = ceiling
+
+-- | Round backwards (floor).
+towardNegInf :: (Integral b, RealFrac a) => a -> b
+towardNegInf = floor
+
+-- | Round away from zero (ceiling if positive, floor otherwise).
+awayFromZero :: (Integral b, RealFrac a) => a -> b
+awayFromZero v = if v > 0 then ceiling v else floor v
+
+-- | Round torwards zero (if half go towards zero, otherwise up to 1).
+nearestTowardZero :: (Integral b, RealFrac a) => a -> b
+nearestTowardZero v = if isHalf v then towardZero   v else round v
+
+-- | Same as "nearestTowardZero" but to infinity instead of zero.
+nearestTowardInf :: (Integral b, RealFrac a) => a -> b
+nearestTowardInf v = if isHalf v then towardInf    v else round v
+
+-- | Same as "nearestTowardZero" but towards negative instead of zero.
+nearestTowardNegInf :: (Integral b, RealFrac a) => a -> b
+nearestTowardNegInf v = if isHalf v then towardNegInf v else round v
+
+-- | Same as "nearestTowardZero" but rounds away from zero (by positive or negative).
+nearestAwayFromZero :: (Integral b, RealFrac a) => a -> b
+nearestAwayFromZero v = if isHalf v then awayFromZero v else round v
+
+-- | Round up (round).
+nearestBanker :: (Integral b, RealFrac a) => a -> b
+nearestBanker = round
+
+{-# INLINE fi #-}
+-- | Short-hand for fromIntegral.
+fi :: (Integral a, Num b) => a -> b
+fi = fromIntegral
+
+{-# INLINE isHalf #-}
+-- | Is a number rounded down 0.5?
+isHalf :: RealFrac a => a -> Bool
+isHalf v = v - fromInteger (towardNegInf v) == 0.5
+
+-- | Short-hand for fromIntegral. Deprecated in favour of the more popular fi.
 int :: (Integral a, Num b) => a -> b
 int = fromIntegral
diff --git a/src/Data/Tuple/Extra.hs b/src/Data/Tuple/Extra.hs
--- a/src/Data/Tuple/Extra.hs
+++ b/src/Data/Tuple/Extra.hs
@@ -1,3 +1,5 @@
+-- | Tuple utilities.
+
 module Data.Tuple.Extra where
 
 -- | Swap tuple's elements.