bizzlelude 1.5.0 → 1.6.0

raw patch · 2 files changed

+5/−3 lines, 2 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

+ Prelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]

+ Prelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]

+ Prelude: class Bounded a

+ Prelude: class Enum a

+ Prelude: enumFrom :: Enum a => a -> [a]

+ Prelude: enumFromThen :: Enum a => a -> a -> [a]

+ Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]

+ Prelude: enumFromTo :: Enum a => a -> a -> [a]

+ Prelude: fromEnum :: Enum a => a -> Int

+ Prelude: fromEnumError :: Show a => String -> a -> b

+ Prelude: infix 4 <=

+ Prelude: infixl 3 <|>

+ Prelude: infixl 6 -

+ Prelude: infixl 7 `mod`

+ Prelude: infixr 6 <>

+ Prelude: maxBound :: Bounded a => a

+ Prelude: minBound :: Bounded a => a

+ Prelude: pred :: Enum a => a -> a

+ Prelude: predError :: () => String -> a

+ Prelude: succ :: Enum a => a -> a

+ Prelude: succError :: () => String -> a

+ Prelude: toEnum :: Enum a => Int -> a

+ Prelude: toEnumError :: Show a => String -> Int -> (a, a) -> b

- Prelude: ($!) :: () => a -> b -> a -> b

+ Prelude: ($!) :: () => (a -> b) -> a -> b

- Prelude: ($) :: () => a -> b -> a -> b

+ Prelude: ($) :: () => (a -> b) -> a -> b

- Prelude: (&>) :: (a -> b) -> (b -> c) -> (a -> c)

+ Prelude: (&>) :: (a -> b) -> (b -> c) -> a -> c

- Prelude: (&>=) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)

+ Prelude: (&>=) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

- Prelude: (.) :: () => b -> c -> a -> b -> a -> c

+ Prelude: (.) :: () => (b -> c) -> (a -> b) -> a -> c

- Prelude: (<$>) :: Functor f => a -> b -> f a -> f b

+ Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b

- Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b

+ Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b

- Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)

+ Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

- Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b

+ Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b

- Prelude: (>>>) :: (a -> b) -> (b -> c) -> (a -> c)

+ Prelude: (>>>) :: (a -> b) -> (b -> c) -> a -> c

- Prelude: all :: Foldable t => a -> Bool -> t a -> Bool

+ Prelude: all :: Foldable t => (a -> Bool) -> t a -> Bool

- Prelude: any :: Foldable t => a -> Bool -> t a -> Bool

+ Prelude: any :: Foldable t => (a -> Bool) -> t a -> Bool

- Prelude: bimap :: Bifunctor p => a -> b -> c -> d -> p a c -> p b d

+ Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d

- Prelude: class Applicative f => Alternative (f :: * -> *)

+ Prelude: class Applicative f => Alternative (f :: Type -> Type)

- Prelude: class Functor f => Applicative (f :: * -> *)

+ Prelude: class Functor f => Applicative (f :: Type -> Type)

- Prelude: class Bifunctor (p :: * -> * -> *)

+ Prelude: class Bifunctor (p :: Type -> Type -> Type)

- Prelude: class Foldable (t :: * -> *)

+ Prelude: class Foldable (t :: Type -> Type)

- Prelude: class Functor (f :: * -> *)

+ Prelude: class Functor (f :: Type -> Type)

- Prelude: class Applicative m => Monad (m :: * -> *)

+ Prelude: class Applicative m => Monad (m :: Type -> Type)

- Prelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)

+ Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)

- Prelude: curry :: () => (a, b) -> c -> a -> b -> c

+ Prelude: curry :: () => ((a, b) -> c) -> a -> b -> c

- Prelude: either :: () => a -> c -> b -> c -> Either a b -> c

+ Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c

- Prelude: filterM :: Applicative m => a -> m Bool -> [a] -> m [a]

+ Prelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]

- Prelude: find :: Foldable t => a -> Bool -> t a -> Maybe a

+ Prelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a

- Prelude: first :: Bifunctor p => a -> b -> p a c -> p b c

+ Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c

- Prelude: flip :: () => a -> b -> c -> b -> a -> c

+ Prelude: flip :: () => (a -> b -> c) -> b -> a -> c

- Prelude: fmap :: Functor f => a -> b -> f a -> f b

+ Prelude: fmap :: Functor f => (a -> b) -> f a -> f b

- Prelude: foldM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b

+ Prelude: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

- Prelude: foldM_ :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m ()

+ Prelude: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()

- Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m

+ Prelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

- Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b

+ Prelude: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

- Prelude: foldl' :: Foldable t => b -> a -> b -> b -> t a -> b

+ Prelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

- Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a

+ Prelude: foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

- Prelude: foldlM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b

+ Prelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

- Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b

+ Prelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

- Prelude: foldr' :: Foldable t => a -> b -> b -> b -> t a -> b

+ Prelude: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b

- Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a

