bricks-internal (empty) → 0.0.0.4

raw patch · 8 files changed

+394/−0 lines, 8 filesdep +basedep +containersdep +doctest

Dependencies added: base, containers, doctest, either-list-functions, text

Files

• bricks-internal.cabal +59/−0
• license.txt +13/−0
• src/Bricks/Internal/List.hs +50/−0
• src/Bricks/Internal/Map.hs +48/−0
• src/Bricks/Internal/Prelude.hs +57/−0
• src/Bricks/Internal/Seq.hs +109/−0
• src/Bricks/Internal/Text.hs +54/−0
• test/doctest.hs +4/−0

@@ -0,0 +1,59 @@+-- This file has been generated from package.yaml by hpack version 0.20.0.+--+-- see: https://github.com/sol/hpack+--+-- hash: 0ab2b6bce3c64bf68bd6f56a735318f614ddcd80c2bc0ca7a0422d985e01cb38++name:           bricks-internal+version:        0.0.0.4+synopsis:       ...++description:    ...+category:       Language+homepage:       https://github.com/chris-martin/bricks#readme+bug-reports:    https://github.com/chris-martin/bricks/issues+author:         Chris Martin <ch.martin@gmail.com>+maintainer:     Chris Martin <ch.martin@gmail.com>+license:        Apache-2.0+license-file:   license.txt+build-type:     Simple+cabal-version:  >= 1.10++source-repository head+  type: git+  location: https://github.com/chris-martin/bricks++library+  hs-source-dirs:+      src+  ghc-options: -Wall+  build-depends:+      base >=4.9 && <4.11+    , containers >=0.5.7 && <0.6+    , either-list-functions ==0.0.0.2+    , text >=1.2.2 && <1.3+  exposed-modules:+      Bricks.Internal.List+      Bricks.Internal.Map+      Bricks.Internal.Prelude+      Bricks.Internal.Seq+      Bricks.Internal.Text+  other-modules:+      Paths_bricks_internal+  default-language: Haskell2010++test-suite doctest+  type: exitcode-stdio-1.0+  main-is: doctest.hs+  hs-source-dirs:+      test+  ghc-options: -Wall -threaded+  build-depends:+      base >=4.9 && <4.11+    , containers >=0.5.7 && <0.6+    , doctest >=0.11 && <0.14+    , either-list-functions ==0.0.0.2+    , text >=1.2.2 && <1.3+  other-modules:+      Paths_bricks_internal+  default-language: Haskell2010

@@ -0,0 +1,13 @@+Copyright 2017 Chris Martin++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.

