-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Utilities for filtering
--   
--   Some helpers to make using Prelude.filter and similar value selection
--   a bit easier. Includes combinators for predicates as well as an
--   operator to match the constructor used for the given value.
@package data-filter
@version 0.1.0.0


-- | Some helpers to make using Prelude.filter and similar value selection
--   a bit easier. Includes combinators for predicates as well as an
--   operator to match the constructor used for the given value.
module Data.Filter

-- | Retrieve the constructor name of the given value as a string. This
--   implementation is taken from
--   <a>https://stackoverflow.com/questions/48179380/getting-the-data-constructor-name-as-a-string-using-ghc-generics</a>
--   .
constrName :: (HasConstructor (Rep a), Generic a) => a -> String

-- | Automatically derived from <a>Generic</a> instances.
class HasConstructor (f :: * -> *)
genericConstrName :: HasConstructor f => f x -> String

-- | Type that can be reduced away from a constructor. Use this to make
--   your data types compatible. The reduction process and the
--   <tt>(=?=)</tt>-operator do not evaluate fields, therefore creating an
--   empty instance which defaults to <tt><a>reduceWith</a> =
--   <a>undefined</a></tt> is okay <b>as long as no reduced field of</b>
--   <b>this type is strict</b>.
class ReduceWith a where reduceWith = undefined
reduceWith :: ReduceWith a => a

-- | Reduction of a constructor <tt>a -&gt; ... -&gt; c</tt> to a value of
--   type <tt>c</tt>.
class (HasConstructor (Rep c), Generic c) => Reduce a c | a -> c
reduce :: Reduce a c => a -> c

-- | Checks whether two values are created by the same data constructor.
--   Also works with constructors that have not yet received all their
--   arguments. This allows for very convenient constructs, e.g.:
--   
--   <pre>
--   &gt;&gt;&gt; Just 1 =?= Just
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Just 1 =?= Nothing
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let filterJust = filter (=?= Just)
--   
--   &gt;&gt;&gt; filterJust [Just 1, Nothing, Just 9001]
--   [Just 1, Just 9001]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let filterJust_ = mapMaybe $ (=?= Just) ==&gt; fromJust
--   
--   &gt;&gt;&gt; filterJust_ [Just 1, Nothing, Just 9001]
--   [1, 9001]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let over9000 = mapMaybe $ ((=?= Just) &lt;&amp;&amp;&gt; (&gt;9000) . fromJust) ==&gt; fromJust
--   
--   &gt;&gt;&gt; over9000 [Just 1, Nothing, Just 9001]
--   [9001]
--   </pre>
(=?=) :: (Reduce a c, Reduce b c) => a -> b -> Bool
infixl 4 =?=

-- | <tt>(pred ==&gt; f) x</tt> returns <tt><a>Just</a> (f x)</tt> if
--   <tt>pred x</tt> succeeds and <tt><a>Nothing</a></tt> otherwise.
(==>) :: (a -> Bool) -> (a -> b) -> a -> Maybe b
(<||>) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
infixl 2 <||>
any_ :: [a -> Bool] -> a -> Bool
(<&&>) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
infixl 3 <&&>
all_ :: [a -> Bool] -> a -> Bool

-- | Adds negative and positive infinity to an ordered type. The
--   <a>fromEnum</a> function is inherently susceptible to overflow since
--   the class <a>Enum</a> is defined using <a>Int</a> instead of
--   <a>Integer</a>, but this should not cause trouble with "small" enums.
data Infinite a
NegInfin :: Infinite a
Exact :: !a -> Infinite a
PosInfin :: Infinite a

-- | The <a>mapMaybe</a> function is a version of <a>map</a> which can
--   throw out elements. In particular, the functional argument returns
--   something of type <tt><a>Maybe</a> b</tt>. If this is <a>Nothing</a>,
--   no element is added on to the result list. If it is <tt><a>Just</a>
--   b</tt>, then <tt>b</tt> is included in the result list.
--   
--   <h4><b>Examples</b></h4>
--   
--   Using <tt><a>mapMaybe</a> f x</tt> is a shortcut for
--   <tt><a>catMaybes</a> $ <a>map</a> f x</tt> in most cases:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; let readMaybeInt = readMaybe :: String -&gt; Maybe Int
--   
--   &gt;&gt;&gt; mapMaybe readMaybeInt ["1", "Foo", "3"]
--   [1,3]
--   
--   &gt;&gt;&gt; catMaybes $ map readMaybeInt ["1", "Foo", "3"]
--   [1,3]
--   </pre>
--   
--   If we map the <a>Just</a> constructor, the entire list should be
--   returned:
--   
--   <pre>
--   &gt;&gt;&gt; mapMaybe Just [1,2,3]
--   [1,2,3]
--   </pre>
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
instance GHC.Generics.Generic (Data.Filter.Infinite a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Filter.Infinite a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Filter.Infinite a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Filter.Infinite a)
instance GHC.Base.Functor Data.Filter.Infinite
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Filter.Infinite a)
instance Data.Filter.HasConstructor f => Data.Filter.HasConstructor (GHC.Generics.D1 c f)
instance (Data.Filter.HasConstructor x, Data.Filter.HasConstructor y) => Data.Filter.HasConstructor (x GHC.Generics.:+: y)
instance GHC.Generics.Constructor c => Data.Filter.HasConstructor (GHC.Generics.C1 c f)
instance Data.Filter.ReduceWith GHC.Types.Bool
instance Data.Filter.ReduceWith GHC.Types.Char
instance Data.Default.Class.Default a => Data.Filter.ReduceWith a
instance (Data.Filter.HasConstructor (GHC.Generics.Rep a), GHC.Generics.Generic a) => Data.Filter.Reduce a a
instance (Data.Filter.ReduceWith a, Data.Filter.Reduce b c) => Data.Filter.Reduce (a -> b) c
instance (GHC.Classes.Eq a, GHC.Enum.Bounded a, GHC.Enum.Enum a) => GHC.Enum.Enum (Data.Filter.Infinite a)
instance Data.Default.Class.Default a => Data.Default.Class.Default (Data.Filter.Infinite a)