diff --git a/LICENSE b/LICENSE deleted file mode 100644 --- a/LICENSE +++ /dev/null @@ -1,30 +0,0 @@ -Copyright (c) 2013, Chris Done - -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following - disclaimer in the documentation and/or other materials provided - with the distribution. - - * Neither the name of Chris Done nor the names of other - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/data-extra.cabal b/data-extra.cabal --- a/data-extra.cabal +++ b/data-extra.cabal @@ -1,32 +1,9 @@ name: data-extra -version: 2.5.4 -synopsis: Extra utilities for working on Data.* types. -description: Extra utilities for working on Data.* types. +version: 2.5.5 +synopsis: None +description: None license: BSD3 -license-file: LICENSE -author: Chris Done, Sam Levy -maintainer: chrisdone@gmail.com -copyright: 2013 Chris Done -category: Data +author: None build-type: Simple -cabal-version: >=1.8 - +cabal-version: >=1.2 library - exposed-modules: Data.Extra, - Data.Either.Extra, - Data.Maybe.Extra, - Data.Bool.Extra, - Data.List.Extra, - Data.String.Extra, - Data.Text.Extra, - Data.Number.Extra, - Data.Time.Extra, - Data.Tuple.Extra, - Data.Eq.Extra - hs-source-dirs: src/ - build-depends: base > 4 && <5, - text, - old-locale, - time, - mtl - ghc-options: -Wall diff --git a/src/Data/Bool/Extra.hs b/src/Data/Bool/Extra.hs deleted file mode 100644 --- a/src/Data/Bool/Extra.hs +++ /dev/null @@ -1,14 +0,0 @@ --- | Extra functions for dealing with Bool. - -module Data.Bool.Extra - (bool - ,cond) - where - --- | bool false true p = if p then true else false -bool :: a -> a -> Bool -> a -bool false true p = if p then true else false - --- | cond false true p v = if p v then true v else false v -cond :: (a -> b) -> (a -> b) -> (a -> Bool) -> a -> b -cond false true p v = if p v then true v else false v diff --git a/src/Data/Either/Extra.hs b/src/Data/Either/Extra.hs deleted file mode 100644 --- a/src/Data/Either/Extra.hs +++ /dev/null @@ -1,45 +0,0 @@ --- | Extra functions for dealing with Either. - -module Data.Either.Extra where - --- | A map for Either values. -mapEither :: (a -> b1) -> (b -> b2) -> Either a b -> Either b1 b2 -mapEither l r = either (Left . l) (Right . r) - --- | Maybe get the left side of an Either. -leftToMaybe :: Either a b -> Maybe a -leftToMaybe = either Just (const Nothing) - --- | Maybe get the right side of an Either. -rightToMaybe :: Either a b -> Maybe b -rightToMaybe = either (const Nothing) Just - --- | Is a value Left? -isLeft :: Either a b -> Bool -isLeft (Left _) = True -isLeft (Right _) = False - --- | Is a value Right? -isRight :: Either a b -> Bool -isRight (Left _) = False -isRight (Right _) = True - --- | Extract the left value or a default. -fromLeft :: a -> Either a b -> a -fromLeft _ (Left x) = x -fromLeft x _ = x - --- | Extract the right value or a default. -fromRight :: b -> Either a b -> b -fromRight _ (Right x) = x -fromRight x _ = x - --- | When a value is Right, do something with it, monadically. -whenRight :: Monad m => Either a b -> (b -> m c) -> m () -whenRight (Right x) m = m x >> return () -whenRight _ _ = return () - --- | When a value is Left, do something with it, monadically. -whenLeft :: Monad m => Either a b -> (a -> m c) -> m () -whenLeft (Left x) m = m x >> return () -whenLeft _ _ = return () diff --git a/src/Data/Eq/Extra.hs b/src/Data/Eq/Extra.hs deleted file mode 100644 --- a/src/Data/Eq/Extra.hs +++ /dev/null @@ -1,9 +0,0 @@ --- | Extra utilities for equality. - -module Data.Eq.Extra where - -import Data.Function - --- | Apply a function before passing it to equality. -equating :: Eq b => (a -> b) -> a -> a -> Bool -equating = on (==) diff --git a/src/Data/Extra.hs b/src/Data/Extra.hs deleted file mode 100644 --- a/src/Data/Extra.hs +++ /dev/null @@ -1,38 +0,0 @@ --- | Extra Data.* functions. - -module Data.Extra - (module Data.Either - ,module Data.Either.Extra - ,module Data.Maybe - ,module Data.Maybe.Extra - ,module Data.List - ,module Data.List.Extra - ,module Data.Bool - ,module Data.Bool.Extra - ,module Data.String - ,module Data.String.Extra - ,module Data.Text.Extra - ,module Data.Time - ,module Data.Time.Extra - ,module Data.Number.Extra - ,module Data.Tuple.Extra - ,module Data.Eq.Extra - ) - where - -import Data.Either -import Data.Either.Extra -import Data.Maybe -import Data.Maybe.Extra -import Data.List -import Data.List.Extra -import Data.Bool -import Data.Bool.Extra -import Data.String -import Data.String.Extra -import Data.Text.Extra -import Data.Time -import Data.Time.Extra -import Data.Number.Extra -import Data.Tuple.Extra -import Data.Eq.Extra diff --git a/src/Data/List/Extra.hs b/src/Data/List/Extra.hs deleted file mode 100644 --- a/src/Data/List/Extra.hs +++ /dev/null @@ -1,42 +0,0 @@ --- | Extra functions for dealing with lists. - -module Data.List.Extra where - -import Control.Arrow -import Data.Bool.Extra -import Data.List -import Data.Maybe -import Data.Ord - --- | When a list is non-null, pass it to a function, otherwise use the --- default. -list :: b -> ([a] -> b) -> [a] -> b -list nil cons = cond (const nil) cons null - --- | Get the union of the given lists. -unionOf :: (Eq a) => [[a]] -> [a] -unionOf = foldr union [] - --- | Opposite of map. -for :: [a] -> (a -> b) -> [b] -for = flip map - --- | Maybe get the last element in the list. -lastToMaybe :: [a] -> Maybe a -lastToMaybe [x] = Just x -lastToMaybe (_:xs) = lastToMaybe xs -lastToMaybe [] = Nothing - --- | Return the first item of a list or something else. -firstOr :: a -> [a] -> a -firstOr n = fromMaybe n . listToMaybe - --- | Get the maximum of a list or return zero. -maxList :: (Num t, Ord t) => [t] -> t -maxList [] = 0 -maxList xs = maximum xs - --- | Sort a list using a key on each element. This implements the --- decorate-sort-undecorate paradigm, also called a Schwarzian transform. -sortByKey :: Ord b => (a -> b) -> [a] -> [a] -sortByKey f = map snd . sortBy (comparing fst) . map (f &&& id) diff --git a/src/Data/Maybe/Extra.hs b/src/Data/Maybe/Extra.hs deleted file mode 100644 --- a/src/Data/Maybe/Extra.hs +++ /dev/null @@ -1,20 +0,0 @@ --- | Extra functions for dealing with Maybe. - -module Data.Maybe.Extra where - -import Control.Monad - --- | When the predicate is true, return maybe the action's return value. -whenMaybe :: Monad m => Bool -> m a -> m (Maybe a) -whenMaybe False _ = return Nothing -whenMaybe True m = liftM Just m - --- | When a value is Just, do something with it, monadically. -whenJust :: Monad m => Maybe a -> (a -> m c) -> m () -whenJust (Just a) m = m a >> return () -whenJust _ _ = return () - --- | Return the sole element of the list or nothing. -sole :: [a] -> Maybe a -sole [x] = Just x -sole _ = Nothing diff --git a/src/Data/Number/Extra.hs b/src/Data/Number/Extra.hs deleted file mode 100644 --- a/src/Data/Number/Extra.hs +++ /dev/null @@ -1,63 +0,0 @@ --- | Extra functions for numbers. - -module Data.Number.Extra where - -{-# 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/String/Extra.hs b/src/Data/String/Extra.hs deleted file mode 100644 --- a/src/Data/String/Extra.hs +++ /dev/null @@ -1,27 +0,0 @@ -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE TypeSynonymInstances #-} - --- | Extra functions and classes for dealing with Strings. - -module Data.String.Extra where - -import Data.Char - --- | Lower case a string. -lower :: String -> String -lower = map toLower - --- | Upper case a string. -upper :: String -> String -upper = map toUpper - --- | Trim a string. -trim :: [Char] -> [Char] -trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace - --- | A class for converting to strings. -class ToString a where - toString :: a -> String - -instance ToString String where - toString = id diff --git a/src/Data/Text/Extra.hs b/src/Data/Text/Extra.hs deleted file mode 100644 --- a/src/Data/Text/Extra.hs +++ /dev/null @@ -1,56 +0,0 @@ -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE TypeSynonymInstances #-} -{-# LANGUAGE OverloadedStrings #-} - --- | Extra functions and classes for dealing with Text. - -module Data.Text.Extra where - -import Data.Number.Extra -import Data.Text -import qualified Data.Text.Lazy as L - --- | A class for converting to Text. -class ToText a where - toText :: a -> Text - toLazyText :: a -> L.Text - -instance ToText Text where - toText = id - toLazyText = L.fromStrict - -instance ToText String where - toText = pack - toLazyText = L.pack - --- | A class for converting from Text. -class FromText a where - fromText :: Text -> Maybe a - fromLazyText :: L.Text -> Maybe a - -instance FromText String where - fromText = Just . unpack - fromLazyText = Just . L.unpack - --- | Big 'em up. -bigUp :: (Integral a) => a -> Text -bigUp = go . int where - go :: Integer -> Text - go n | n < 3 = "a couple" - | n < 5 = "several" - | n < 10 = "many" - | n < 80 = "dozens" - | n < 100 = "nearly a hundred" - | n < 200 = "some hundred" - | n < 1000 = "hundreds" - | n < 10000 = "thousands" - | n < 100000 = "tens of thousands" - | n < 200000 = "a hundred thousand" - | n < 500000 = "hundreds of thousands" - | n < 500000 = "half a million" - | n < 600000 = "over half a million" - | n < 1000000 = "nearly a million" - | n < 2000000 = "over a million" - | n < (10^ (9::Int)) = "millions" - | n < 10^ (12::Int) = "billions" - | otherwise = "trillions" diff --git a/src/Data/Time/Extra.hs b/src/Data/Time/Extra.hs deleted file mode 100644 --- a/src/Data/Time/Extra.hs +++ /dev/null @@ -1,79 +0,0 @@ -{-# LANGUAGE BangPatterns #-} - --- | Extra date functions. - -module Data.Time.Extra where - -import Control.Monad.Trans -import Data.List -import Data.Text (Text,pack) -import Data.Time -import System.Locale -import Text.Printf - --- | Get the current year. -getYear :: FormatTime t => t -> Integer -getYear = read . formatTime defaultTimeLocale "%Y" - --- | Get the current month. -getMonth :: FormatTime t => t -> Integer -getMonth = read . formatTime defaultTimeLocale "%m" - --- | Get the current day. -getDay :: FormatTime t => t -> Integer -getDay = read . formatTime defaultTimeLocale "%d" - --- | Display a time span as one time relative to another. -relative :: UTCTime -- ^ The later time span. - -> UTCTime -- ^ The earlier time span. - -> Bool -- ^ Display 'in/ago'? - -> Text -- ^ Example: '3 seconds ago', 'in three days'. -relative t1 t2 fix = pack $ maybe "unknown" format $ find (\(s,_,_) -> abs span'>=s) $ reverse ranges where - minute = 60; hour = minute * 60; day = hour * 24; - week = day * 7; month = day * 30; year = month * 12 - format range = - (if fix && span'>0 then "in " else "") - ++ case range of - (_,str,0) -> str - (_,str,base) -> printf str (abs $ round (span' / base) :: Integer) - ++ (if fix && span'<0 then " ago" else "") - span' = t1 `diffUTCTime` t2 - ranges = [(0,"%d seconds",1) - ,(minute,"a minute",0) - ,(minute*2,"%d minutes",minute) - ,(minute*30,"half an hour",0) - ,(minute*31,"%d minutes",minute) - ,(hour,"an hour",0) - ,(hour*2,"%d hours",hour) - ,(hour*3,"a few hours",0) - ,(hour*4,"%d hours",hour) - ,(day,"a day",0) - ,(day*2,"%d days",day) - ,(week,"a week",0) - ,(week*2,"%d weeks",week) - ,(month,"a month",0) - ,(month*2,"%d months",month) - ,(year,"a year",0) - ,(year*2,"%d years",year) - ] - --- | Run a stop-watch at the start and end of a computation. -stopwatch :: MonadIO m => m a -> m (a,NominalDiffTime) -stopwatch computation = do - start <- liftIO $ getCurrentTime - !a <- computation - end <- liftIO $ getCurrentTime - return (a,end `diffUTCTime` start) - --- | Trivial benchmark for some monadic action. -bench :: MonadIO m => Integer -> m a -> m (a,NominalDiffTime) -bench i computation = go i (Nothing,0) where - go n (Nothing,_) = do - (a,time) <- stopwatch computation - go (n-1) (Just a,time) - go 0 (Just x,avg) = do - return (x, avg) - go n (Just _,avg) = do - (a,new) <- stopwatch computation - go (n-1) (Just a,(new + avg*cnt) / (cnt+1)) - where cnt = fromIntegral (i-n) diff --git a/src/Data/Tuple/Extra.hs b/src/Data/Tuple/Extra.hs deleted file mode 100644 --- a/src/Data/Tuple/Extra.hs +++ /dev/null @@ -1,7 +0,0 @@ --- | Tuple utilities. - -module Data.Tuple.Extra where - --- | Swap tuple's elements. -swap :: (t1, t) -> (t, t1) -swap (a,b) = (b,a)