@@ -0,0 +1,50 @@+{-# LANGUAGE LambdaCase        #-}+{-# LANGUAGE NoImplicitPrelude #-}++module Bricks.Internal.List++  ( module Data.List+  , module Data.List.EitherFunctions++  , minimum, maximum++  ) where++-- either-list-functions+import Data.List.EitherFunctions++-- base+import           Data.List  hiding (maximum, minimum)+import qualified Data.List  as List+import           Data.Maybe (Maybe (..))+import           Data.Ord   (Ord (..))++{- |++>>> minimum [1,2,3]+Just 1++>>> minimum []+Nothing++-}+minimum :: Ord a => [a] -> Maybe a+minimum =+  \case+    [] -> Nothing+    xs -> Just (List.minimum xs)++{- |++>>> maximum [1,2,3]+Just 3++>>> maximum []+Nothing++-}+maximum :: Ord a => [a] -> Maybe a+maximum =+  \case+    [] -> Nothing+    xs -> Just (List.maximum xs)

@@ -0,0 +1,48 @@+module Bricks.Internal.Map+  ( module Data.Map++  , exactKeys+  , restrictKeys++  ) where++-- Containers+import           Data.Map hiding (restrictKeys)+import           Data.Set (Set)+import qualified Data.Set as Set++{- | This function was added in containers version 0.5.8 which we're not using+yet. -}++restrictKeys :: Ord k => Map k a -> Set k -> Map k a+m `restrictKeys` s = filterWithKey (\k _ -> k `Set.member` s) m++{- | If @s@ is a subset of the keys in @m@ then++> m exactKeys s = Right (m `restrictKeys` s)++Otherwise, @m exactKeys s = Left s'@ where @s'@ is the keys that are missing+from @m@. -}++-- | ==== Examples+--+-- >>> :{+-- >>> fromList [('a', 1), ('b', 2), ('c', 3)]+-- >>>   `exactKeys` Set.fromList ['a', 'b']+-- >>> :}+-- Right (fromList [('a',1),('b',2)])+--+-- >>> :{+-- >>> fromList [('a', 1), ('b', 2), ('c', 3)]+-- >>>   `exactKeys` Set.fromList ['a', 'x', 'y']+-- >>> :}+-- Left (fromList "xy")++exactKeys :: Ord k => Map k a -> Set k -> Either (Set k) (Map k a)+m `exactKeys` s =+  let+    s' = s `Set.difference` keysSet m+  in+    if Set.null s'+    then Right (m `restrictKeys` s)+    else Left s'

@@ -0,0 +1,57 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Bricks.Internal.Prelude++  ( (<&>)++  , module Control.Applicative+  , module Control.Arrow+  , module Control.Monad+  , module Data.Bool+  , module Data.Char+  , module Data.Either+  , module Data.Eq+  , module Data.Foldable+  , module Data.Function+  , module Data.Functor+  , module Data.Maybe+  , module Data.Monoid+  , module Data.Ord+  , module Data.Semigroup+  , module Data.String+  , module Data.Traversable+  , module Data.Tuple+  , module GHC.Stack+  , module Numeric.Natural+  , module Prelude+  , module Text.Show++  ) where++import Control.Applicative (Applicative, pure, (*>), (<*), (<*>), (<|>))+import Control.Arrow       ((>>>))+import Control.Monad       (Monad, (<=<), (=<<), (>=>), (>>=))+import Data.Bool           (Bool (False, True), not, (&&), (||))+import Data.Char           (Char)+import Data.Either         (Either (..), either)+import Data.Eq             (Eq ((/=), (==)))+import Data.Foldable       (asum, fold, foldMap, foldl, foldl1, foldr, foldr1,+                            for_, traverse_)+import Data.Function       (const, flip, id, ($), (&), (.))+import Data.Functor        (Functor, fmap, void, ($>), (<$), (<$>))+import Data.Maybe          (Maybe (Just, Nothing), catMaybes, isJust, isNothing,+                            maybe)+import Data.Monoid         (Monoid (mappend, mempty))+import Data.Ord            (Ord (..))+import Data.Semigroup      (Semigroup ((<>)))+import Data.String         (String)+import Data.Traversable    (traverse)+import Data.Tuple          (fst, snd)+import GHC.Stack           (HasCallStack)+import Numeric.Natural     (Natural)+import Prelude             (undefined)+import Text.Show           (Show (show, showList, showsPrec), shows)++(<&>) :: Functor f => f a -> (a -> b) -> f b+(<&>) = flip fmap+infixl 1 <&>

@@ -0,0 +1,109 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Bricks.Internal.Seq++  ( Seq++  , (<|), (|>)++  , adjust+  , adjustLast+  , append+  , concat+  , concatMap+  , dropWhileL+  , dropWhileR+  , empty+  , filter+  , fromList+  , intersperse+  , length+  , map+  , minimum+  , maximum+  , null+  , toList+  , trimWhile+  , singleton++  ) where++-- Containers+import Data.Sequence (Seq, adjust, dropWhileL, dropWhileR, empty, filter,+                      fromList, length, null, singleton, (<|), (><), (|>))++-- Base+import           Data.Bool     (Bool (..))+import           Data.Foldable (Foldable)+import qualified Data.Foldable as Foldable+import           Data.Functor  (fmap)+import qualified Data.List     as List+import           Data.Maybe    (Maybe (..))+import           Data.Ord      (Ord)+import           Prelude       (Num (..))++-- | Alias for '><'.+append :: Seq a -> Seq a -> Seq a+append = (><)++-- | Like 'List.intersperse', but for 'Seq'.+intersperse :: a -> Seq a -> Seq a+intersperse x xs =+  fromList (List.intersperse x (Foldable.toList xs))++-- | 'Foldable.fold' specialized for 'Seq'.+concat :: Foldable f => f (Seq a) -> Seq a+concat = Foldable.fold++-- | Like 'Foldable.concatMap', but for 'Seq'.+concatMap :: Foldable f => (a -> Seq b) -> f a -> Seq b+concatMap f xs = concat (fmap f (Foldable.toList xs))++{- |++>>> minimum (fromList [1,2,3])+Just 1++>>> minimum empty+Nothing++-}+minimum :: Ord a => Seq a -> Maybe a+minimum xs =+  if null xs then Nothing else Just (List.minimum (Foldable.toList xs))++{- |++>>> maximum (fromList [1,2,3])+Just 3++>>> maximum empty+Nothing++-}+maximum :: Ord a => Seq a -> Maybe a+maximum xs =+  if null xs then Nothing else Just (List.maximum (Foldable.toList xs))++-- | Specialization of 'fmap'.+map :: (a -> b) -> Seq a -> Seq b+map = fmap++-- | Specialization of 'Foldable.toList' for 'Seq'.+toList :: Seq a -> [a]+toList = Foldable.toList++{- |++>>> adjustLast (+ 1) (fromList [1, 2, 3])+fromList [1,2,4]++>>> adjustLast (+ 1) empty+fromList []++-}+adjustLast :: (a -> a) -> Seq a -> Seq a+adjustLast f xs = adjust f (length xs - 1) xs++trimWhile :: (a -> Bool) -> Seq a -> Seq a+trimWhile f xs = dropWhileL f (dropWhileR f xs)

@@ -0,0 +1,54 @@+{-# LANGUAGE NoImplicitPrelude #-}++module Bricks.Internal.Text++  ( Text++  , all+  , append+  , concat+  , concatMap+  , intercalate+  , intercalateMap+  , isPrefixOf+  , isSuffixOf+  , null+  , pack+  , replace+  , replicate+  , show+  , singleton+  , unpack+  , unwords++  ) where++-- Text+import           Data.Text (Text, all, append, isPrefixOf, isSuffixOf, null,+                            pack, replace, replicate, singleton, unpack,+                            unwords)+import qualified Data.Text as Text++-- Base+import           Data.Foldable (Foldable, foldr, toList)+import           Data.Function ((.))+import           Data.Functor  (Functor, fmap)+import qualified Text.Show++concat :: Foldable f => f Text -> Text+concat =+  Text.concat . toList++concatMap :: Foldable f => (a -> Text) -> f a -> Text+concatMap f = foldr (append . f) Text.empty++intercalate :: Foldable f => Text -> f Text -> Text+intercalate x =+  Text.intercalate x . toList++intercalateMap :: (Foldable f, Functor f) => Text -> (a -> Text) -> f a -> Text+intercalateMap i f =+  intercalate i . fmap f++show :: Text.Show.Show a => a -> Text+show = Text.pack . Text.Show.show

@@ -0,0 +1,4 @@+import Test.DocTest (doctest)++main :: IO ()+main = doctest ["src", "-XOverloadedStrings"]