incipit-base 0.1.0.0 → 0.1.0.1
raw patch · 2 files changed
+3/−1 lines, 2 filesPVP: minor bump suggested
API additions: PVP suggests at least a minor version bump
API changes (from Hackage documentation)
+ Incipit.Base: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ Incipit.Base: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ Incipit.Base: ($>) :: Functor f => f a -> b -> f b
+ Incipit.Base: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Incipit.Base: (&&) :: Bool -> Bool -> Bool
+ Incipit.Base: (&) :: a -> (a -> b) -> b
+ Incipit.Base: (*) :: Num a => a -> a -> a
+ Incipit.Base: (*>) :: Applicative f => f a -> f b -> f b
+ Incipit.Base: (+) :: Num a => a -> a -> a
+ Incipit.Base: (++) :: [a] -> [a] -> [a]
+ Incipit.Base: (-) :: Num a => a -> a -> a
+ Incipit.Base: (.) :: (b -> c) -> (a -> b) -> a -> c
+ Incipit.Base: (/) :: Fractional a => a -> a -> a
+ Incipit.Base: (/=) :: Eq a => a -> a -> Bool
+ Incipit.Base: (:|) :: a -> [a] -> NonEmpty a
+ Incipit.Base: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ Incipit.Base: (<$) :: Functor f => a -> f b -> f a
+ Incipit.Base: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ Incipit.Base: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ Incipit.Base: (<) :: Ord a => a -> a -> Bool
+ Incipit.Base: (<*) :: Applicative f => f a -> f b -> f a
+ Incipit.Base: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ Incipit.Base: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Incipit.Base: (<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
+ Incipit.Base: (<=) :: Ord a => a -> a -> Bool
+ Incipit.Base: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ Incipit.Base: (<>) :: Semigroup a => a -> a -> a
+ Incipit.Base: (<|>) :: Alternative f => f a -> f a -> f a
+ Incipit.Base: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ Incipit.Base: (==) :: Eq a => a -> a -> Bool
+ Incipit.Base: (>$) :: Contravariant f => b -> f b -> f a
+ Incipit.Base: (>$<) :: Contravariant f => (a -> b) -> f b -> f a
+ Incipit.Base: (>) :: Ord a => a -> a -> Bool
+ Incipit.Base: (>=) :: Ord a => a -> a -> Bool
+ Incipit.Base: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ Incipit.Base: (>>) :: Monad m => m a -> m b -> m b
+ Incipit.Base: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Incipit.Base: (>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
+ Incipit.Base: (^) :: (Num a, Integral b) => a -> b -> a
+ Incipit.Base: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Incipit.Base: (||) :: Bool -> Bool -> Bool
+ Incipit.Base: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
+ Incipit.Base: Const :: a -> Const a (b :: k)
+ Incipit.Base: D# :: Double# -> Double
+ Incipit.Base: Down :: a -> Down a
+ Incipit.Base: EQ :: Ordering
+ Incipit.Base: F# :: Float# -> Float
+ Incipit.Base: False :: Bool
+ Incipit.Base: GT :: Ordering
+ Incipit.Base: Identity :: a -> Identity a
+ Incipit.Base: Just :: a -> Maybe a
+ Incipit.Base: LT :: Ordering
+ Incipit.Base: Nothing :: Maybe a
+ Incipit.Base: Proxy :: Proxy (t :: k)
+ Incipit.Base: SomeException :: e -> SomeException
+ Incipit.Base: SomeNat :: Proxy n -> SomeNat
+ Incipit.Base: SomeSymbol :: Proxy n -> SomeSymbol
+ Incipit.Base: True :: Bool
+ Incipit.Base: ZipList :: [a] -> ZipList a
+ Incipit.Base: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
+ Incipit.Base: [getConst] :: Const a (b :: k) -> a
+ Incipit.Base: [getDown] :: Down a -> a
+ Incipit.Base: [getZipList] :: ZipList a -> [a]
+ Incipit.Base: [runIdentity] :: Identity a -> a
+ Incipit.Base: abs :: Num a => a -> a
+ Incipit.Base: all :: Foldable t => (a -> Bool) -> t a -> Bool
+ Incipit.Base: and :: Foldable t => t Bool -> Bool
+ Incipit.Base: any :: Foldable t => (a -> Bool) -> t a -> Bool
+ Incipit.Base: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ Incipit.Base: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Incipit.Base: bool :: a -> a -> Bool -> a
+ Incipit.Base: break :: (a -> Bool) -> [a] -> ([a], [a])
+ Incipit.Base: byteSwap16 :: Word16 -> Word16
+ Incipit.Base: byteSwap32 :: Word32 -> Word32
+ Incipit.Base: byteSwap64 :: Word64 -> Word64
+ Incipit.Base: catMaybes :: [Maybe a] -> [a]
+ Incipit.Base: ceiling :: (RealFrac a, Integral b) => a -> b
+ Incipit.Base: chr :: Int -> Char
+ Incipit.Base: class Applicative f => Alternative (f :: Type -> Type)
+ Incipit.Base: class Functor f => Applicative (f :: Type -> Type)
+ Incipit.Base: class Bifunctor (p :: Type -> Type -> Type)
+ Incipit.Base: class Bounded a
+ Incipit.Base: class a ~R# b => Coercible (a :: k) (b :: k)
+ Incipit.Base: class Contravariant (f :: Type -> Type)
+ Incipit.Base: class Enum a
+ Incipit.Base: class Eq a
+ Incipit.Base: class (Typeable e, Show e) => Exception e
+ Incipit.Base: class Foldable (t :: Type -> Type)
+ Incipit.Base: class Num a => Fractional a
+ Incipit.Base: class Functor (f :: Type -> Type)
+ Incipit.Base: class Generic a
+ Incipit.Base: class (Real a, Enum a) => Integral a
+ Incipit.Base: class IsLabel (x :: Symbol) a
+ Incipit.Base: class KnownNat (n :: Nat)
+ Incipit.Base: class KnownSymbol (n :: Symbol)
+ Incipit.Base: class Applicative m => Monad (m :: Type -> Type)
+ Incipit.Base: class Monad m => MonadFail (m :: Type -> Type)
+ Incipit.Base: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ Incipit.Base: class Semigroup a => Monoid a
+ Incipit.Base: class Num a
+ Incipit.Base: class Eq a => Ord a
+ Incipit.Base: class (Num a, Ord a) => Real a
+ Incipit.Base: class (Real a, Fractional a) => RealFrac a
+ Incipit.Base: class Semigroup a
+ Incipit.Base: class Show a
+ Incipit.Base: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ Incipit.Base: class Typeable (a :: k)
+ Incipit.Base: coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
+ Incipit.Base: compare :: Ord a => a -> a -> Ordering
+ Incipit.Base: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ Incipit.Base: concat :: Foldable t => t [a] -> [a]
+ Incipit.Base: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
+ Incipit.Base: const :: a -> b -> a
+ Incipit.Base: contramap :: Contravariant f => (a' -> a) -> f a -> f a'
+ Incipit.Base: curry :: ((a, b) -> c) -> a -> b -> c
+ Incipit.Base: data Bool
+ Incipit.Base: data Char
+ Incipit.Base: data Constraint
+ Incipit.Base: data Double
+ Incipit.Base: data Float
+ Incipit.Base: data IO a
+ Incipit.Base: data Int
+ Incipit.Base: data Int16
+ Incipit.Base: data Int32
+ Incipit.Base: data Int64
+ Incipit.Base: data Int8
+ Incipit.Base: data Integer
+ Incipit.Base: data Maybe a
+ Incipit.Base: data Nat
+ Incipit.Base: data Natural
+ Incipit.Base: data NonEmpty a
+ Incipit.Base: data Ordering
+ Incipit.Base: data Proxy (t :: k)
+ Incipit.Base: data Ratio a
+ Incipit.Base: data SomeException
+ Incipit.Base: data SomeNat
+ Incipit.Base: data SomeSymbol
+ Incipit.Base: data Symbol
+ Incipit.Base: data Void
+ Incipit.Base: data Word
+ Incipit.Base: data Word16
+ Incipit.Base: data Word32
+ Incipit.Base: data Word64
+ Incipit.Base: data Word8
+ Incipit.Base: denominator :: Ratio a -> a
+ Incipit.Base: div :: Integral a => a -> a -> a
+ Incipit.Base: divMod :: Integral a => a -> a -> (a, a)
+ Incipit.Base: drop :: Int -> [a] -> [a]
+ Incipit.Base: dropWhile :: (a -> Bool) -> [a] -> [a]
+ Incipit.Base: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Incipit.Base: empty :: Alternative f => f a
+ Incipit.Base: enumFrom :: Enum a => a -> [a]
+ Incipit.Base: enumFromThen :: Enum a => a -> a -> [a]
+ Incipit.Base: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Incipit.Base: enumFromTo :: Enum a => a -> a -> [a]
+ Incipit.Base: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
+ Incipit.Base: even :: Integral a => a -> Bool
+ Incipit.Base: fail :: MonadFail m => String -> m a
+ Incipit.Base: filter :: (a -> Bool) -> [a] -> [a]
+ Incipit.Base: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
+ Incipit.Base: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
+ Incipit.Base: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ Incipit.Base: fix :: (a -> a) -> a
+ Incipit.Base: flip :: (a -> b -> c) -> b -> a -> c
+ Incipit.Base: floor :: (RealFrac a, Integral b) => a -> b
+ Incipit.Base: fmap :: Functor f => (a -> b) -> f a -> f b
+ Incipit.Base: fold :: (Foldable t, Monoid m) => t m -> m
+ Incipit.Base: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ Incipit.Base: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ Incipit.Base: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Incipit.Base: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Incipit.Base: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
+ Incipit.Base: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ Incipit.Base: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Incipit.Base: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Incipit.Base: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
+ Incipit.Base: for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+ Incipit.Base: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+ Incipit.Base: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
+ Incipit.Base: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+ Incipit.Base: forever :: Applicative f => f a -> f b
+ Incipit.Base: fromEnum :: Enum a => a -> Int
+ Incipit.Base: fromInteger :: Num a => Integer -> a
+ Incipit.Base: fromIntegral :: (Integral a, Num b) => a -> b
+ Incipit.Base: fromLabel :: IsLabel x a => a
+ Incipit.Base: fromMaybe :: a -> Maybe a -> a
+ Incipit.Base: fromRational :: Fractional a => Rational -> a
+ Incipit.Base: fst :: (a, b) -> a
+ Incipit.Base: gcd :: Integral a => a -> a -> a
+ Incipit.Base: genericDrop :: Integral i => i -> [a] -> [a]
+ Incipit.Base: genericLength :: Num i => [a] -> i
+ Incipit.Base: genericReplicate :: Integral i => i -> a -> [a]
+ Incipit.Base: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ Incipit.Base: genericTake :: Integral i => i -> [a] -> [a]
+ Incipit.Base: group :: Eq a => [a] -> [[a]]
+ Incipit.Base: guard :: Alternative f => Bool -> f ()
+ Incipit.Base: id :: a -> a
+ Incipit.Base: infix 4 <=
+ Incipit.Base: infixl 0 `on`
+ Incipit.Base: infixl 1 <&>
+ Incipit.Base: infixl 3 <|>
+ Incipit.Base: infixl 4 >$<
+ Incipit.Base: infixl 5 :$$:
+ Incipit.Base: infixl 6 :<>:
+ Incipit.Base: infixl 7 `Mod`
+ Incipit.Base: infixr 0 $!
+ Incipit.Base: infixr 1 =<<
+ Incipit.Base: infixr 2 ||
+ Incipit.Base: infixr 3 &&
+ Incipit.Base: infixr 5 :|
+ Incipit.Base: infixr 6 <>
+ Incipit.Base: infixr 8 ^
+ Incipit.Base: infixr 9 `Compose`
+ Incipit.Base: inits :: [a] -> [[a]]
+ Incipit.Base: intercalate :: [a] -> [[a]] -> [a]
+ Incipit.Base: intersperse :: a -> [a] -> [a]
+ Incipit.Base: isJust :: Maybe a -> Bool
+ Incipit.Base: isNothing :: Maybe a -> Bool
+ Incipit.Base: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Incipit.Base: iterate :: (a -> a) -> a -> [a]
+ Incipit.Base: join :: Monad m => m (m a) -> m a
+ Incipit.Base: lcm :: Integral a => a -> a -> a
+ Incipit.Base: length :: Foldable t => t a -> Int
+ Incipit.Base: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ Incipit.Base: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ Incipit.Base: listToMaybe :: [a] -> Maybe a
+ Incipit.Base: many :: Alternative f => f a -> f [a]
+ Incipit.Base: map :: (a -> b) -> [a] -> [b]
+ Incipit.Base: mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Incipit.Base: mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Incipit.Base: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
+ Incipit.Base: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
+ Incipit.Base: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+ Incipit.Base: mappend :: Monoid a => a -> a -> a
+ Incipit.Base: max :: Ord a => a -> a -> a
+ Incipit.Base: maxBound :: Bounded a => a
+ Incipit.Base: maxInt :: Int
+ Incipit.Base: maximum :: (Foldable t, Ord a) => t a -> a
+ Incipit.Base: maybe :: b -> (a -> b) -> Maybe a -> b
+ Incipit.Base: maybeToList :: Maybe a -> [a]
+ Incipit.Base: mconcat :: Monoid a => [a] -> a
+ Incipit.Base: mempty :: Monoid a => a
+ Incipit.Base: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
+ Incipit.Base: min :: Ord a => a -> a -> a
+ Incipit.Base: minBound :: Bounded a => a
+ Incipit.Base: minInt :: Int
+ Incipit.Base: minimum :: (Foldable t, Ord a) => t a -> a
+ Incipit.Base: mod :: Integral a => a -> a -> a
+ Incipit.Base: mplus :: MonadPlus m => m a -> m a -> m a
+ Incipit.Base: mzero :: MonadPlus m => m a
+ Incipit.Base: natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
+ Incipit.Base: natVal' :: forall (n :: Nat). KnownNat n => Proxy# n -> Integer
+ Incipit.Base: negate :: Num a => a -> a
+ Incipit.Base: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
+ Incipit.Base: newtype Const a (b :: k)
+ Incipit.Base: newtype Down a
+ Incipit.Base: newtype Identity a
+ Incipit.Base: newtype ZipList a
+ Incipit.Base: nonEmpty :: [a] -> Maybe (NonEmpty a)
+ Incipit.Base: not :: Bool -> Bool
+ Incipit.Base: null :: Foldable t => t a -> Bool
+ Incipit.Base: numerator :: Ratio a -> a
+ Incipit.Base: odd :: Integral a => a -> Bool
+ Incipit.Base: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
+ Incipit.Base: optional :: Alternative f => f a -> f (Maybe a)
+ Incipit.Base: or :: Foldable t => t Bool -> Bool
+ Incipit.Base: ord :: Char -> Int
+ Incipit.Base: otherwise :: Bool
+ Incipit.Base: pattern (:$$:) :: () => ErrorMessage -> ErrorMessage -> ErrorMessage
+ Incipit.Base: pattern ShowType :: () => t -> ErrorMessage
+ Incipit.Base: permutations :: [a] -> [[a]]
+ Incipit.Base: pred :: Enum a => a -> a
+ Incipit.Base: print :: Show a => a -> IO ()
+ Incipit.Base: product :: (Foldable t, Num a) => t a -> a
+ Incipit.Base: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Incipit.Base: pure :: Applicative f => a -> f a
+ Incipit.Base: putStr :: String -> IO ()
+ Incipit.Base: putStrLn :: String -> IO ()
+ Incipit.Base: quot :: Integral a => a -> a -> a
+ Incipit.Base: quotRem :: Integral a => a -> a -> (a, a)
+ Incipit.Base: realToFrac :: (Real a, Fractional b) => a -> b
+ Incipit.Base: recip :: Fractional a => a -> a
+ Incipit.Base: rem :: Integral a => a -> a -> a
+ Incipit.Base: repeat :: a -> [a]
+ Incipit.Base: replicate :: Int -> a -> [a]
+ Incipit.Base: replicateM :: Applicative m => Int -> m a -> m [a]
+ Incipit.Base: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Incipit.Base: reverse :: [a] -> [a]
+ Incipit.Base: round :: (RealFrac a, Integral b) => a -> b
+ Incipit.Base: sameNat :: forall (a :: Nat) (b :: Nat) proxy1 proxy2. (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Maybe (a :~: b)
+ Incipit.Base: sameSymbol :: forall (a :: Symbol) (b :: Symbol) proxy1 proxy2. (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> Maybe (a :~: b)
+ Incipit.Base: scanl :: (b -> a -> b) -> b -> [a] -> [b]
+ Incipit.Base: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
+ Incipit.Base: scanl1 :: (a -> a -> a) -> [a] -> [a]
+ Incipit.Base: scanr :: (a -> b -> b) -> b -> [a] -> [b]
+ Incipit.Base: scanr1 :: (a -> a -> a) -> [a] -> [a]
+ Incipit.Base: sconcat :: Semigroup a => NonEmpty a -> a
+ Incipit.Base: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ Incipit.Base: seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
+ Incipit.Base: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+ Incipit.Base: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ Incipit.Base: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
+ Incipit.Base: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
+ Incipit.Base: signum :: Num a => a -> a
+ Incipit.Base: snd :: (a, b) -> b
+ Incipit.Base: some :: Alternative f => f a -> f [a]
+ Incipit.Base: someNatVal :: Integer -> Maybe SomeNat
+ Incipit.Base: someSymbolVal :: String -> SomeSymbol
+ Incipit.Base: sort :: Ord a => [a] -> [a]
+ Incipit.Base: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
+ Incipit.Base: sortOn :: Ord b => (a -> b) -> [a] -> [a]
+ Incipit.Base: span :: (a -> Bool) -> [a] -> ([a], [a])
+ Incipit.Base: splitAt :: Int -> [a] -> ([a], [a])
+ Incipit.Base: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Incipit.Base: subsequences :: [a] -> [[a]]
+ Incipit.Base: subtract :: Num a => a -> a -> a
+ Incipit.Base: succ :: Enum a => a -> a
+ Incipit.Base: sum :: (Foldable t, Num a) => t a -> a
+ Incipit.Base: swap :: (a, b) -> (b, a)
+ Incipit.Base: symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
+ Incipit.Base: symbolVal' :: forall (n :: Symbol). KnownSymbol n => Proxy# n -> String
+ Incipit.Base: tails :: [a] -> [[a]]
+ Incipit.Base: take :: Int -> [a] -> [a]
+ Incipit.Base: takeWhile :: (a -> Bool) -> [a] -> [a]
+ Incipit.Base: toEnum :: Enum a => Int -> a
+ Incipit.Base: toInteger :: Integral a => a -> Integer
+ Incipit.Base: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
+ Incipit.Base: toList :: Foldable t => t a -> [a]
+ Incipit.Base: toRational :: Real a => a -> Rational
+ Incipit.Base: transpose :: [[a]] -> [[a]]
+ Incipit.Base: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Incipit.Base: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
+ Incipit.Base: truncate :: (RealFrac a, Integral b) => a -> b
+ Incipit.Base: type (x :: Nat) <= (y :: Nat) = x <=? y ~ 'True
+ Incipit.Base: type FilePath = String
+ Incipit.Base: type HasCallStack = ?callStack :: CallStack
+ Incipit.Base: type Rational = Ratio Integer
+ Incipit.Base: type Type = Type
+ Incipit.Base: type family AppendSymbol (a :: Symbol) (b :: Symbol) :: Symbol
+ Incipit.Base: uncons :: [a] -> Maybe (a, [a])
+ Incipit.Base: uncurry :: (a -> b -> c) -> (a, b) -> c
+ Incipit.Base: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
+ Incipit.Base: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+ Incipit.Base: unless :: Applicative f => Bool -> f () -> f ()
+ Incipit.Base: unzip :: [(a, b)] -> ([a], [b])
+ Incipit.Base: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
+ Incipit.Base: void :: Functor f => f a -> f ()
+ Incipit.Base: when :: Applicative f => Bool -> f () -> f ()
+ Incipit.Base: xor :: Bits a => a -> a -> a
+ Incipit.Base: zip :: [a] -> [b] -> [(a, b)]
+ Incipit.Base: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
+ Incipit.Base: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+ Incipit.Base: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
+ Incipit.Base: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
Files
- incipit-base.cabal +1/−1
- lib/Incipit/Base.hs +2/−0
incipit-base.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: incipit-base-version: 0.1.0.0+version: 0.1.0.1 synopsis: A Prelude for Polysemy description: See <https://hackage.haskell.org/package/incipit-base/docs/Incipit-Prelude.html> category: Prelude
lib/Incipit/Base.hs view
@@ -5,6 +5,7 @@ module Control.Applicative, module Control.Arrow, module Control.Category,+ module Control.Exception, module Control.Monad, module Control.Monad.Fail, module Data.Bifunctor,@@ -61,6 +62,7 @@ ) import Control.Arrow ((&&&)) import Control.Category ((<<<), (>>>))+import Control.Exception (Exception, SomeException (..)) import Control.Monad ( Monad ((>>), (>>=)), MonadPlus (..),