+ Prelude: foldr1 :: Foldable t => (a -> a -> a) -> t a -> a

- Prelude: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b

+ Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)

- Prelude: forM_ :: (Foldable t, Monad m) => t a -> a -> m b -> m ()

+ Prelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()

- Prelude: for_ :: (Foldable t, Applicative f) => t a -> a -> f b -> f ()

+ Prelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()

- Prelude: infixr 8 ^

+ Prelude: infixr 8 **

- Prelude: join :: Monad m => m m a -> m a

+ Prelude: join :: Monad m => m (m a) -> m a

- Prelude: map :: (Functor f) => (a -> b) -> f a -> f b

+ Prelude: map :: Functor f => (a -> b) -> f a -> f b

- Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b

+ Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

- Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()

+ Prelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

- Prelude: maximumBy :: Foldable t => a -> a -> Ordering -> t a -> a

+ Prelude: maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a

- Prelude: maybe :: () => b -> a -> b -> Maybe a -> b

+ Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b

- Prelude: minimumBy :: Foldable t => a -> a -> Ordering -> t a -> a

+ Prelude: minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a

- Prelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c

+ Prelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c

- Prelude: return' :: (Monad m) => a -> m a

+ Prelude: return' :: Monad m => a -> m a

- Prelude: second :: Bifunctor p => b -> c -> p a b -> p a c

+ Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c

- Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a

+ Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

- Prelude: sequenceA_ :: (Foldable t, Applicative f) => t f a -> f ()

+ Prelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()

- Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()

+ Prelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

- Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c

+ Prelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c

- Prelude: uncurry3 :: (a -> b -> c -> x) -> ((a, b, c) -> x)

+ Prelude: uncurry3 :: (a -> b -> c -> x) -> (a, b, c) -> x

- Prelude: uncurry4 :: (a -> b -> c -> d -> x) -> ((a, b, c, d) -> x)

+ Prelude: uncurry4 :: (a -> b -> c -> d -> x) -> (a, b, c, d) -> x

- Prelude: uncurry5 :: (a -> b -> c -> d -> e -> f) -> ((a, b, c, d, e) -> f)

+ Prelude: uncurry5 :: (a -> b -> c -> d -> e -> f) -> (a, b, c, d, e) -> f

Files

bizzlelude.cabal +2/−2
src/main/External.hs +3/−1

bizzlelude.cabal view

@@ -1,6 +1,6 @@ Name:                bizzlelude-Version:             1.5.0-Cabal-version:       1.22.0+Version:             1.6.0+Cabal-version:       1.22 License:             BSD3 License-File:        LICENSE.txt Author:              Jason Bertsche

src/main/External.hs view

@@ -1,5 +1,5 @@ {-# LANGUAGE NoImplicitPrelude #-}-module External(module Control.Arrow, module Control.Applicative, module Control.Monad, module Control.Monad.IO.Class, module Data.Bifunctor, module Data.Bool, module Data.Char, module Data.Either, module Data.Eq, module Data.Foldable, module Data.Function, module Data.Functor, module Data.Int, module Data.IntSet, module Data.Map, module Data.Maybe, module Data.Monoid, module Data.Ord, module Data.Semigroup, module Data.Set, module Data.Text, module Data.Tuple, module Debug.Trace, module GHC.Base, module GHC.Err, module GHC.Float, module GHC.IO, module GHC.Num, module GHC.Real, module GHC.Show, module Numeric, module System.IO.Error, module Text.Read) where+module External(module Control.Arrow, module Control.Applicative, module Control.Monad, module Control.Monad.IO.Class, module Data.Bifunctor, module Data.Bool, module Data.Char, module Data.Either, module Data.Eq, module Data.Foldable, module Data.Function, module Data.Functor, module Data.Int, module Data.IntSet, module Data.Map, module Data.Maybe, module Data.Monoid, module Data.Ord, module Data.Semigroup, module Data.Set, module Data.Text, module Data.Tuple, module Debug.Trace, module GHC.Base, module GHC.Enum, module GHC.Err, module GHC.Float, module GHC.IO, module GHC.Num, module GHC.Real, module GHC.Show, module Numeric, module System.IO.Error, module Text.Read) where  import Control.Arrow((&&&), (***)) import Control.Applicative(Alternative((<|>)), Applicative((<*>), (<*), (*>), pure))@@ -28,6 +28,8 @@ import Debug.Trace(trace, traceEvent, traceEventIO, traceId, traceIO, traceM, traceMarker, traceMarkerIO, traceShow, traceShowId, traceShowM, traceStack)  import GHC.Base(($!), seq, String)+import GHC.Enum(Bounded, boundedEnumFrom, boundedEnumFromThen, Enum, enumFrom, enumFromThen, enumFromThenTo, enumFromTo, fromEnum, fromEnumError, maxBound, minBound, pred, predError, succ, succError, toEnum, toEnumError)+ import GHC.Err(undefined) import GHC.Float(Double, Float) import GHC.IO(FilePath, IO)