-- vim:fdm=marker:foldtext=foldtext() -------------------------------------------------------------------- -- | -- Module : Test.SmallCheck.Series -- Copyright : (c) Colin Runciman et al. -- License : BSD3 -- Maintainer: Roman Cheplyaka <roma@ro-che.info> -- -- You need this module if you want to generate test values of your own -- types. -- -- You'll typically need the following extensions: -- -- >{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} -- -- SmallCheck itself defines data generators for all the data types used -- by the "Prelude". -- -- In order to generate values and functions of your own types, you need -- to make them instances of 'Serial' (for values) and 'CoSerial' (for -- functions). There are two main ways to do so: using Generics or writing -- the instances by hand. -------------------------------------------------------------------- {-# LANGUAGE CPP #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE DefaultSignatures #-} #endif {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeOperators #-} #if MIN_VERSION_base(4,8,0) {-# LANGUAGE Safe #-} #else {-# LANGUAGE OverlappingInstances #-} #if __GLASGOW_HASKELL__ >= 704 {-# LANGUAGE Trustworthy #-} #endif #endif #define HASCBOOL MIN_VERSION_base(4,10,0) module Test.SmallCheck.Series ( -- {{{ -- * Generic instances -- | The easiest way to create the necessary instances is to use GHC -- generics (available starting with GHC 7.2.1). -- -- Here's a complete example: -- -- >{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} -- >{-# LANGUAGE DeriveGeneric #-} -- > -- >import Test.SmallCheck.Series -- >import GHC.Generics -- > -- >data Tree a = Null | Fork (Tree a) a (Tree a) -- > deriving Generic -- > -- >instance Serial m a => Serial m (Tree a) -- -- Here we enable the @DeriveGeneric@ extension which allows to derive 'Generic' -- instance for our data type. Then we declare that @Tree@ @a@ is an instance of -- 'Serial', but do not provide any definitions. This causes GHC to use the -- default definitions that use the 'Generic' instance. -- -- One minor limitation of generic instances is that there's currently no -- way to distinguish newtypes and datatypes. Thus, newtype constructors -- will also count as one level of depth. -- * Data Generators -- | Writing 'Serial' instances for application-specific types is -- straightforward. You need to define a 'series' generator, typically using -- @consN@ family of generic combinators where N is constructor arity. -- -- For example: -- -- >data Tree a = Null | Fork (Tree a) a (Tree a) -- > -- >instance Serial m a => Serial m (Tree a) where -- > series = cons0 Null \/ cons3 Fork -- -- For newtypes use 'newtypeCons' instead of 'cons1'. -- The difference is that 'cons1' is counts as one level of depth, while -- 'newtypeCons' doesn't affect the depth. -- -- >newtype Light a = Light a -- > -- >instance Serial m a => Serial m (Light a) where -- > series = newtypeCons Light -- -- For data types with more than 6 fields define @consN@ as -- -- >consN f = decDepth $ -- > f <$> series -- > <~> series -- > <~> series -- > <~> ... {- series repeated N times in total -} -- ** What does @consN@ do, exactly? -- | @consN@ has type -- @(Serial t₁, ..., Serial tₙ) => (t₁ -> ... -> tₙ -> t) -> Series t@. -- -- @consN@ @f@ is a series which, for a given depth \(d > 0\), produces values of the -- form -- -- >f x₁ ... xₙ -- -- where @xₖ@ ranges over all values of type @tₖ@ of depth up to \(d-1\) -- (as defined by the 'series' functions for @tₖ@). -- -- @consN@ functions also ensure that xₖ are enumerated in the -- breadth-first order. Thus, combinations of smaller depth come first -- (assuming the same is true for @tₖ@). -- -- If \(d \le 0\), no values are produced. cons0, cons1, cons2, cons3, cons4, cons5, cons6, newtypeCons, -- * Function Generators -- | To generate functions of an application-specific argument type, -- make the type an instance of 'CoSerial'. -- -- Again there is a standard pattern, this time using the @altsN@ -- combinators where again N is constructor arity. Here are @Tree@ and -- @Light@ instances: -- -- -- >instance CoSerial m a => CoSerial m (Tree a) where -- > coseries rs = -- > alts0 rs >>- \z -> -- > alts3 rs >>- \f -> -- > return $ \t -> -- > case t of -- > Null -> z -- > Fork t1 x t2 -> f t1 x t2 -- -- >instance CoSerial m a => CoSerial m (Light a) where -- > coseries rs = -- > newtypeAlts rs >>- \f -> -- > return $ \l -> -- > case l of -- > Light x -> f x -- -- For data types with more than 6 fields define @altsN@ as -- -- >altsN rs = do -- > rs <- fixDepth rs -- > decDepthChecked -- > (constM $ constM $ ... $ constM rs) -- > (coseries $ coseries $ ... $ coseries rs) -- > {- constM and coseries are repeated N times each -} -- ** What does altsN do, exactly? -- | @altsN@ has type -- @(Serial t₁, ..., Serial tₙ) => Series t -> Series (t₁ -> ... -> tₙ -> t)@. -- -- @altsN@ @s@ is a series which, for a given depth \( d \), produces functions of -- type -- -- >t₁ -> ... -> tₙ -> t -- -- If \( d \le 0 \), these are constant functions, one for each value produced -- by @s@. -- -- If \( d > 0 \), these functions inspect each of their arguments up to the depth -- \( d-1 \) (as defined by the 'coseries' functions for the corresponding -- types) and return values produced by @s@. The depth to which the -- values are enumerated does not depend on the depth of inspection. alts0, alts1, alts2, alts3, alts4, alts5, alts6, newtypeAlts, -- * Basic definitions Depth, Series, Serial(..), CoSerial(..), #if __GLASGOW_HASKELL__ >= 702 -- * Generic implementations genericSeries, genericCoseries, #endif -- * Convenient wrappers Positive(..), NonNegative(..), NonZero(..), NonEmpty(..), -- * Other useful definitions (\/), (><), (<~>), (>>-), localDepth, decDepth, getDepth, generate, limit, listSeries, list, listM, fixDepth, decDepthChecked, constM -- }}} ) where import Control.Monad (liftM, guard, mzero, mplus, msum) import Control.Monad.Logic (MonadLogic, (>>-), interleave, msplit, observeAllT) import Control.Monad.Reader (ask, local) import Control.Applicative (empty, pure, (<$>), (<|>)) import Data.Complex (Complex(..)) import Data.Foldable (Foldable) import Data.Functor.Compose (Compose(..)) import Data.Void (Void, absurd) import Control.Monad.Identity (Identity(..)) import Data.Int (Int, Int8, Int16, Int32, Int64) import Data.List (intercalate) import qualified Data.List.NonEmpty as NE import Data.Ratio (Ratio, numerator, denominator, (%)) import Data.Traversable (Traversable) import Data.Word (Word, Word8, Word16, Word32, Word64) import Foreign.C.Types (CFloat(..), CDouble(..), CChar(..), CSChar(..), CUChar(..), CShort(..), CUShort(..), CInt(..), CUInt(..), CLong(..), CULong(..), CPtrdiff(..), CSize(..), CWchar(..), CSigAtomic(..), CLLong(..), CULLong(..), CIntPtr(..), CUIntPtr(..), CIntMax(..), CUIntMax(..), CClock(..), CTime(..)) #if __GLASGOW_HASKELL__ >= 702 import Foreign.C.Types (CUSeconds(..), CSUSeconds(..)) #endif #if HASCBOOL import Foreign.C.Types (CBool(..)) #endif import Numeric.Natural (Natural) import Test.SmallCheck.SeriesMonad #if __GLASGOW_HASKELL__ >= 702 import GHC.Generics (Generic, (:+:)(..), (:*:)(..), C1, K1(..), M1(..), U1(..), V1(..), Rep, to, from) #endif ------------------------------ -- Main types and classes ------------------------------ --{{{ class Monad m => Serial m a where series :: Series m a #if __GLASGOW_HASKELL__ >= 704 default series :: (Generic a, GSerial m (Rep a)) => Series m a series = Series m a forall (m :: * -> *) a. (Monad m, Generic a, GSerial m (Rep a)) => Series m a genericSeries #endif #if __GLASGOW_HASKELL__ >= 702 genericSeries :: (Monad m, Generic a, GSerial m (Rep a)) => Series m a genericSeries :: Series m a genericSeries = Rep a Any -> a forall a x. Generic a => Rep a x -> a to (Rep a Any -> a) -> Series m (Rep a Any) -> Series m a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (Rep a Any) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries #endif class Monad m => CoSerial m a where -- | A proper 'coseries' implementation should pass the depth unchanged to -- its first argument. Doing otherwise will make enumeration of curried -- functions non-uniform in their arguments. coseries :: Series m b -> Series m (a->b) #if __GLASGOW_HASKELL__ >= 704 default coseries :: (Generic a, GCoSerial m (Rep a)) => Series m b -> Series m (a->b) coseries = Series m b -> Series m (a -> b) forall (m :: * -> *) a b. (Monad m, Generic a, GCoSerial m (Rep a)) => Series m b -> Series m (a -> b) genericCoseries #endif #if __GLASGOW_HASKELL__ >= 702 genericCoseries :: (Monad m, Generic a, GCoSerial m (Rep a)) => Series m b -> Series m (a->b) genericCoseries :: Series m b -> Series m (a -> b) genericCoseries Series m b rs = ((Rep a Any -> b) -> (a -> Rep a Any) -> a -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> Rep a Any forall a x. Generic a => a -> Rep a x from) ((Rep a Any -> b) -> a -> b) -> Series m (Rep a Any -> b) -> Series m (a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (Rep a Any -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries Series m b rs #endif -- }}} ------------------------------ -- Helper functions ------------------------------ -- {{{ -- | A simple series specified by a function from depth to the list of -- values up to that depth. generate :: (Depth -> [a]) -> Series m a generate :: (Depth -> [a]) -> Series m a generate Depth -> [a] f = do Depth d <- Series m Depth forall (m :: * -> *). Series m Depth getDepth [Series m a] -> Series m a forall (t :: * -> *) (m :: * -> *) a. (Foldable t, MonadPlus m) => t (m a) -> m a msum ([Series m a] -> Series m a) -> [Series m a] -> Series m a forall a b. (a -> b) -> a -> b $ (a -> Series m a) -> [a] -> [Series m a] forall a b. (a -> b) -> [a] -> [b] map a -> Series m a forall (m :: * -> *) a. Monad m => a -> m a return ([a] -> [Series m a]) -> [a] -> [Series m a] forall a b. (a -> b) -> a -> b $ Depth -> [a] f Depth d -- | Limit a 'Series' to its first @n@ elements. limit :: forall m a . Monad m => Int -> Series m a -> Series m a limit :: Depth -> Series m a -> Series m a limit Depth n0 (Series ReaderT Depth (LogicT m) a s) = ReaderT Depth (LogicT m) a -> Series m a forall (m :: * -> *) a. ReaderT Depth (LogicT m) a -> Series m a Series (ReaderT Depth (LogicT m) a -> Series m a) -> ReaderT Depth (LogicT m) a -> Series m a forall a b. (a -> b) -> a -> b $ Depth -> ReaderT Depth (LogicT m) a -> ReaderT Depth (LogicT m) a forall t (ml :: * -> *) b. (Eq t, Num t, MonadLogic ml) => t -> ml b -> ml b go Depth n0 ReaderT Depth (LogicT m) a s where go :: t -> ml b -> ml b go t 0 ml b _ = ml b forall (f :: * -> *) a. Alternative f => f a empty go t n ml b mb1 = do Maybe (b, ml b) cons :: Maybe (b, ml b) <- ml b -> ml (Maybe (b, ml b)) forall (m :: * -> *) a. MonadLogic m => m a -> m (Maybe (a, m a)) msplit ml b mb1 case Maybe (b, ml b) cons of Maybe (b, ml b) Nothing -> ml b forall (f :: * -> *) a. Alternative f => f a empty Just (b b, ml b mb2) -> b -> ml b forall (m :: * -> *) a. Monad m => a -> m a return b b ml b -> ml b -> ml b forall (f :: * -> *) a. Alternative f => f a -> f a -> f a <|> t -> ml b -> ml b go (t nt -> t -> t forall a. Num a => a -> a -> a -t 1) ml b mb2 suchThat :: Series m a -> (a -> Bool) -> Series m a suchThat :: Series m a -> (a -> Bool) -> Series m a suchThat Series m a s a -> Bool p = Series m a s Series m a -> (a -> Series m a) -> Series m a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b >>= \a x -> if a -> Bool p a x then a -> Series m a forall (f :: * -> *) a. Applicative f => a -> f a pure a x else Series m a forall (f :: * -> *) a. Alternative f => f a empty -- | Given a depth, return the list of values generated by a 'Serial' instance. -- -- For example, list all integers up to depth 1: -- -- * @listSeries 1 :: [Int] -- returns [0,1,-1]@ listSeries :: Serial Identity a => Depth -> [a] listSeries :: Depth -> [a] listSeries Depth d = Depth -> Series Identity a -> [a] forall a. Depth -> Series Identity a -> [a] list Depth d Series Identity a forall (m :: * -> *) a. Serial m a => Series m a series -- | Return the list of values generated by a 'Series'. Useful for -- debugging 'Serial' instances. -- -- Examples: -- -- * @'list' 3 'series' :: ['Int'] -- returns [0,1,-1,2,-2,3,-3]@ -- -- * @'list' 3 ('series' :: 'Series' 'Data.Functor.Identity' 'Int') -- returns [0,1,-1,2,-2,3,-3]@ -- -- * @'list' 2 'series' :: [['Bool']] -- returns [[],['True'],['False']]@ -- -- The first two are equivalent. The second has a more explicit type binding. list :: Depth -> Series Identity a -> [a] list :: Depth -> Series Identity a -> [a] list Depth d Series Identity a s = Identity [a] -> [a] forall a. Identity a -> a runIdentity (Identity [a] -> [a]) -> Identity [a] -> [a] forall a b. (a -> b) -> a -> b $ LogicT Identity a -> Identity [a] forall (m :: * -> *) a. Monad m => LogicT m a -> m [a] observeAllT (LogicT Identity a -> Identity [a]) -> LogicT Identity a -> Identity [a] forall a b. (a -> b) -> a -> b $ Depth -> Series Identity a -> LogicT Identity a forall (m :: * -> *) a. Depth -> Series m a -> LogicT m a runSeries Depth d Series Identity a s -- | Monadic version of 'list'. listM :: Depth -> Series m a -> m [a] listM Depth d Series m a s = LogicT m a -> m [a] forall (m :: * -> *) a. Monad m => LogicT m a -> m [a] observeAllT (LogicT m a -> m [a]) -> LogicT m a -> m [a] forall a b. (a -> b) -> a -> b $ Depth -> Series m a -> LogicT m a forall (m :: * -> *) a. Depth -> Series m a -> LogicT m a runSeries Depth d Series m a s -- | Sum (union) of series. infixr 7 \/ (\/) :: Monad m => Series m a -> Series m a -> Series m a \/ :: Series m a -> Series m a -> Series m a (\/) = Series m a -> Series m a -> Series m a forall (m :: * -> *) a. MonadLogic m => m a -> m a -> m a interleave -- | Product of series infixr 8 >< (><) :: Monad m => Series m a -> Series m b -> Series m (a,b) Series m a a >< :: Series m a -> Series m b -> Series m (a, b) >< Series m b b = (,) (a -> b -> (a, b)) -> Series m a -> Series m (b -> (a, b)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a a Series m (b -> (a, b)) -> Series m b -> Series m (a, b) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b b -- | Fair version of 'Control.Applicative.ap' and '<*>'. infixl 4 <~> (<~>) :: Monad m => Series m (a -> b) -> Series m a -> Series m b Series m (a -> b) a <~> :: Series m (a -> b) -> Series m a -> Series m b <~> Series m a b = Series m (a -> b) a Series m (a -> b) -> ((a -> b) -> Series m b) -> Series m b forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- ((a -> b) -> Series m a -> Series m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a b) uncurry3 :: (a->b->c->d) -> ((a,b,c)->d) uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d uncurry3 a -> b -> c -> d f (a x,b y,c z) = a -> b -> c -> d f a x b y c z uncurry4 :: (a->b->c->d->e) -> ((a,b,c,d)->e) uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e uncurry4 a -> b -> c -> d -> e f (a w,b x,c y,d z) = a -> b -> c -> d -> e f a w b x c y d z uncurry5 :: (a->b->c->d->e->f) -> ((a,b,c,d,e)->f) uncurry5 :: (a -> b -> c -> d -> e -> f) -> (a, b, c, d, e) -> f uncurry5 a -> b -> c -> d -> e -> f f (a v,b w,c x,d y,e z) = a -> b -> c -> d -> e -> f f a v b w c x d y e z uncurry6 :: (a->b->c->d->e->f->g) -> ((a,b,c,d,e,f)->g) uncurry6 :: (a -> b -> c -> d -> e -> f -> g) -> (a, b, c, d, e, f) -> g uncurry6 a -> b -> c -> d -> e -> f -> g f (a u,b v,c w,d x,e y,f z) = a -> b -> c -> d -> e -> f -> g f a u b v c w d x e y f z -- | Query the current depth. getDepth :: Series m Depth getDepth :: Series m Depth getDepth = ReaderT Depth (LogicT m) Depth -> Series m Depth forall (m :: * -> *) a. ReaderT Depth (LogicT m) a -> Series m a Series ReaderT Depth (LogicT m) Depth forall r (m :: * -> *). MonadReader r m => m r ask -- | Run a series with a modified depth. localDepth :: (Depth -> Depth) -> Series m a -> Series m a localDepth :: (Depth -> Depth) -> Series m a -> Series m a localDepth Depth -> Depth f (Series ReaderT Depth (LogicT m) a a) = ReaderT Depth (LogicT m) a -> Series m a forall (m :: * -> *) a. ReaderT Depth (LogicT m) a -> Series m a Series (ReaderT Depth (LogicT m) a -> Series m a) -> ReaderT Depth (LogicT m) a -> Series m a forall a b. (a -> b) -> a -> b $ (Depth -> Depth) -> ReaderT Depth (LogicT m) a -> ReaderT Depth (LogicT m) a forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a local Depth -> Depth f ReaderT Depth (LogicT m) a a -- | Run a 'Series' with the depth decreased by 1. -- -- If the current depth is less or equal to 0, the result is 'empty'. decDepth :: Series m a -> Series m a decDepth :: Series m a -> Series m a decDepth Series m a a = do Series m () forall (m :: * -> *). Series m () checkDepth (Depth -> Depth) -> Series m a -> Series m a forall (m :: * -> *) a. (Depth -> Depth) -> Series m a -> Series m a localDepth (Depth -> Depth -> Depth forall a. Num a => a -> a -> a subtract Depth 1) Series m a a checkDepth :: Series m () checkDepth :: Series m () checkDepth = do Depth d <- Series m Depth forall (m :: * -> *). Series m Depth getDepth Bool -> Series m () forall (f :: * -> *). Alternative f => Bool -> f () guard (Bool -> Series m ()) -> Bool -> Series m () forall a b. (a -> b) -> a -> b $ Depth d Depth -> Depth -> Bool forall a. Ord a => a -> a -> Bool > Depth 0 -- | @'constM' = 'liftM' 'const'@ constM :: Monad m => m b -> m (a -> b) constM :: m b -> m (a -> b) constM = (b -> a -> b) -> m b -> m (a -> b) forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM b -> a -> b forall a b. a -> b -> a const -- | Fix the depth of a series at the current level. The resulting series -- will no longer depend on the \"ambient\" depth. fixDepth :: Series m a -> Series m (Series m a) fixDepth :: Series m a -> Series m (Series m a) fixDepth Series m a s = Series m Depth forall (m :: * -> *). Series m Depth getDepth Series m Depth -> (Depth -> Series m (Series m a)) -> Series m (Series m a) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b >>= \Depth d -> Series m a -> Series m (Series m a) forall (m :: * -> *) a. Monad m => a -> m a return (Series m a -> Series m (Series m a)) -> Series m a -> Series m (Series m a) forall a b. (a -> b) -> a -> b $ (Depth -> Depth) -> Series m a -> Series m a forall (m :: * -> *) a. (Depth -> Depth) -> Series m a -> Series m a localDepth (Depth -> Depth -> Depth forall a b. a -> b -> a const Depth d) Series m a s -- | If the current depth is 0, evaluate the first argument. Otherwise, -- evaluate the second argument with decremented depth. decDepthChecked :: Series m a -> Series m a -> Series m a decDepthChecked :: Series m a -> Series m a -> Series m a decDepthChecked Series m a b Series m a r = do Depth d <- Series m Depth forall (m :: * -> *). Series m Depth getDepth if Depth d Depth -> Depth -> Bool forall a. Ord a => a -> a -> Bool <= Depth 0 then Series m a b else Series m a -> Series m a forall (m :: * -> *) a. Series m a -> Series m a decDepth Series m a r unwind :: MonadLogic m => m a -> m [a] unwind :: m a -> m [a] unwind m a a = m a -> m (Maybe (a, m a)) forall (m :: * -> *) a. MonadLogic m => m a -> m (Maybe (a, m a)) msplit m a a m (Maybe (a, m a)) -> (Maybe (a, m a) -> m [a]) -> m [a] forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b >>= m [a] -> ((a, m a) -> m [a]) -> Maybe (a, m a) -> m [a] forall b a. b -> (a -> b) -> Maybe a -> b maybe ([a] -> m [a] forall (m :: * -> *) a. Monad m => a -> m a return []) (\(a x,m a a') -> (a xa -> [a] -> [a] forall a. a -> [a] -> [a] :) ([a] -> [a]) -> m [a] -> m [a] forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r `liftM` m a -> m [a] forall (m :: * -> *) a. MonadLogic m => m a -> m [a] unwind m a a') -- }}} ------------------------------ -- cons* and alts* functions ------------------------------ -- {{{ cons0 :: a -> Series m a cons0 :: a -> Series m a cons0 a x = Series m a -> Series m a forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m a -> Series m a) -> Series m a -> Series m a forall a b. (a -> b) -> a -> b $ a -> Series m a forall (f :: * -> *) a. Applicative f => a -> f a pure a x cons1 :: Serial m a => (a->b) -> Series m b cons1 :: (a -> b) -> Series m b cons1 a -> b f = Series m b -> Series m b forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m b -> Series m b) -> Series m b -> Series m b forall a b. (a -> b) -> a -> b $ a -> b f (a -> b) -> Series m a -> Series m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series -- | Same as 'cons1', but preserves the depth. newtypeCons :: Serial m a => (a->b) -> Series m b newtypeCons :: (a -> b) -> Series m b newtypeCons a -> b f = a -> b f (a -> b) -> Series m a -> Series m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series cons2 :: (Serial m a, Serial m b) => (a->b->c) -> Series m c cons2 :: (a -> b -> c) -> Series m c cons2 a -> b -> c f = Series m c -> Series m c forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m c -> Series m c) -> Series m c -> Series m c forall a b. (a -> b) -> a -> b $ a -> b -> c f (a -> b -> c) -> Series m a -> Series m (b -> c) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m (b -> c) -> Series m b -> Series m c forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b forall (m :: * -> *) a. Serial m a => Series m a series cons3 :: (Serial m a, Serial m b, Serial m c) => (a->b->c->d) -> Series m d cons3 :: (a -> b -> c -> d) -> Series m d cons3 a -> b -> c -> d f = Series m d -> Series m d forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m d -> Series m d) -> Series m d -> Series m d forall a b. (a -> b) -> a -> b $ a -> b -> c -> d f (a -> b -> c -> d) -> Series m a -> Series m (b -> c -> d) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m (b -> c -> d) -> Series m b -> Series m (c -> d) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b forall (m :: * -> *) a. Serial m a => Series m a series Series m (c -> d) -> Series m c -> Series m d forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m c forall (m :: * -> *) a. Serial m a => Series m a series cons4 :: (Serial m a, Serial m b, Serial m c, Serial m d) => (a->b->c->d->e) -> Series m e cons4 :: (a -> b -> c -> d -> e) -> Series m e cons4 a -> b -> c -> d -> e f = Series m e -> Series m e forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m e -> Series m e) -> Series m e -> Series m e forall a b. (a -> b) -> a -> b $ a -> b -> c -> d -> e f (a -> b -> c -> d -> e) -> Series m a -> Series m (b -> c -> d -> e) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m (b -> c -> d -> e) -> Series m b -> Series m (c -> d -> e) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b forall (m :: * -> *) a. Serial m a => Series m a series Series m (c -> d -> e) -> Series m c -> Series m (d -> e) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m c forall (m :: * -> *) a. Serial m a => Series m a series Series m (d -> e) -> Series m d -> Series m e forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m d forall (m :: * -> *) a. Serial m a => Series m a series cons5 :: (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e) => (a->b->c->d->e->f) -> Series m f cons5 :: (a -> b -> c -> d -> e -> f) -> Series m f cons5 a -> b -> c -> d -> e -> f f = Series m f -> Series m f forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m f -> Series m f) -> Series m f -> Series m f forall a b. (a -> b) -> a -> b $ a -> b -> c -> d -> e -> f f (a -> b -> c -> d -> e -> f) -> Series m a -> Series m (b -> c -> d -> e -> f) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m (b -> c -> d -> e -> f) -> Series m b -> Series m (c -> d -> e -> f) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b forall (m :: * -> *) a. Serial m a => Series m a series Series m (c -> d -> e -> f) -> Series m c -> Series m (d -> e -> f) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m c forall (m :: * -> *) a. Serial m a => Series m a series Series m (d -> e -> f) -> Series m d -> Series m (e -> f) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m d forall (m :: * -> *) a. Serial m a => Series m a series Series m (e -> f) -> Series m e -> Series m f forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m e forall (m :: * -> *) a. Serial m a => Series m a series cons6 :: (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e, Serial m f) => (a->b->c->d->e->f->g) -> Series m g cons6 :: (a -> b -> c -> d -> e -> f -> g) -> Series m g cons6 a -> b -> c -> d -> e -> f -> g f = Series m g -> Series m g forall (m :: * -> *) a. Series m a -> Series m a decDepth (Series m g -> Series m g) -> Series m g -> Series m g forall a b. (a -> b) -> a -> b $ a -> b -> c -> d -> e -> f -> g f (a -> b -> c -> d -> e -> f -> g) -> Series m a -> Series m (b -> c -> d -> e -> f -> g) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m (b -> c -> d -> e -> f -> g) -> Series m b -> Series m (c -> d -> e -> f -> g) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b forall (m :: * -> *) a. Serial m a => Series m a series Series m (c -> d -> e -> f -> g) -> Series m c -> Series m (d -> e -> f -> g) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m c forall (m :: * -> *) a. Serial m a => Series m a series Series m (d -> e -> f -> g) -> Series m d -> Series m (e -> f -> g) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m d forall (m :: * -> *) a. Serial m a => Series m a series Series m (e -> f -> g) -> Series m e -> Series m (f -> g) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m e forall (m :: * -> *) a. Serial m a => Series m a series Series m (f -> g) -> Series m f -> Series m g forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m f forall (m :: * -> *) a. Serial m a => Series m a series alts0 :: Series m a -> Series m a alts0 :: Series m a -> Series m a alts0 Series m a s = Series m a s alts1 :: CoSerial m a => Series m b -> Series m (a->b) alts1 :: Series m b -> Series m (a -> b) alts1 Series m b rs = do Series m b rs <- Series m b -> Series m (Series m b) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m b rs Series m (a -> b) -> Series m (a -> b) -> Series m (a -> b) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m b -> Series m (a -> b) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m b rs) (Series m b -> Series m (a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs) alts2 :: (CoSerial m a, CoSerial m b) => Series m c -> Series m (a->b->c) alts2 :: Series m c -> Series m (a -> b -> c) alts2 Series m c rs = do Series m c rs <- Series m c -> Series m (Series m c) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m c rs Series m (a -> b -> c) -> Series m (a -> b -> c) -> Series m (a -> b -> c) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m (b -> c) -> Series m (a -> b -> c) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (b -> c) -> Series m (a -> b -> c)) -> Series m (b -> c) -> Series m (a -> b -> c) forall a b. (a -> b) -> a -> b $ Series m c -> Series m (b -> c) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m c rs) (Series m (b -> c) -> Series m (a -> b -> c) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (b -> c) -> Series m (a -> b -> c)) -> Series m (b -> c) -> Series m (a -> b -> c) forall a b. (a -> b) -> a -> b $ Series m c -> Series m (b -> c) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m c rs) alts3 :: (CoSerial m a, CoSerial m b, CoSerial m c) => Series m d -> Series m (a->b->c->d) alts3 :: Series m d -> Series m (a -> b -> c -> d) alts3 Series m d rs = do Series m d rs <- Series m d -> Series m (Series m d) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m d rs Series m (a -> b -> c -> d) -> Series m (a -> b -> c -> d) -> Series m (a -> b -> c -> d) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m (b -> c -> d) -> Series m (a -> b -> c -> d) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (b -> c -> d) -> Series m (a -> b -> c -> d)) -> Series m (b -> c -> d) -> Series m (a -> b -> c -> d) forall a b. (a -> b) -> a -> b $ Series m (c -> d) -> Series m (b -> c -> d) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (c -> d) -> Series m (b -> c -> d)) -> Series m (c -> d) -> Series m (b -> c -> d) forall a b. (a -> b) -> a -> b $ Series m d -> Series m (c -> d) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m d rs) (Series m (b -> c -> d) -> Series m (a -> b -> c -> d) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (b -> c -> d) -> Series m (a -> b -> c -> d)) -> Series m (b -> c -> d) -> Series m (a -> b -> c -> d) forall a b. (a -> b) -> a -> b $ Series m (c -> d) -> Series m (b -> c -> d) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (c -> d) -> Series m (b -> c -> d)) -> Series m (c -> d) -> Series m (b -> c -> d) forall a b. (a -> b) -> a -> b $ Series m d -> Series m (c -> d) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m d rs) alts4 :: (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d) => Series m e -> Series m (a->b->c->d->e) alts4 :: Series m e -> Series m (a -> b -> c -> d -> e) alts4 Series m e rs = do Series m e rs <- Series m e -> Series m (Series m e) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m e rs Series m (a -> b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e)) -> Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e) -> Series m (b -> c -> d -> e) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (c -> d -> e) -> Series m (b -> c -> d -> e)) -> Series m (c -> d -> e) -> Series m (b -> c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m (d -> e) -> Series m (c -> d -> e) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (d -> e) -> Series m (c -> d -> e)) -> Series m (d -> e) -> Series m (c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m e -> Series m (d -> e) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m e rs) (Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e)) -> Series m (b -> c -> d -> e) -> Series m (a -> b -> c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e) -> Series m (b -> c -> d -> e) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (c -> d -> e) -> Series m (b -> c -> d -> e)) -> Series m (c -> d -> e) -> Series m (b -> c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m (d -> e) -> Series m (c -> d -> e) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (d -> e) -> Series m (c -> d -> e)) -> Series m (d -> e) -> Series m (c -> d -> e) forall a b. (a -> b) -> a -> b $ Series m e -> Series m (d -> e) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m e rs) alts5 :: (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e) => Series m f -> Series m (a->b->c->d->e->f) alts5 :: Series m f -> Series m (a -> b -> c -> d -> e -> f) alts5 Series m f rs = do Series m f rs <- Series m f -> Series m (Series m f) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m f rs Series m (a -> b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f)) -> Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f)) -> Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (d -> e -> f) -> Series m (c -> d -> e -> f) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (d -> e -> f) -> Series m (c -> d -> e -> f)) -> Series m (d -> e -> f) -> Series m (c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (e -> f) -> Series m (d -> e -> f) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (e -> f) -> Series m (d -> e -> f)) -> Series m (e -> f) -> Series m (d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m f -> Series m (e -> f) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m f rs) (Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f)) -> Series m (b -> c -> d -> e -> f) -> Series m (a -> b -> c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f)) -> Series m (c -> d -> e -> f) -> Series m (b -> c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (d -> e -> f) -> Series m (c -> d -> e -> f) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (d -> e -> f) -> Series m (c -> d -> e -> f)) -> Series m (d -> e -> f) -> Series m (c -> d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m (e -> f) -> Series m (d -> e -> f) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (e -> f) -> Series m (d -> e -> f)) -> Series m (e -> f) -> Series m (d -> e -> f) forall a b. (a -> b) -> a -> b $ Series m f -> Series m (e -> f) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m f rs) alts6 :: (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e, CoSerial m f) => Series m g -> Series m (a->b->c->d->e->f->g) alts6 :: Series m g -> Series m (a -> b -> c -> d -> e -> f -> g) alts6 Series m g rs = do Series m g rs <- Series m g -> Series m (Series m g) forall (m :: * -> *) a. Series m a -> Series m (Series m a) fixDepth Series m g rs Series m (a -> b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) forall (m :: * -> *) a. Series m a -> Series m a -> Series m a decDepthChecked (Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g)) -> Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g)) -> Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g)) -> Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (e -> f -> g) -> Series m (d -> e -> f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (e -> f -> g) -> Series m (d -> e -> f -> g)) -> Series m (e -> f -> g) -> Series m (d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (f -> g) -> Series m (e -> f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM (Series m (f -> g) -> Series m (e -> f -> g)) -> Series m (f -> g) -> Series m (e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m g -> Series m (f -> g) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m g rs) (Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g)) -> Series m (b -> c -> d -> e -> f -> g) -> Series m (a -> b -> c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g)) -> Series m (c -> d -> e -> f -> g) -> Series m (b -> c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g)) -> Series m (d -> e -> f -> g) -> Series m (c -> d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (e -> f -> g) -> Series m (d -> e -> f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (e -> f -> g) -> Series m (d -> e -> f -> g)) -> Series m (e -> f -> g) -> Series m (d -> e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m (f -> g) -> Series m (e -> f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m (f -> g) -> Series m (e -> f -> g)) -> Series m (f -> g) -> Series m (e -> f -> g) forall a b. (a -> b) -> a -> b $ Series m g -> Series m (f -> g) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m g rs) -- | Same as 'alts1', but preserves the depth. newtypeAlts :: CoSerial m a => Series m b -> Series m (a->b) newtypeAlts :: Series m b -> Series m (a -> b) newtypeAlts = Series m b -> Series m (a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries -- }}} ------------------------------ -- Generic instances ------------------------------ -- {{{ class GSerial m f where gSeries :: Series m (f a) class GCoSerial m f where gCoseries :: Series m b -> Series m (f a -> b) #if __GLASGOW_HASKELL__ >= 702 instance {-# OVERLAPPABLE #-} GSerial m f => GSerial m (M1 i c f) where gSeries :: Series m (M1 i c f a) gSeries = f a -> M1 i c f a forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p M1 (f a -> M1 i c f a) -> Series m (f a) -> Series m (M1 i c f a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (f a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries {-# INLINE gSeries #-} instance GCoSerial m f => GCoSerial m (M1 i c f) where gCoseries :: Series m b -> Series m (M1 i c f a -> b) gCoseries Series m b rs = ((f a -> b) -> (M1 i c f a -> f a) -> M1 i c f a -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . M1 i c f a -> f a forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p unM1) ((f a -> b) -> M1 i c f a -> b) -> Series m (f a -> b) -> Series m (M1 i c f a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (f a -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries Series m b rs {-# INLINE gCoseries #-} instance Serial m c => GSerial m (K1 i c) where gSeries :: Series m (K1 i c a) gSeries = c -> K1 i c a forall k i c (p :: k). c -> K1 i c p K1 (c -> K1 i c a) -> Series m c -> Series m (K1 i c a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m c forall (m :: * -> *) a. Serial m a => Series m a series {-# INLINE gSeries #-} instance CoSerial m c => GCoSerial m (K1 i c) where gCoseries :: Series m b -> Series m (K1 i c a -> b) gCoseries Series m b rs = ((c -> b) -> (K1 i c a -> c) -> K1 i c a -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . K1 i c a -> c forall i c k (p :: k). K1 i c p -> c unK1) ((c -> b) -> K1 i c a -> b) -> Series m (c -> b) -> Series m (K1 i c a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (c -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs {-# INLINE gCoseries #-} instance GSerial m U1 where gSeries :: Series m (U1 a) gSeries = U1 a -> Series m (U1 a) forall (f :: * -> *) a. Applicative f => a -> f a pure U1 a forall k (p :: k). U1 p U1 {-# INLINE gSeries #-} instance GCoSerial m U1 where gCoseries :: Series m b -> Series m (U1 a -> b) gCoseries Series m b rs = Series m b -> Series m (U1 a -> b) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m b rs {-# INLINE gCoseries #-} instance GSerial m V1 where gSeries :: Series m (V1 a) gSeries = Series m (V1 a) forall (m :: * -> *) a. MonadPlus m => m a mzero {-# INLINE gSeries #-} instance GCoSerial m V1 where gCoseries :: Series m b -> Series m (V1 a -> b) gCoseries = Series m (V1 a -> b) -> Series m b -> Series m (V1 a -> b) forall a b. a -> b -> a const (Series m (V1 a -> b) -> Series m b -> Series m (V1 a -> b)) -> Series m (V1 a -> b) -> Series m b -> Series m (V1 a -> b) forall a b. (a -> b) -> a -> b $ (V1 a -> b) -> Series m (V1 a -> b) forall (m :: * -> *) a. Monad m => a -> m a return (\V1 a a -> V1 a a V1 a -> b -> b `seq` let x :: t x = t x in b forall t. t x) {-# INLINE gCoseries #-} instance (Monad m, GSerial m a, GSerial m b) => GSerial m (a :*: b) where gSeries :: Series m ((:*:) a b a) gSeries = a a -> b a -> (:*:) a b a forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> g p -> (:*:) f g p (:*:) (a a -> b a -> (:*:) a b a) -> Series m (a a) -> Series m (b a -> (:*:) a b a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (a a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries Series m (b a -> (:*:) a b a) -> Series m (b a) -> Series m ((:*:) a b a) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m (b a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries {-# INLINE gSeries #-} instance (Monad m, GCoSerial m a, GCoSerial m b) => GCoSerial m (a :*: b) where gCoseries :: Series m b -> Series m ((:*:) a b a -> b) gCoseries Series m b rs = (a a -> b a -> b) -> (:*:) a b a -> b forall (f :: * -> *) p (g :: * -> *) t. (f p -> g p -> t) -> (:*:) f g p -> t uncur ((a a -> b a -> b) -> (:*:) a b a -> b) -> Series m (a a -> b a -> b) -> Series m ((:*:) a b a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (b a -> b) -> Series m (a a -> b a -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries (Series m b -> Series m (b a -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries Series m b rs) where uncur :: (f p -> g p -> t) -> (:*:) f g p -> t uncur f p -> g p -> t f (f p x :*: g p y) = f p -> g p -> t f f p x g p y {-# INLINE gCoseries #-} instance (Monad m, GSerial m a, GSerial m b) => GSerial m (a :+: b) where gSeries :: Series m ((:+:) a b a) gSeries = (a a -> (:+:) a b a forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p L1 (a a -> (:+:) a b a) -> Series m (a a) -> Series m ((:+:) a b a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (a a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries) Series m ((:+:) a b a) -> Series m ((:+:) a b a) -> Series m ((:+:) a b a) forall (m :: * -> *) a. MonadLogic m => m a -> m a -> m a `interleave` (b a -> (:+:) a b a forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p R1 (b a -> (:+:) a b a) -> Series m (b a) -> Series m ((:+:) a b a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (b a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries) {-# INLINE gSeries #-} instance (Monad m, GCoSerial m a, GCoSerial m b) => GCoSerial m (a :+: b) where gCoseries :: Series m b -> Series m ((:+:) a b a -> b) gCoseries Series m b rs = Series m b -> Series m (a a -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries Series m b rs Series m (a a -> b) -> ((a a -> b) -> Series m ((:+:) a b a -> b)) -> Series m ((:+:) a b a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \a a -> b f -> Series m b -> Series m (b a -> b) forall (m :: * -> *) (f :: * -> *) b a. GCoSerial m f => Series m b -> Series m (f a -> b) gCoseries Series m b rs Series m (b a -> b) -> ((b a -> b) -> Series m ((:+:) a b a -> b)) -> Series m ((:+:) a b a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b a -> b g -> ((:+:) a b a -> b) -> Series m ((:+:) a b a -> b) forall (m :: * -> *) a. Monad m => a -> m a return (((:+:) a b a -> b) -> Series m ((:+:) a b a -> b)) -> ((:+:) a b a -> b) -> Series m ((:+:) a b a -> b) forall a b. (a -> b) -> a -> b $ \(:+:) a b a e -> case (:+:) a b a e of L1 a a x -> a a -> b f a a x R1 b a y -> b a -> b g b a y {-# INLINE gCoseries #-} instance {-# OVERLAPPING #-} GSerial m f => GSerial m (C1 c f) where gSeries :: Series m (C1 c f a) gSeries = f a -> C1 c f a forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p M1 (f a -> C1 c f a) -> Series m (f a) -> Series m (C1 c f a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (f a) -> Series m (f a) forall (m :: * -> *) a. Series m a -> Series m a decDepth Series m (f a) forall (m :: * -> *) (f :: * -> *) a. GSerial m f => Series m (f a) gSeries {-# INLINE gSeries #-} #endif -- }}} ------------------------------ -- Instances for basic types ------------------------------ -- {{{ instance Monad m => Serial m () where series :: Series m () series = () -> Series m () forall (m :: * -> *) a. Monad m => a -> m a return () instance Monad m => CoSerial m () where coseries :: Series m b -> Series m (() -> b) coseries Series m b rs = Series m b -> Series m (() -> b) forall (m :: * -> *) b a. Monad m => m b -> m (a -> b) constM Series m b rs instance Monad m => Serial m Integer where series :: Series m Integer series = M Integer -> Integer forall a. M a -> a unM (M Integer -> Integer) -> Series m (M Integer) -> Series m Integer forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Integer) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Integer where coseries :: Series m b -> Series m (Integer -> b) coseries = ((M Integer -> b) -> Integer -> b) -> Series m (M Integer -> b) -> Series m (Integer -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Integer -> b) -> (Integer -> M Integer) -> Integer -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Integer -> M Integer forall a. a -> M a M) (Series m (M Integer -> b) -> Series m (Integer -> b)) -> (Series m b -> Series m (M Integer -> b)) -> Series m b -> Series m (Integer -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Integer -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Natural where series :: Series m Natural series = N Natural -> Natural forall a. N a -> a unN (N Natural -> Natural) -> Series m (N Natural) -> Series m Natural forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Natural) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Natural where coseries :: Series m b -> Series m (Natural -> b) coseries = ((N Natural -> b) -> Natural -> b) -> Series m (N Natural -> b) -> Series m (Natural -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Natural -> b) -> (Natural -> N Natural) -> Natural -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Natural -> N Natural forall a. a -> N a N) (Series m (N Natural -> b) -> Series m (Natural -> b)) -> (Series m b -> Series m (N Natural -> b)) -> Series m b -> Series m (Natural -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Natural -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Int where series :: Series m Depth series = M Depth -> Depth forall a. M a -> a unM (M Depth -> Depth) -> Series m (M Depth) -> Series m Depth forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Depth) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Int where coseries :: Series m b -> Series m (Depth -> b) coseries = ((M Depth -> b) -> Depth -> b) -> Series m (M Depth -> b) -> Series m (Depth -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Depth -> b) -> (Depth -> M Depth) -> Depth -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Depth -> M Depth forall a. a -> M a M) (Series m (M Depth -> b) -> Series m (Depth -> b)) -> (Series m b -> Series m (M Depth -> b)) -> Series m b -> Series m (Depth -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Depth -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Word where series :: Series m Word series = N Word -> Word forall a. N a -> a unN (N Word -> Word) -> Series m (N Word) -> Series m Word forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Word) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Word where coseries :: Series m b -> Series m (Word -> b) coseries = ((N Word -> b) -> Word -> b) -> Series m (N Word -> b) -> Series m (Word -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Word -> b) -> (Word -> N Word) -> Word -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Word -> N Word forall a. a -> N a N) (Series m (N Word -> b) -> Series m (Word -> b)) -> (Series m b -> Series m (N Word -> b)) -> Series m b -> Series m (Word -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Word -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Int8 where series :: Series m Int8 series = M Int8 -> Int8 forall a. M a -> a unM (M Int8 -> Int8) -> Series m (M Int8) -> Series m Int8 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Int8) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Int8 where coseries :: Series m b -> Series m (Int8 -> b) coseries = ((M Int8 -> b) -> Int8 -> b) -> Series m (M Int8 -> b) -> Series m (Int8 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Int8 -> b) -> (Int8 -> M Int8) -> Int8 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Int8 -> M Int8 forall a. a -> M a M) (Series m (M Int8 -> b) -> Series m (Int8 -> b)) -> (Series m b -> Series m (M Int8 -> b)) -> Series m b -> Series m (Int8 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Int8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Word8 where series :: Series m Word8 series = N Word8 -> Word8 forall a. N a -> a unN (N Word8 -> Word8) -> Series m (N Word8) -> Series m Word8 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Word8) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Word8 where coseries :: Series m b -> Series m (Word8 -> b) coseries = ((N Word8 -> b) -> Word8 -> b) -> Series m (N Word8 -> b) -> Series m (Word8 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Word8 -> b) -> (Word8 -> N Word8) -> Word8 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Word8 -> N Word8 forall a. a -> N a N) (Series m (N Word8 -> b) -> Series m (Word8 -> b)) -> (Series m b -> Series m (N Word8 -> b)) -> Series m b -> Series m (Word8 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Word8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Int16 where series :: Series m Int16 series = M Int16 -> Int16 forall a. M a -> a unM (M Int16 -> Int16) -> Series m (M Int16) -> Series m Int16 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Int16) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Int16 where coseries :: Series m b -> Series m (Int16 -> b) coseries = ((M Int16 -> b) -> Int16 -> b) -> Series m (M Int16 -> b) -> Series m (Int16 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Int16 -> b) -> (Int16 -> M Int16) -> Int16 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Int16 -> M Int16 forall a. a -> M a M) (Series m (M Int16 -> b) -> Series m (Int16 -> b)) -> (Series m b -> Series m (M Int16 -> b)) -> Series m b -> Series m (Int16 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Int16 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Word16 where series :: Series m Word16 series = N Word16 -> Word16 forall a. N a -> a unN (N Word16 -> Word16) -> Series m (N Word16) -> Series m Word16 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Word16) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Word16 where coseries :: Series m b -> Series m (Word16 -> b) coseries = ((N Word16 -> b) -> Word16 -> b) -> Series m (N Word16 -> b) -> Series m (Word16 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Word16 -> b) -> (Word16 -> N Word16) -> Word16 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Word16 -> N Word16 forall a. a -> N a N) (Series m (N Word16 -> b) -> Series m (Word16 -> b)) -> (Series m b -> Series m (N Word16 -> b)) -> Series m b -> Series m (Word16 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Word16 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Int32 where series :: Series m Int32 series = M Int32 -> Int32 forall a. M a -> a unM (M Int32 -> Int32) -> Series m (M Int32) -> Series m Int32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Int32) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Int32 where coseries :: Series m b -> Series m (Int32 -> b) coseries = ((M Int32 -> b) -> Int32 -> b) -> Series m (M Int32 -> b) -> Series m (Int32 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Int32 -> b) -> (Int32 -> M Int32) -> Int32 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Int32 -> M Int32 forall a. a -> M a M) (Series m (M Int32 -> b) -> Series m (Int32 -> b)) -> (Series m b -> Series m (M Int32 -> b)) -> Series m b -> Series m (Int32 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Int32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Word32 where series :: Series m Word32 series = N Word32 -> Word32 forall a. N a -> a unN (N Word32 -> Word32) -> Series m (N Word32) -> Series m Word32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Word32) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Word32 where coseries :: Series m b -> Series m (Word32 -> b) coseries = ((N Word32 -> b) -> Word32 -> b) -> Series m (N Word32 -> b) -> Series m (Word32 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Word32 -> b) -> (Word32 -> N Word32) -> Word32 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Word32 -> N Word32 forall a. a -> N a N) (Series m (N Word32 -> b) -> Series m (Word32 -> b)) -> (Series m b -> Series m (N Word32 -> b)) -> Series m b -> Series m (Word32 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Word32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Int64 where series :: Series m Int64 series = M Int64 -> Int64 forall a. M a -> a unM (M Int64 -> Int64) -> Series m (M Int64) -> Series m Int64 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (M Int64) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Int64 where coseries :: Series m b -> Series m (Int64 -> b) coseries = ((M Int64 -> b) -> Int64 -> b) -> Series m (M Int64 -> b) -> Series m (Int64 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((M Int64 -> b) -> (Int64 -> M Int64) -> Int64 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Int64 -> M Int64 forall a. a -> M a M) (Series m (M Int64 -> b) -> Series m (Int64 -> b)) -> (Series m b -> Series m (M Int64 -> b)) -> Series m b -> Series m (Int64 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (M Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries instance Monad m => Serial m Word64 where series :: Series m Word64 series = N Word64 -> Word64 forall a. N a -> a unN (N Word64 -> Word64) -> Series m (N Word64) -> Series m Word64 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (N Word64) forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Word64 where coseries :: Series m b -> Series m (Word64 -> b) coseries = ((N Word64 -> b) -> Word64 -> b) -> Series m (N Word64 -> b) -> Series m (Word64 -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((N Word64 -> b) -> (Word64 -> N Word64) -> Word64 -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Word64 -> N Word64 forall a. a -> N a N) (Series m (N Word64 -> b) -> Series m (Word64 -> b)) -> (Series m b -> Series m (N Word64 -> b)) -> Series m b -> Series m (Word64 -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (N Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries -- | 'N' is a wrapper for 'Integral' types that causes only non-negative values -- to be generated. Generated functions of type @N a -> b@ do not distinguish -- different negative values of @a@. newtype N a = N { N a -> a unN :: a } deriving (N a -> N a -> Bool (N a -> N a -> Bool) -> (N a -> N a -> Bool) -> Eq (N a) forall a. Eq a => N a -> N a -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: N a -> N a -> Bool $c/= :: forall a. Eq a => N a -> N a -> Bool == :: N a -> N a -> Bool $c== :: forall a. Eq a => N a -> N a -> Bool Eq, Eq (N a) Eq (N a) -> (N a -> N a -> Ordering) -> (N a -> N a -> Bool) -> (N a -> N a -> Bool) -> (N a -> N a -> Bool) -> (N a -> N a -> Bool) -> (N a -> N a -> N a) -> (N a -> N a -> N a) -> Ord (N a) N a -> N a -> Bool N a -> N a -> Ordering N a -> N a -> N a forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a forall a. Ord a => Eq (N a) forall a. Ord a => N a -> N a -> Bool forall a. Ord a => N a -> N a -> Ordering forall a. Ord a => N a -> N a -> N a min :: N a -> N a -> N a $cmin :: forall a. Ord a => N a -> N a -> N a max :: N a -> N a -> N a $cmax :: forall a. Ord a => N a -> N a -> N a >= :: N a -> N a -> Bool $c>= :: forall a. Ord a => N a -> N a -> Bool > :: N a -> N a -> Bool $c> :: forall a. Ord a => N a -> N a -> Bool <= :: N a -> N a -> Bool $c<= :: forall a. Ord a => N a -> N a -> Bool < :: N a -> N a -> Bool $c< :: forall a. Ord a => N a -> N a -> Bool compare :: N a -> N a -> Ordering $ccompare :: forall a. Ord a => N a -> N a -> Ordering $cp1Ord :: forall a. Ord a => Eq (N a) Ord, Depth -> N a -> ShowS [N a] -> ShowS N a -> String (Depth -> N a -> ShowS) -> (N a -> String) -> ([N a] -> ShowS) -> Show (N a) forall a. Show a => Depth -> N a -> ShowS forall a. Show a => [N a] -> ShowS forall a. Show a => N a -> String forall a. (Depth -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a showList :: [N a] -> ShowS $cshowList :: forall a. Show a => [N a] -> ShowS show :: N a -> String $cshow :: forall a. Show a => N a -> String showsPrec :: Depth -> N a -> ShowS $cshowsPrec :: forall a. Show a => Depth -> N a -> ShowS Show) instance Real a => Real (N a) where toRational :: N a -> Rational toRational (N a x) = a -> Rational forall a. Real a => a -> Rational toRational a x instance Enum a => Enum (N a) where toEnum :: Depth -> N a toEnum Depth x = a -> N a forall a. a -> N a N (Depth -> a forall a. Enum a => Depth -> a toEnum Depth x) fromEnum :: N a -> Depth fromEnum (N a x) = a -> Depth forall a. Enum a => a -> Depth fromEnum a x instance Num a => Num (N a) where N a x + :: N a -> N a -> N a + N a y = a -> N a forall a. a -> N a N (a x a -> a -> a forall a. Num a => a -> a -> a + a y) N a x * :: N a -> N a -> N a * N a y = a -> N a forall a. a -> N a N (a x a -> a -> a forall a. Num a => a -> a -> a * a y) negate :: N a -> N a negate (N a x) = a -> N a forall a. a -> N a N (a -> a forall a. Num a => a -> a negate a x) abs :: N a -> N a abs (N a x) = a -> N a forall a. a -> N a N (a -> a forall a. Num a => a -> a abs a x) signum :: N a -> N a signum (N a x) = a -> N a forall a. a -> N a N (a -> a forall a. Num a => a -> a signum a x) fromInteger :: Integer -> N a fromInteger Integer x = a -> N a forall a. a -> N a N (Integer -> a forall a. Num a => Integer -> a fromInteger Integer x) instance Integral a => Integral (N a) where quotRem :: N a -> N a -> (N a, N a) quotRem (N a x) (N a y) = (a -> N a forall a. a -> N a N a q, a -> N a forall a. a -> N a N a r) where (a q, a r) = a x a -> a -> (a, a) forall a. Integral a => a -> a -> (a, a) `quotRem` a y toInteger :: N a -> Integer toInteger (N a x) = a -> Integer forall a. Integral a => a -> Integer toInteger a x instance (Num a, Enum a, Serial m a) => Serial m (N a) where series :: Series m (N a) series = (Depth -> [N a]) -> Series m (N a) forall a (m :: * -> *). (Depth -> [a]) -> Series m a generate ((Depth -> [N a]) -> Series m (N a)) -> (Depth -> [N a]) -> Series m (N a) forall a b. (a -> b) -> a -> b $ \Depth d -> Depth -> [N a] -> [N a] forall a. Depth -> [a] -> [a] take (Depth dDepth -> Depth -> Depth forall a. Num a => a -> a -> a +Depth 1) [N a 0..] instance (Integral a, Monad m) => CoSerial m (N a) where coseries :: Series m b -> Series m (N a -> b) coseries Series m b rs = -- This is a recursive function, because @alts1 rs@ typically calls -- back to 'coseries' (but with lower depth). -- -- The recursion stops when depth == 0. Then alts1 produces a constant -- function, and doesn't call back to 'coseries'. Series m b -> Series m b forall (m :: * -> *) a. Series m a -> Series m a alts0 Series m b rs Series m b -> (b -> Series m (N a -> b)) -> Series m (N a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b z -> Series m b -> Series m (N a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs Series m (N a -> b) -> ((N a -> b) -> Series m (N a -> b)) -> Series m (N a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \N a -> b f -> (N a -> b) -> Series m (N a -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((N a -> b) -> Series m (N a -> b)) -> (N a -> b) -> Series m (N a -> b) forall a b. (a -> b) -> a -> b $ \(N a i) -> if a i a -> a -> Bool forall a. Ord a => a -> a -> Bool > a 0 then N a -> b f (a -> N a forall a. a -> N a N (a -> N a) -> a -> N a forall a b. (a -> b) -> a -> b $ a ia -> a -> a forall a. Num a => a -> a -> a -a 1) else b z -- | 'M' is a helper type to generate values of a signed type of increasing magnitude. newtype M a = M { M a -> a unM :: a } deriving (M a -> M a -> Bool (M a -> M a -> Bool) -> (M a -> M a -> Bool) -> Eq (M a) forall a. Eq a => M a -> M a -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: M a -> M a -> Bool $c/= :: forall a. Eq a => M a -> M a -> Bool == :: M a -> M a -> Bool $c== :: forall a. Eq a => M a -> M a -> Bool Eq, Eq (M a) Eq (M a) -> (M a -> M a -> Ordering) -> (M a -> M a -> Bool) -> (M a -> M a -> Bool) -> (M a -> M a -> Bool) -> (M a -> M a -> Bool) -> (M a -> M a -> M a) -> (M a -> M a -> M a) -> Ord (M a) M a -> M a -> Bool M a -> M a -> Ordering M a -> M a -> M a forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a forall a. Ord a => Eq (M a) forall a. Ord a => M a -> M a -> Bool forall a. Ord a => M a -> M a -> Ordering forall a. Ord a => M a -> M a -> M a min :: M a -> M a -> M a $cmin :: forall a. Ord a => M a -> M a -> M a max :: M a -> M a -> M a $cmax :: forall a. Ord a => M a -> M a -> M a >= :: M a -> M a -> Bool $c>= :: forall a. Ord a => M a -> M a -> Bool > :: M a -> M a -> Bool $c> :: forall a. Ord a => M a -> M a -> Bool <= :: M a -> M a -> Bool $c<= :: forall a. Ord a => M a -> M a -> Bool < :: M a -> M a -> Bool $c< :: forall a. Ord a => M a -> M a -> Bool compare :: M a -> M a -> Ordering $ccompare :: forall a. Ord a => M a -> M a -> Ordering $cp1Ord :: forall a. Ord a => Eq (M a) Ord, Depth -> M a -> ShowS [M a] -> ShowS M a -> String (Depth -> M a -> ShowS) -> (M a -> String) -> ([M a] -> ShowS) -> Show (M a) forall a. Show a => Depth -> M a -> ShowS forall a. Show a => [M a] -> ShowS forall a. Show a => M a -> String forall a. (Depth -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a showList :: [M a] -> ShowS $cshowList :: forall a. Show a => [M a] -> ShowS show :: M a -> String $cshow :: forall a. Show a => M a -> String showsPrec :: Depth -> M a -> ShowS $cshowsPrec :: forall a. Show a => Depth -> M a -> ShowS Show) instance Real a => Real (M a) where toRational :: M a -> Rational toRational (M a x) = a -> Rational forall a. Real a => a -> Rational toRational a x instance Enum a => Enum (M a) where toEnum :: Depth -> M a toEnum Depth x = a -> M a forall a. a -> M a M (Depth -> a forall a. Enum a => Depth -> a toEnum Depth x) fromEnum :: M a -> Depth fromEnum (M a x) = a -> Depth forall a. Enum a => a -> Depth fromEnum a x instance Num a => Num (M a) where M a x + :: M a -> M a -> M a + M a y = a -> M a forall a. a -> M a M (a x a -> a -> a forall a. Num a => a -> a -> a + a y) M a x * :: M a -> M a -> M a * M a y = a -> M a forall a. a -> M a M (a x a -> a -> a forall a. Num a => a -> a -> a * a y) negate :: M a -> M a negate (M a x) = a -> M a forall a. a -> M a M (a -> a forall a. Num a => a -> a negate a x) abs :: M a -> M a abs (M a x) = a -> M a forall a. a -> M a M (a -> a forall a. Num a => a -> a abs a x) signum :: M a -> M a signum (M a x) = a -> M a forall a. a -> M a M (a -> a forall a. Num a => a -> a signum a x) fromInteger :: Integer -> M a fromInteger Integer x = a -> M a forall a. a -> M a M (Integer -> a forall a. Num a => Integer -> a fromInteger Integer x) instance Integral a => Integral (M a) where quotRem :: M a -> M a -> (M a, M a) quotRem (M a x) (M a y) = (a -> M a forall a. a -> M a M a q, a -> M a forall a. a -> M a M a r) where (a q, a r) = a x a -> a -> (a, a) forall a. Integral a => a -> a -> (a, a) `quotRem` a y toInteger :: M a -> Integer toInteger (M a x) = a -> Integer forall a. Integral a => a -> Integer toInteger a x instance (Num a, Enum a, Monad m) => Serial m (M a) where series :: Series m (M a) series = Series m (M a) forall (m :: * -> *). Series m (M a) others Series m (M a) -> Series m (M a) -> Series m (M a) forall (m :: * -> *) a. MonadLogic m => m a -> m a -> m a `interleave` Series m (M a) forall (m :: * -> *). Series m (M a) positives where positives :: Series m (M a) positives = (Depth -> [M a]) -> Series m (M a) forall a (m :: * -> *). (Depth -> [a]) -> Series m a generate ((Depth -> [M a]) -> Series m (M a)) -> (Depth -> [M a]) -> Series m (M a) forall a b. (a -> b) -> a -> b $ \Depth d -> Depth -> [M a] -> [M a] forall a. Depth -> [a] -> [a] take Depth d [M a 1..] others :: Series m (M a) others = (Depth -> [M a]) -> Series m (M a) forall a (m :: * -> *). (Depth -> [a]) -> Series m a generate ((Depth -> [M a]) -> Series m (M a)) -> (Depth -> [M a]) -> Series m (M a) forall a b. (a -> b) -> a -> b $ \Depth d -> Depth -> [M a] -> [M a] forall a. Depth -> [a] -> [a] take (Depth dDepth -> Depth -> Depth forall a. Num a => a -> a -> a +Depth 1) [M a 0,-M a 1..] instance (Ord a, Num a, Monad m) => CoSerial m (M a) where coseries :: Series m b -> Series m (M a -> b) coseries Series m b rs = Series m b -> Series m b forall (m :: * -> *) a. Series m a -> Series m a alts0 Series m b rs Series m b -> (b -> Series m (M a -> b)) -> Series m (M a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b z -> Series m b -> Series m (M (M a) -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs Series m (M (M a) -> b) -> ((M (M a) -> b) -> Series m (M a -> b)) -> Series m (M a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \M (M a) -> b f -> Series m b -> Series m (M (M a) -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs Series m (M (M a) -> b) -> ((M (M a) -> b) -> Series m (M a -> b)) -> Series m (M a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \M (M a) -> b g -> (M a -> b) -> Series m (M a -> b) forall (f :: * -> *) a. Applicative f => a -> f a pure ((M a -> b) -> Series m (M a -> b)) -> (M a -> b) -> Series m (M a -> b) forall a b. (a -> b) -> a -> b $ \ M a i -> case M a -> M a -> Ordering forall a. Ord a => a -> a -> Ordering compare M a i M a 0 of Ordering GT -> M (M a) -> b f (M a -> M (M a) forall a. a -> M a M (M a i M a -> M a -> M a forall a. Num a => a -> a -> a - M a 1)) Ordering LT -> M (M a) -> b g (M a -> M (M a) forall a. a -> M a M (M a -> M a forall a. Num a => a -> a abs M a i M a -> M a -> M a forall a. Num a => a -> a -> a - M a 1)) Ordering EQ -> b z instance Monad m => Serial m Float where series :: Series m Float series = Series m (Integer, Depth) forall (m :: * -> *) a. Serial m a => Series m a series Series m (Integer, Depth) -> ((Integer, Depth) -> Series m Float) -> Series m Float forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \(Integer sig, Depth exp) -> Bool -> Series m () forall (f :: * -> *). Alternative f => Bool -> f () guard (Integer -> Bool forall a. Integral a => a -> Bool odd Integer sig Bool -> Bool -> Bool || Integer sigInteger -> Integer -> Bool forall a. Eq a => a -> a -> Bool ==Integer 0 Bool -> Bool -> Bool && Depth expDepth -> Depth -> Bool forall a. Eq a => a -> a -> Bool ==Depth 0) Series m () -> Series m Float -> Series m Float forall (m :: * -> *) a b. Monad m => m a -> m b -> m b >> Float -> Series m Float forall (m :: * -> *) a. Monad m => a -> m a return (Integer -> Depth -> Float forall a. RealFloat a => Integer -> Depth -> a encodeFloat Integer sig Depth exp) instance Monad m => CoSerial m Float where coseries :: Series m b -> Series m (Float -> b) coseries Series m b rs = Series m b -> Series m ((Integer, Depth) -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs Series m ((Integer, Depth) -> b) -> (((Integer, Depth) -> b) -> Series m (Float -> b)) -> Series m (Float -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \(Integer, Depth) -> b f -> (Float -> b) -> Series m (Float -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((Float -> b) -> Series m (Float -> b)) -> (Float -> b) -> Series m (Float -> b) forall a b. (a -> b) -> a -> b $ (Integer, Depth) -> b f ((Integer, Depth) -> b) -> (Float -> (Integer, Depth)) -> Float -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Float -> (Integer, Depth) forall a. RealFloat a => a -> (Integer, Depth) decodeFloat instance Monad m => Serial m Double where series :: Series m Double series = (Float -> Double forall a b. (Real a, Fractional b) => a -> b realToFrac :: Float -> Double) (Float -> Double) -> Series m Float -> Series m Double forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m Float forall (m :: * -> *) a. Serial m a => Series m a series instance Monad m => CoSerial m Double where coseries :: Series m b -> Series m (Double -> b) coseries Series m b rs = ((Float -> b) -> (Double -> Float) -> Double -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . (Double -> Float forall a b. (Real a, Fractional b) => a -> b realToFrac :: Double -> Float)) ((Float -> b) -> Double -> b) -> Series m (Float -> b) -> Series m (Double -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (Float -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs instance (Integral i, Serial m i) => Serial m (Ratio i) where series :: Series m (Ratio i) series = (i, Positive i) -> Ratio i forall a. Integral a => (a, Positive a) -> Ratio a pairToRatio ((i, Positive i) -> Ratio i) -> Series m (i, Positive i) -> Series m (Ratio i) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (i, Positive i) forall (m :: * -> *) a. Serial m a => Series m a series where pairToRatio :: (a, Positive a) -> Ratio a pairToRatio (a n, Positive a d) = a n a -> a -> Ratio a forall a. Integral a => a -> a -> Ratio a % a d instance (Integral i, CoSerial m i) => CoSerial m (Ratio i) where coseries :: Series m b -> Series m (Ratio i -> b) coseries Series m b rs = (((i, i) -> b) -> (Ratio i -> (i, i)) -> Ratio i -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Ratio i -> (i, i) forall b. Ratio b -> (b, b) ratioToPair) (((i, i) -> b) -> Ratio i -> b) -> Series m ((i, i) -> b) -> Series m (Ratio i -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m ((i, i) -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs where ratioToPair :: Ratio b -> (b, b) ratioToPair Ratio b r = (Ratio b -> b forall a. Ratio a -> a numerator Ratio b r, Ratio b -> b forall a. Ratio a -> a denominator Ratio b r) instance Monad m => Serial m Char where series :: Series m Char series = (Depth -> String) -> Series m Char forall a (m :: * -> *). (Depth -> [a]) -> Series m a generate ((Depth -> String) -> Series m Char) -> (Depth -> String) -> Series m Char forall a b. (a -> b) -> a -> b $ \Depth d -> Depth -> ShowS forall a. Depth -> [a] -> [a] take (Depth dDepth -> Depth -> Depth forall a. Num a => a -> a -> a +Depth 1) [Char 'a'..Char 'z'] instance Monad m => CoSerial m Char where coseries :: Series m b -> Series m (Char -> b) coseries Series m b rs = Series m b -> Series m (N Depth -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b rs Series m (N Depth -> b) -> ((N Depth -> b) -> Series m (Char -> b)) -> Series m (Char -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \N Depth -> b f -> (Char -> b) -> Series m (Char -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((Char -> b) -> Series m (Char -> b)) -> (Char -> b) -> Series m (Char -> b) forall a b. (a -> b) -> a -> b $ \Char c -> N Depth -> b f (Depth -> N Depth forall a. a -> N a N (Char -> Depth forall a. Enum a => a -> Depth fromEnum Char c Depth -> Depth -> Depth forall a. Num a => a -> a -> a - Char -> Depth forall a. Enum a => a -> Depth fromEnum Char 'a')) instance (Serial m a, Serial m b) => Serial m (a,b) where series :: Series m (a, b) series = (a -> b -> (a, b)) -> Series m (a, b) forall (m :: * -> *) a b c. (Serial m a, Serial m b) => (a -> b -> c) -> Series m c cons2 (,) instance (CoSerial m a, CoSerial m b) => CoSerial m (a,b) where coseries :: Series m b -> Series m ((a, b) -> b) coseries Series m b rs = (a -> b -> b) -> (a, b) -> b forall a b c. (a -> b -> c) -> (a, b) -> c uncurry ((a -> b -> b) -> (a, b) -> b) -> Series m (a -> b -> b) -> Series m ((a, b) -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b -> b) forall (m :: * -> *) a b c. (CoSerial m a, CoSerial m b) => Series m c -> Series m (a -> b -> c) alts2 Series m b rs instance (Serial m a, Serial m b, Serial m c) => Serial m (a,b,c) where series :: Series m (a, b, c) series = (a -> b -> c -> (a, b, c)) -> Series m (a, b, c) forall (m :: * -> *) a b c d. (Serial m a, Serial m b, Serial m c) => (a -> b -> c -> d) -> Series m d cons3 (,,) instance (CoSerial m a, CoSerial m b, CoSerial m c) => CoSerial m (a,b,c) where coseries :: Series m b -> Series m ((a, b, c) -> b) coseries Series m b rs = (a -> b -> c -> b) -> (a, b, c) -> b forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d uncurry3 ((a -> b -> c -> b) -> (a, b, c) -> b) -> Series m (a -> b -> c -> b) -> Series m ((a, b, c) -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b -> c -> b) forall (m :: * -> *) a b c d. (CoSerial m a, CoSerial m b, CoSerial m c) => Series m d -> Series m (a -> b -> c -> d) alts3 Series m b rs instance (Serial m a, Serial m b, Serial m c, Serial m d) => Serial m (a,b,c,d) where series :: Series m (a, b, c, d) series = (a -> b -> c -> d -> (a, b, c, d)) -> Series m (a, b, c, d) forall (m :: * -> *) a b c d e. (Serial m a, Serial m b, Serial m c, Serial m d) => (a -> b -> c -> d -> e) -> Series m e cons4 (,,,) instance (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d) => CoSerial m (a,b,c,d) where coseries :: Series m b -> Series m ((a, b, c, d) -> b) coseries Series m b rs = (a -> b -> c -> d -> b) -> (a, b, c, d) -> b forall a b c d e. (a -> b -> c -> d -> e) -> (a, b, c, d) -> e uncurry4 ((a -> b -> c -> d -> b) -> (a, b, c, d) -> b) -> Series m (a -> b -> c -> d -> b) -> Series m ((a, b, c, d) -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b -> c -> d -> b) forall (m :: * -> *) a b c d e. (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d) => Series m e -> Series m (a -> b -> c -> d -> e) alts4 Series m b rs instance (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e) => Serial m (a,b,c,d,e) where series :: Series m (a, b, c, d, e) series = (a -> b -> c -> d -> e -> (a, b, c, d, e)) -> Series m (a, b, c, d, e) forall (m :: * -> *) a b c d e f. (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e) => (a -> b -> c -> d -> e -> f) -> Series m f cons5 (,,,,) instance (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e) => CoSerial m (a,b,c,d,e) where coseries :: Series m b -> Series m ((a, b, c, d, e) -> b) coseries Series m b rs = (a -> b -> c -> d -> e -> b) -> (a, b, c, d, e) -> b forall a b c d e f. (a -> b -> c -> d -> e -> f) -> (a, b, c, d, e) -> f uncurry5 ((a -> b -> c -> d -> e -> b) -> (a, b, c, d, e) -> b) -> Series m (a -> b -> c -> d -> e -> b) -> Series m ((a, b, c, d, e) -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b -> c -> d -> e -> b) forall (m :: * -> *) a b c d e f. (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e) => Series m f -> Series m (a -> b -> c -> d -> e -> f) alts5 Series m b rs instance (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e, Serial m f) => Serial m (a,b,c,d,e,f) where series :: Series m (a, b, c, d, e, f) series = (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f)) -> Series m (a, b, c, d, e, f) forall (m :: * -> *) a b c d e f g. (Serial m a, Serial m b, Serial m c, Serial m d, Serial m e, Serial m f) => (a -> b -> c -> d -> e -> f -> g) -> Series m g cons6 (,,,,,) instance (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e, CoSerial m f) => CoSerial m (a,b,c,d,e,f) where coseries :: Series m b -> Series m ((a, b, c, d, e, f) -> b) coseries Series m b rs = (a -> b -> c -> d -> e -> f -> b) -> (a, b, c, d, e, f) -> b forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> (a, b, c, d, e, f) -> g uncurry6 ((a -> b -> c -> d -> e -> f -> b) -> (a, b, c, d, e, f) -> b) -> Series m (a -> b -> c -> d -> e -> f -> b) -> Series m ((a, b, c, d, e, f) -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b -> c -> d -> e -> f -> b) forall (m :: * -> *) a b c d e f g. (CoSerial m a, CoSerial m b, CoSerial m c, CoSerial m d, CoSerial m e, CoSerial m f) => Series m g -> Series m (a -> b -> c -> d -> e -> f -> g) alts6 Series m b rs instance Monad m => Serial m Bool where series :: Series m Bool series = Bool -> Series m Bool forall a (m :: * -> *). a -> Series m a cons0 Bool True Series m Bool -> Series m Bool -> Series m Bool forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ Bool -> Series m Bool forall a (m :: * -> *). a -> Series m a cons0 Bool False instance Monad m => CoSerial m Bool where coseries :: Series m b -> Series m (Bool -> b) coseries Series m b rs = Series m b rs Series m b -> (b -> Series m (Bool -> b)) -> Series m (Bool -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b r1 -> Series m b rs Series m b -> (b -> Series m (Bool -> b)) -> Series m (Bool -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b r2 -> (Bool -> b) -> Series m (Bool -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((Bool -> b) -> Series m (Bool -> b)) -> (Bool -> b) -> Series m (Bool -> b) forall a b. (a -> b) -> a -> b $ \Bool x -> if Bool x then b r1 else b r2 instance Monad m => Serial m Ordering where series :: Series m Ordering series = Ordering -> Series m Ordering forall a (m :: * -> *). a -> Series m a cons0 Ordering LT Series m Ordering -> Series m Ordering -> Series m Ordering forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ Ordering -> Series m Ordering forall a (m :: * -> *). a -> Series m a cons0 Ordering EQ Series m Ordering -> Series m Ordering -> Series m Ordering forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ Ordering -> Series m Ordering forall a (m :: * -> *). a -> Series m a cons0 Ordering GT instance Monad m => CoSerial m Ordering where coseries :: Series m b -> Series m (Ordering -> b) coseries Series m b rs = Series m b rs Series m b -> (b -> Series m (Ordering -> b)) -> Series m (Ordering -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b r1 -> Series m b rs Series m b -> (b -> Series m (Ordering -> b)) -> Series m (Ordering -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b r2 -> Series m b rs Series m b -> (b -> Series m (Ordering -> b)) -> Series m (Ordering -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b r3 -> (Ordering -> b) -> Series m (Ordering -> b) forall (f :: * -> *) a. Applicative f => a -> f a pure ((Ordering -> b) -> Series m (Ordering -> b)) -> (Ordering -> b) -> Series m (Ordering -> b) forall a b. (a -> b) -> a -> b $ \Ordering x -> case Ordering x of Ordering LT -> b r1 Ordering EQ -> b r2 Ordering GT -> b r3 instance (Serial m a) => Serial m (Maybe a) where series :: Series m (Maybe a) series = Maybe a -> Series m (Maybe a) forall a (m :: * -> *). a -> Series m a cons0 Maybe a forall a. Maybe a Nothing Series m (Maybe a) -> Series m (Maybe a) -> Series m (Maybe a) forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ (a -> Maybe a) -> Series m (Maybe a) forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b cons1 a -> Maybe a forall a. a -> Maybe a Just instance (CoSerial m a) => CoSerial m (Maybe a) where coseries :: Series m b -> Series m (Maybe a -> b) coseries Series m b rs = b -> (a -> b) -> Maybe a -> b forall b a. b -> (a -> b) -> Maybe a -> b maybe (b -> (a -> b) -> Maybe a -> b) -> Series m b -> Series m ((a -> b) -> Maybe a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m b forall (m :: * -> *) a. Series m a -> Series m a alts0 Series m b rs Series m ((a -> b) -> Maybe a -> b) -> Series m (a -> b) -> Series m (Maybe a -> b) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b -> Series m (a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs instance (Serial m a, Serial m b) => Serial m (Either a b) where series :: Series m (Either a b) series = (a -> Either a b) -> Series m (Either a b) forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b cons1 a -> Either a b forall a b. a -> Either a b Left Series m (Either a b) -> Series m (Either a b) -> Series m (Either a b) forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ (b -> Either a b) -> Series m (Either a b) forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b cons1 b -> Either a b forall a b. b -> Either a b Right instance (CoSerial m a, CoSerial m b) => CoSerial m (Either a b) where coseries :: Series m b -> Series m (Either a b -> b) coseries Series m b rs = (a -> b) -> (b -> b) -> Either a b -> b forall a c b. (a -> c) -> (b -> c) -> Either a b -> c either ((a -> b) -> (b -> b) -> Either a b -> b) -> Series m (a -> b) -> Series m ((b -> b) -> Either a b -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m b -> Series m (a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs Series m ((b -> b) -> Either a b -> b) -> Series m (b -> b) -> Series m (Either a b -> b) forall (m :: * -> *) a b. Monad m => Series m (a -> b) -> Series m a -> Series m b <~> Series m b -> Series m (b -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) alts1 Series m b rs instance Serial m a => Serial m [a] where series :: Series m [a] series = [a] -> Series m [a] forall a (m :: * -> *). a -> Series m a cons0 [] Series m [a] -> Series m [a] -> Series m [a] forall (m :: * -> *) a. Monad m => Series m a -> Series m a -> Series m a \/ (a -> [a] -> [a]) -> Series m [a] forall (m :: * -> *) a b c. (Serial m a, Serial m b) => (a -> b -> c) -> Series m c cons2 (:) instance CoSerial m a => CoSerial m [a] where coseries :: Series m b -> Series m ([a] -> b) coseries Series m b rs = Series m b -> Series m b forall (m :: * -> *) a. Series m a -> Series m a alts0 Series m b rs Series m b -> (b -> Series m ([a] -> b)) -> Series m ([a] -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \b y -> Series m b -> Series m (a -> [a] -> b) forall (m :: * -> *) a b c. (CoSerial m a, CoSerial m b) => Series m c -> Series m (a -> b -> c) alts2 Series m b rs Series m (a -> [a] -> b) -> ((a -> [a] -> b) -> Series m ([a] -> b)) -> Series m ([a] -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \a -> [a] -> b f -> ([a] -> b) -> Series m ([a] -> b) forall (m :: * -> *) a. Monad m => a -> m a return (([a] -> b) -> Series m ([a] -> b)) -> ([a] -> b) -> Series m ([a] -> b) forall a b. (a -> b) -> a -> b $ \[a] xs -> case [a] xs of [] -> b y; a x:[a] xs' -> a -> [a] -> b f a x [a] xs' instance Serial m a => Serial m (NE.NonEmpty a) where series :: Series m (NonEmpty a) series = (a -> [a] -> NonEmpty a) -> Series m (NonEmpty a) forall (m :: * -> *) a b c. (Serial m a, Serial m b) => (a -> b -> c) -> Series m c cons2 a -> [a] -> NonEmpty a forall a. a -> [a] -> NonEmpty a (NE.:|) instance CoSerial m a => CoSerial m (NE.NonEmpty a) where coseries :: Series m b -> Series m (NonEmpty a -> b) coseries Series m b rs = Series m b -> Series m (a -> [a] -> b) forall (m :: * -> *) a b c. (CoSerial m a, CoSerial m b) => Series m c -> Series m (a -> b -> c) alts2 Series m b rs Series m (a -> [a] -> b) -> ((a -> [a] -> b) -> Series m (NonEmpty a -> b)) -> Series m (NonEmpty a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \a -> [a] -> b f -> (NonEmpty a -> b) -> Series m (NonEmpty a -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((NonEmpty a -> b) -> Series m (NonEmpty a -> b)) -> (NonEmpty a -> b) -> Series m (NonEmpty a -> b) forall a b. (a -> b) -> a -> b $ \(a x NE.:| [a] xs') -> a -> [a] -> b f a x [a] xs' #if MIN_VERSION_base(4,4,0) instance Serial m a => Serial m (Complex a) where #else instance (RealFloat a, Serial m a) => Serial m (Complex a) where #endif series :: Series m (Complex a) series = (a -> a -> Complex a) -> Series m (Complex a) forall (m :: * -> *) a b c. (Serial m a, Serial m b) => (a -> b -> c) -> Series m c cons2 a -> a -> Complex a forall a. a -> a -> Complex a (:+) #if MIN_VERSION_base(4,4,0) instance CoSerial m a => CoSerial m (Complex a) where #else instance (RealFloat a, CoSerial m a) => CoSerial m (Complex a) where #endif coseries :: Series m b -> Series m (Complex a -> b) coseries Series m b rs = Series m b -> Series m (a -> a -> b) forall (m :: * -> *) a b c. (CoSerial m a, CoSerial m b) => Series m c -> Series m (a -> b -> c) alts2 Series m b rs Series m (a -> a -> b) -> ((a -> a -> b) -> Series m (Complex a -> b)) -> Series m (Complex a -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \a -> a -> b f -> (Complex a -> b) -> Series m (Complex a -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((Complex a -> b) -> Series m (Complex a -> b)) -> (Complex a -> b) -> Series m (Complex a -> b) forall a b. (a -> b) -> a -> b $ \(a x :+ a xs') -> a -> a -> b f a x a xs' instance Monad m => Serial m Void where series :: Series m Void series = Series m Void forall (m :: * -> *) a. MonadPlus m => m a mzero instance Monad m => CoSerial m Void where coseries :: Series m b -> Series m (Void -> b) coseries = Series m (Void -> b) -> Series m b -> Series m (Void -> b) forall a b. a -> b -> a const (Series m (Void -> b) -> Series m b -> Series m (Void -> b)) -> Series m (Void -> b) -> Series m b -> Series m (Void -> b) forall a b. (a -> b) -> a -> b $ (Void -> b) -> Series m (Void -> b) forall (m :: * -> *) a. Monad m => a -> m a return Void -> b forall a. Void -> a absurd instance (CoSerial m a, Serial m b) => Serial m (a->b) where series :: Series m (a -> b) series = Series m b -> Series m (a -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries Series m b forall (m :: * -> *) a. Serial m a => Series m a series -- Thanks to Ralf Hinze for the definition of coseries -- using the nest auxiliary. instance (Serial m a, CoSerial m a, Serial m b, CoSerial m b) => CoSerial m (a->b) where coseries :: Series m b -> Series m ((a -> b) -> b) coseries Series m b r = do [a] args <- Series m a -> Series m [a] forall (m :: * -> *) a. MonadLogic m => m a -> m [a] unwind Series m a forall (m :: * -> *) a. Serial m a => Series m a series [b] -> b g <- Series m b -> [a] -> Series m ([b] -> b) forall a b (m :: * -> *) c. (Serial m b, CoSerial m b) => Series m c -> [a] -> Series m ([b] -> c) nest Series m b r [a] args ((a -> b) -> b) -> Series m ((a -> b) -> b) forall (m :: * -> *) a. Monad m => a -> m a return (((a -> b) -> b) -> Series m ((a -> b) -> b)) -> ((a -> b) -> b) -> Series m ((a -> b) -> b) forall a b. (a -> b) -> a -> b $ \a -> b f -> [b] -> b g ([b] -> b) -> [b] -> b forall a b. (a -> b) -> a -> b $ (a -> b) -> [a] -> [b] forall a b. (a -> b) -> [a] -> [b] map a -> b f [a] args where nest :: forall a b m c . (Serial m b, CoSerial m b) => Series m c -> [a] -> Series m ([b] -> c) nest :: Series m c -> [a] -> Series m ([b] -> c) nest Series m c rs [a] args = do case [a] args of [] -> c -> [b] -> c forall a b. a -> b -> a const (c -> [b] -> c) -> Series m c -> Series m ([b] -> c) forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r `liftM` Series m c rs a _:[a] rest -> do let sf :: Series m (b -> [b] -> c) sf = Series m ([b] -> c) -> Series m (b -> [b] -> c) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries (Series m ([b] -> c) -> Series m (b -> [b] -> c)) -> Series m ([b] -> c) -> Series m (b -> [b] -> c) forall a b. (a -> b) -> a -> b $ Series m c -> [a] -> Series m ([b] -> c) forall a b (m :: * -> *) c. (Serial m b, CoSerial m b) => Series m c -> [a] -> Series m ([b] -> c) nest Series m c rs [a] rest b -> [b] -> c f <- Series m (b -> [b] -> c) sf ([b] -> c) -> Series m ([b] -> c) forall (m :: * -> *) a. Monad m => a -> m a return (([b] -> c) -> Series m ([b] -> c)) -> ([b] -> c) -> Series m ([b] -> c) forall a b. (a -> b) -> a -> b $ \(b b:[b] bs) -> b -> [b] -> c f b b [b] bs -- show the extension of a function (in part, bounded both by -- the number and depth of arguments) instance (Serial Identity a, Show a, Show b) => Show (a -> b) where show :: (a -> b) -> String show a -> b f = if Depth maxarheight Depth -> Depth -> Bool forall a. Eq a => a -> a -> Bool == Depth 1 Bool -> Bool -> Bool && Depth sumarwidth Depth -> Depth -> Depth forall a. Num a => a -> a -> a + [(String, String)] -> Depth forall (t :: * -> *) a. Foldable t => t a -> Depth length [(String, String)] ars Depth -> Depth -> Depth forall a. Num a => a -> a -> a * String -> Depth forall (t :: * -> *) a. Foldable t => t a -> Depth length String "->;" Depth -> Depth -> Bool forall a. Ord a => a -> a -> Bool < Depth widthLimit then String "{"String -> ShowS forall a. [a] -> [a] -> [a] ++ String -> [String] -> String forall a. [a] -> [[a]] -> [a] intercalate String ";" [String aString -> ShowS forall a. [a] -> [a] -> [a] ++String "->"String -> ShowS forall a. [a] -> [a] -> [a] ++String r | (String a,String r) <- [(String, String)] ars] String -> ShowS forall a. [a] -> [a] -> [a] ++String "}" else [String] -> String forall (t :: * -> *) a. Foldable t => t [a] -> [a] concat ([String] -> String) -> [String] -> String forall a b. (a -> b) -> a -> b $ [String aString -> ShowS forall a. [a] -> [a] -> [a] ++String "->\n"String -> ShowS forall a. [a] -> [a] -> [a] ++ShowS indent String r | (String a,String r) <- [(String, String)] ars] where ars :: [(String, String)] ars = Depth -> [(String, String)] -> [(String, String)] forall a. Depth -> [a] -> [a] take Depth lengthLimit [ (a -> String forall a. Show a => a -> String show a x, b -> String forall a. Show a => a -> String show (a -> b f a x)) | a x <- Depth -> Series Identity a -> [a] forall a. Depth -> Series Identity a -> [a] list Depth depthLimit Series Identity a forall (m :: * -> *) a. Serial m a => Series m a series ] maxarheight :: Depth maxarheight = [Depth] -> Depth forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a maximum [ Depth -> Depth -> Depth forall a. Ord a => a -> a -> a max (String -> Depth height String a) (String -> Depth height String r) | (String a,String r) <- [(String, String)] ars ] sumarwidth :: Depth sumarwidth = [Depth] -> Depth forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a sum [ String -> Depth forall (t :: * -> *) a. Foldable t => t a -> Depth length String a Depth -> Depth -> Depth forall a. Num a => a -> a -> a + String -> Depth forall (t :: * -> *) a. Foldable t => t a -> Depth length String r | (String a,String r) <- [(String, String)] ars] indent :: ShowS indent = [String] -> String unlines ([String] -> String) -> (String -> [String]) -> ShowS forall b c a. (b -> c) -> (a -> b) -> a -> c . ShowS -> [String] -> [String] forall a b. (a -> b) -> [a] -> [b] map (String " "String -> ShowS forall a. [a] -> [a] -> [a] ++) ([String] -> [String]) -> (String -> [String]) -> String -> [String] forall b c a. (b -> c) -> (a -> b) -> a -> c . String -> [String] lines height :: String -> Depth height = [String] -> Depth forall (t :: * -> *) a. Foldable t => t a -> Depth length ([String] -> Depth) -> (String -> [String]) -> String -> Depth forall b c a. (b -> c) -> (a -> b) -> a -> c . String -> [String] lines (Depth widthLimit,Depth lengthLimit,Depth depthLimit) = (Depth 80,Depth 20,Depth 3)::(Int,Int,Depth) instance (Monad m, Serial m (f (g a))) => Serial m (Compose f g a) where series :: Series m (Compose f g a) series = f (g a) -> Compose f g a forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1). f (g a) -> Compose f g a Compose (f (g a) -> Compose f g a) -> Series m (f (g a)) -> Series m (Compose f g a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m (f (g a)) forall (m :: * -> *) a. Serial m a => Series m a series instance (Monad m, CoSerial m (f (g a))) => CoSerial m (Compose f g a) where coseries :: Series m b -> Series m (Compose f g a -> b) coseries = ((f (g a) -> b) -> Compose f g a -> b) -> Series m (f (g a) -> b) -> Series m (Compose f g a -> b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((f (g a) -> b) -> (Compose f g a -> f (g a)) -> Compose f g a -> b forall b c a. (b -> c) -> (a -> b) -> a -> c . Compose f g a -> f (g a) forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2). Compose f g a -> f (g a) getCompose) (Series m (f (g a) -> b) -> Series m (Compose f g a -> b)) -> (Series m b -> Series m (f (g a) -> b)) -> Series m b -> Series m (Compose f g a -> b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Series m b -> Series m (f (g a) -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) coseries -- }}} ------------------------------ -- Convenient wrappers ------------------------------ -- {{{ -------------------------------------------------------------------------- -- | 'Positive' @x@ guarantees that \( x > 0 \). newtype Positive a = Positive { Positive a -> a getPositive :: a } deriving (Positive a -> Positive a -> Bool (Positive a -> Positive a -> Bool) -> (Positive a -> Positive a -> Bool) -> Eq (Positive a) forall a. Eq a => Positive a -> Positive a -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: Positive a -> Positive a -> Bool $c/= :: forall a. Eq a => Positive a -> Positive a -> Bool == :: Positive a -> Positive a -> Bool $c== :: forall a. Eq a => Positive a -> Positive a -> Bool Eq, Eq (Positive a) Eq (Positive a) -> (Positive a -> Positive a -> Ordering) -> (Positive a -> Positive a -> Bool) -> (Positive a -> Positive a -> Bool) -> (Positive a -> Positive a -> Bool) -> (Positive a -> Positive a -> Bool) -> (Positive a -> Positive a -> Positive a) -> (Positive a -> Positive a -> Positive a) -> Ord (Positive a) Positive a -> Positive a -> Bool Positive a -> Positive a -> Ordering Positive a -> Positive a -> Positive a forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a forall a. Ord a => Eq (Positive a) forall a. Ord a => Positive a -> Positive a -> Bool forall a. Ord a => Positive a -> Positive a -> Ordering forall a. Ord a => Positive a -> Positive a -> Positive a min :: Positive a -> Positive a -> Positive a $cmin :: forall a. Ord a => Positive a -> Positive a -> Positive a max :: Positive a -> Positive a -> Positive a $cmax :: forall a. Ord a => Positive a -> Positive a -> Positive a >= :: Positive a -> Positive a -> Bool $c>= :: forall a. Ord a => Positive a -> Positive a -> Bool > :: Positive a -> Positive a -> Bool $c> :: forall a. Ord a => Positive a -> Positive a -> Bool <= :: Positive a -> Positive a -> Bool $c<= :: forall a. Ord a => Positive a -> Positive a -> Bool < :: Positive a -> Positive a -> Bool $c< :: forall a. Ord a => Positive a -> Positive a -> Bool compare :: Positive a -> Positive a -> Ordering $ccompare :: forall a. Ord a => Positive a -> Positive a -> Ordering $cp1Ord :: forall a. Ord a => Eq (Positive a) Ord, a -> Positive b -> Positive a (a -> b) -> Positive a -> Positive b (forall a b. (a -> b) -> Positive a -> Positive b) -> (forall a b. a -> Positive b -> Positive a) -> Functor Positive forall a b. a -> Positive b -> Positive a forall a b. (a -> b) -> Positive a -> Positive b forall (f :: * -> *). (forall a b. (a -> b) -> f a -> f b) -> (forall a b. a -> f b -> f a) -> Functor f <$ :: a -> Positive b -> Positive a $c<$ :: forall a b. a -> Positive b -> Positive a fmap :: (a -> b) -> Positive a -> Positive b $cfmap :: forall a b. (a -> b) -> Positive a -> Positive b Functor, Positive a -> Bool (a -> m) -> Positive a -> m (a -> b -> b) -> b -> Positive a -> b (forall m. Monoid m => Positive m -> m) -> (forall m a. Monoid m => (a -> m) -> Positive a -> m) -> (forall m a. Monoid m => (a -> m) -> Positive a -> m) -> (forall a b. (a -> b -> b) -> b -> Positive a -> b) -> (forall a b. (a -> b -> b) -> b -> Positive a -> b) -> (forall b a. (b -> a -> b) -> b -> Positive a -> b) -> (forall b a. (b -> a -> b) -> b -> Positive a -> b) -> (forall a. (a -> a -> a) -> Positive a -> a) -> (forall a. (a -> a -> a) -> Positive a -> a) -> (forall a. Positive a -> [a]) -> (forall a. Positive a -> Bool) -> (forall a. Positive a -> Depth) -> (forall a. Eq a => a -> Positive a -> Bool) -> (forall a. Ord a => Positive a -> a) -> (forall a. Ord a => Positive a -> a) -> (forall a. Num a => Positive a -> a) -> (forall a. Num a => Positive a -> a) -> Foldable Positive forall a. Eq a => a -> Positive a -> Bool forall a. Num a => Positive a -> a forall a. Ord a => Positive a -> a forall m. Monoid m => Positive m -> m forall a. Positive a -> Bool forall a. Positive a -> Depth forall a. Positive a -> [a] forall a. (a -> a -> a) -> Positive a -> a forall m a. Monoid m => (a -> m) -> Positive a -> m forall b a. (b -> a -> b) -> b -> Positive a -> b forall a b. (a -> b -> b) -> b -> Positive a -> b forall (t :: * -> *). (forall m. Monoid m => t m -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. t a -> [a]) -> (forall a. t a -> Bool) -> (forall a. t a -> Depth) -> (forall a. Eq a => a -> t a -> Bool) -> (forall a. Ord a => t a -> a) -> (forall a. Ord a => t a -> a) -> (forall a. Num a => t a -> a) -> (forall a. Num a => t a -> a) -> Foldable t product :: Positive a -> a $cproduct :: forall a. Num a => Positive a -> a sum :: Positive a -> a $csum :: forall a. Num a => Positive a -> a minimum :: Positive a -> a $cminimum :: forall a. Ord a => Positive a -> a maximum :: Positive a -> a $cmaximum :: forall a. Ord a => Positive a -> a elem :: a -> Positive a -> Bool $celem :: forall a. Eq a => a -> Positive a -> Bool length :: Positive a -> Depth $clength :: forall a. Positive a -> Depth null :: Positive a -> Bool $cnull :: forall a. Positive a -> Bool toList :: Positive a -> [a] $ctoList :: forall a. Positive a -> [a] foldl1 :: (a -> a -> a) -> Positive a -> a $cfoldl1 :: forall a. (a -> a -> a) -> Positive a -> a foldr1 :: (a -> a -> a) -> Positive a -> a $cfoldr1 :: forall a. (a -> a -> a) -> Positive a -> a foldl' :: (b -> a -> b) -> b -> Positive a -> b $cfoldl' :: forall b a. (b -> a -> b) -> b -> Positive a -> b foldl :: (b -> a -> b) -> b -> Positive a -> b $cfoldl :: forall b a. (b -> a -> b) -> b -> Positive a -> b foldr' :: (a -> b -> b) -> b -> Positive a -> b $cfoldr' :: forall a b. (a -> b -> b) -> b -> Positive a -> b foldr :: (a -> b -> b) -> b -> Positive a -> b $cfoldr :: forall a b. (a -> b -> b) -> b -> Positive a -> b foldMap' :: (a -> m) -> Positive a -> m $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Positive a -> m foldMap :: (a -> m) -> Positive a -> m $cfoldMap :: forall m a. Monoid m => (a -> m) -> Positive a -> m fold :: Positive m -> m $cfold :: forall m. Monoid m => Positive m -> m Foldable, Functor Positive Foldable Positive Functor Positive -> Foldable Positive -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> Positive a -> f (Positive b)) -> (forall (f :: * -> *) a. Applicative f => Positive (f a) -> f (Positive a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> Positive a -> m (Positive b)) -> (forall (m :: * -> *) a. Monad m => Positive (m a) -> m (Positive a)) -> Traversable Positive (a -> f b) -> Positive a -> f (Positive b) forall (t :: * -> *). Functor t -> Foldable t -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b)) -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)) -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)) -> Traversable t forall (m :: * -> *) a. Monad m => Positive (m a) -> m (Positive a) forall (f :: * -> *) a. Applicative f => Positive (f a) -> f (Positive a) forall (m :: * -> *) a b. Monad m => (a -> m b) -> Positive a -> m (Positive b) forall (f :: * -> *) a b. Applicative f => (a -> f b) -> Positive a -> f (Positive b) sequence :: Positive (m a) -> m (Positive a) $csequence :: forall (m :: * -> *) a. Monad m => Positive (m a) -> m (Positive a) mapM :: (a -> m b) -> Positive a -> m (Positive b) $cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Positive a -> m (Positive b) sequenceA :: Positive (f a) -> f (Positive a) $csequenceA :: forall (f :: * -> *) a. Applicative f => Positive (f a) -> f (Positive a) traverse :: (a -> f b) -> Positive a -> f (Positive b) $ctraverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> Positive a -> f (Positive b) $cp2Traversable :: Foldable Positive $cp1Traversable :: Functor Positive Traversable) instance Real a => Real (Positive a) where toRational :: Positive a -> Rational toRational (Positive a x) = a -> Rational forall a. Real a => a -> Rational toRational a x instance (Num a, Bounded a) => Bounded (Positive a) where minBound :: Positive a minBound = a -> Positive a forall a. a -> Positive a Positive a 1 maxBound :: Positive a maxBound = a -> Positive a forall a. a -> Positive a Positive (a forall a. Bounded a => a maxBound :: a) instance Enum a => Enum (Positive a) where toEnum :: Depth -> Positive a toEnum Depth x = a -> Positive a forall a. a -> Positive a Positive (Depth -> a forall a. Enum a => Depth -> a toEnum Depth x) fromEnum :: Positive a -> Depth fromEnum (Positive a x) = a -> Depth forall a. Enum a => a -> Depth fromEnum a x instance Num a => Num (Positive a) where Positive a x + :: Positive a -> Positive a -> Positive a + Positive a y = a -> Positive a forall a. a -> Positive a Positive (a x a -> a -> a forall a. Num a => a -> a -> a + a y) Positive a x * :: Positive a -> Positive a -> Positive a * Positive a y = a -> Positive a forall a. a -> Positive a Positive (a x a -> a -> a forall a. Num a => a -> a -> a * a y) negate :: Positive a -> Positive a negate (Positive a x) = a -> Positive a forall a. a -> Positive a Positive (a -> a forall a. Num a => a -> a negate a x) abs :: Positive a -> Positive a abs (Positive a x) = a -> Positive a forall a. a -> Positive a Positive (a -> a forall a. Num a => a -> a abs a x) signum :: Positive a -> Positive a signum (Positive a x) = a -> Positive a forall a. a -> Positive a Positive (a -> a forall a. Num a => a -> a signum a x) fromInteger :: Integer -> Positive a fromInteger Integer x = a -> Positive a forall a. a -> Positive a Positive (Integer -> a forall a. Num a => Integer -> a fromInteger Integer x) instance Integral a => Integral (Positive a) where quotRem :: Positive a -> Positive a -> (Positive a, Positive a) quotRem (Positive a x) (Positive a y) = (a -> Positive a forall a. a -> Positive a Positive a q, a -> Positive a forall a. a -> Positive a Positive a r) where (a q, a r) = a x a -> a -> (a, a) forall a. Integral a => a -> a -> (a, a) `quotRem` a y toInteger :: Positive a -> Integer toInteger (Positive a x) = a -> Integer forall a. Integral a => a -> Integer toInteger a x instance (Num a, Ord a, Serial m a) => Serial m (Positive a) where series :: Series m (Positive a) series = a -> Positive a forall a. a -> Positive a Positive (a -> Positive a) -> Series m a -> Series m (Positive a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m a -> (a -> Bool) -> Series m a forall (m :: * -> *) a. Series m a -> (a -> Bool) -> Series m a `suchThat` (a -> a -> Bool forall a. Ord a => a -> a -> Bool > a 0) instance Show a => Show (Positive a) where showsPrec :: Depth -> Positive a -> ShowS showsPrec Depth n (Positive a x) = Depth -> a -> ShowS forall a. Show a => Depth -> a -> ShowS showsPrec Depth n a x -- | 'NonNegative' @x@ guarantees that \( x \ge 0 \). newtype NonNegative a = NonNegative { NonNegative a -> a getNonNegative :: a } deriving (NonNegative a -> NonNegative a -> Bool (NonNegative a -> NonNegative a -> Bool) -> (NonNegative a -> NonNegative a -> Bool) -> Eq (NonNegative a) forall a. Eq a => NonNegative a -> NonNegative a -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: NonNegative a -> NonNegative a -> Bool $c/= :: forall a. Eq a => NonNegative a -> NonNegative a -> Bool == :: NonNegative a -> NonNegative a -> Bool $c== :: forall a. Eq a => NonNegative a -> NonNegative a -> Bool Eq, Eq (NonNegative a) Eq (NonNegative a) -> (NonNegative a -> NonNegative a -> Ordering) -> (NonNegative a -> NonNegative a -> Bool) -> (NonNegative a -> NonNegative a -> Bool) -> (NonNegative a -> NonNegative a -> Bool) -> (NonNegative a -> NonNegative a -> Bool) -> (NonNegative a -> NonNegative a -> NonNegative a) -> (NonNegative a -> NonNegative a -> NonNegative a) -> Ord (NonNegative a) NonNegative a -> NonNegative a -> Bool NonNegative a -> NonNegative a -> Ordering NonNegative a -> NonNegative a -> NonNegative a forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a forall a. Ord a => Eq (NonNegative a) forall a. Ord a => NonNegative a -> NonNegative a -> Bool forall a. Ord a => NonNegative a -> NonNegative a -> Ordering forall a. Ord a => NonNegative a -> NonNegative a -> NonNegative a min :: NonNegative a -> NonNegative a -> NonNegative a $cmin :: forall a. Ord a => NonNegative a -> NonNegative a -> NonNegative a max :: NonNegative a -> NonNegative a -> NonNegative a $cmax :: forall a. Ord a => NonNegative a -> NonNegative a -> NonNegative a >= :: NonNegative a -> NonNegative a -> Bool $c>= :: forall a. Ord a => NonNegative a -> NonNegative a -> Bool > :: NonNegative a -> NonNegative a -> Bool $c> :: forall a. Ord a => NonNegative a -> NonNegative a -> Bool <= :: NonNegative a -> NonNegative a -> Bool $c<= :: forall a. Ord a => NonNegative a -> NonNegative a -> Bool < :: NonNegative a -> NonNegative a -> Bool $c< :: forall a. Ord a => NonNegative a -> NonNegative a -> Bool compare :: NonNegative a -> NonNegative a -> Ordering $ccompare :: forall a. Ord a => NonNegative a -> NonNegative a -> Ordering $cp1Ord :: forall a. Ord a => Eq (NonNegative a) Ord, a -> NonNegative b -> NonNegative a (a -> b) -> NonNegative a -> NonNegative b (forall a b. (a -> b) -> NonNegative a -> NonNegative b) -> (forall a b. a -> NonNegative b -> NonNegative a) -> Functor NonNegative forall a b. a -> NonNegative b -> NonNegative a forall a b. (a -> b) -> NonNegative a -> NonNegative b forall (f :: * -> *). (forall a b. (a -> b) -> f a -> f b) -> (forall a b. a -> f b -> f a) -> Functor f <$ :: a -> NonNegative b -> NonNegative a $c<$ :: forall a b. a -> NonNegative b -> NonNegative a fmap :: (a -> b) -> NonNegative a -> NonNegative b $cfmap :: forall a b. (a -> b) -> NonNegative a -> NonNegative b Functor, NonNegative a -> Bool (a -> m) -> NonNegative a -> m (a -> b -> b) -> b -> NonNegative a -> b (forall m. Monoid m => NonNegative m -> m) -> (forall m a. Monoid m => (a -> m) -> NonNegative a -> m) -> (forall m a. Monoid m => (a -> m) -> NonNegative a -> m) -> (forall a b. (a -> b -> b) -> b -> NonNegative a -> b) -> (forall a b. (a -> b -> b) -> b -> NonNegative a -> b) -> (forall b a. (b -> a -> b) -> b -> NonNegative a -> b) -> (forall b a. (b -> a -> b) -> b -> NonNegative a -> b) -> (forall a. (a -> a -> a) -> NonNegative a -> a) -> (forall a. (a -> a -> a) -> NonNegative a -> a) -> (forall a. NonNegative a -> [a]) -> (forall a. NonNegative a -> Bool) -> (forall a. NonNegative a -> Depth) -> (forall a. Eq a => a -> NonNegative a -> Bool) -> (forall a. Ord a => NonNegative a -> a) -> (forall a. Ord a => NonNegative a -> a) -> (forall a. Num a => NonNegative a -> a) -> (forall a. Num a => NonNegative a -> a) -> Foldable NonNegative forall a. Eq a => a -> NonNegative a -> Bool forall a. Num a => NonNegative a -> a forall a. Ord a => NonNegative a -> a forall m. Monoid m => NonNegative m -> m forall a. NonNegative a -> Bool forall a. NonNegative a -> Depth forall a. NonNegative a -> [a] forall a. (a -> a -> a) -> NonNegative a -> a forall m a. Monoid m => (a -> m) -> NonNegative a -> m forall b a. (b -> a -> b) -> b -> NonNegative a -> b forall a b. (a -> b -> b) -> b -> NonNegative a -> b forall (t :: * -> *). (forall m. Monoid m => t m -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. t a -> [a]) -> (forall a. t a -> Bool) -> (forall a. t a -> Depth) -> (forall a. Eq a => a -> t a -> Bool) -> (forall a. Ord a => t a -> a) -> (forall a. Ord a => t a -> a) -> (forall a. Num a => t a -> a) -> (forall a. Num a => t a -> a) -> Foldable t product :: NonNegative a -> a $cproduct :: forall a. Num a => NonNegative a -> a sum :: NonNegative a -> a $csum :: forall a. Num a => NonNegative a -> a minimum :: NonNegative a -> a $cminimum :: forall a. Ord a => NonNegative a -> a maximum :: NonNegative a -> a $cmaximum :: forall a. Ord a => NonNegative a -> a elem :: a -> NonNegative a -> Bool $celem :: forall a. Eq a => a -> NonNegative a -> Bool length :: NonNegative a -> Depth $clength :: forall a. NonNegative a -> Depth null :: NonNegative a -> Bool $cnull :: forall a. NonNegative a -> Bool toList :: NonNegative a -> [a] $ctoList :: forall a. NonNegative a -> [a] foldl1 :: (a -> a -> a) -> NonNegative a -> a $cfoldl1 :: forall a. (a -> a -> a) -> NonNegative a -> a foldr1 :: (a -> a -> a) -> NonNegative a -> a $cfoldr1 :: forall a. (a -> a -> a) -> NonNegative a -> a foldl' :: (b -> a -> b) -> b -> NonNegative a -> b $cfoldl' :: forall b a. (b -> a -> b) -> b -> NonNegative a -> b foldl :: (b -> a -> b) -> b -> NonNegative a -> b $cfoldl :: forall b a. (b -> a -> b) -> b -> NonNegative a -> b foldr' :: (a -> b -> b) -> b -> NonNegative a -> b $cfoldr' :: forall a b. (a -> b -> b) -> b -> NonNegative a -> b foldr :: (a -> b -> b) -> b -> NonNegative a -> b $cfoldr :: forall a b. (a -> b -> b) -> b -> NonNegative a -> b foldMap' :: (a -> m) -> NonNegative a -> m $cfoldMap' :: forall m a. Monoid m => (a -> m) -> NonNegative a -> m foldMap :: (a -> m) -> NonNegative a -> m $cfoldMap :: forall m a. Monoid m => (a -> m) -> NonNegative a -> m fold :: NonNegative m -> m $cfold :: forall m. Monoid m => NonNegative m -> m Foldable, Functor NonNegative Foldable NonNegative Functor NonNegative -> Foldable NonNegative -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonNegative a -> f (NonNegative b)) -> (forall (f :: * -> *) a. Applicative f => NonNegative (f a) -> f (NonNegative a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonNegative a -> m (NonNegative b)) -> (forall (m :: * -> *) a. Monad m => NonNegative (m a) -> m (NonNegative a)) -> Traversable NonNegative (a -> f b) -> NonNegative a -> f (NonNegative b) forall (t :: * -> *). Functor t -> Foldable t -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b)) -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)) -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)) -> Traversable t forall (m :: * -> *) a. Monad m => NonNegative (m a) -> m (NonNegative a) forall (f :: * -> *) a. Applicative f => NonNegative (f a) -> f (NonNegative a) forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonNegative a -> m (NonNegative b) forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonNegative a -> f (NonNegative b) sequence :: NonNegative (m a) -> m (NonNegative a) $csequence :: forall (m :: * -> *) a. Monad m => NonNegative (m a) -> m (NonNegative a) mapM :: (a -> m b) -> NonNegative a -> m (NonNegative b) $cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonNegative a -> m (NonNegative b) sequenceA :: NonNegative (f a) -> f (NonNegative a) $csequenceA :: forall (f :: * -> *) a. Applicative f => NonNegative (f a) -> f (NonNegative a) traverse :: (a -> f b) -> NonNegative a -> f (NonNegative b) $ctraverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonNegative a -> f (NonNegative b) $cp2Traversable :: Foldable NonNegative $cp1Traversable :: Functor NonNegative Traversable) instance Real a => Real (NonNegative a) where toRational :: NonNegative a -> Rational toRational (NonNegative a x) = a -> Rational forall a. Real a => a -> Rational toRational a x instance (Num a, Bounded a) => Bounded (NonNegative a) where minBound :: NonNegative a minBound = a -> NonNegative a forall a. a -> NonNegative a NonNegative a 0 maxBound :: NonNegative a maxBound = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a forall a. Bounded a => a maxBound :: a) instance Enum a => Enum (NonNegative a) where toEnum :: Depth -> NonNegative a toEnum Depth x = a -> NonNegative a forall a. a -> NonNegative a NonNegative (Depth -> a forall a. Enum a => Depth -> a toEnum Depth x) fromEnum :: NonNegative a -> Depth fromEnum (NonNegative a x) = a -> Depth forall a. Enum a => a -> Depth fromEnum a x instance Num a => Num (NonNegative a) where NonNegative a x + :: NonNegative a -> NonNegative a -> NonNegative a + NonNegative a y = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a x a -> a -> a forall a. Num a => a -> a -> a + a y) NonNegative a x * :: NonNegative a -> NonNegative a -> NonNegative a * NonNegative a y = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a x a -> a -> a forall a. Num a => a -> a -> a * a y) negate :: NonNegative a -> NonNegative a negate (NonNegative a x) = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a -> a forall a. Num a => a -> a negate a x) abs :: NonNegative a -> NonNegative a abs (NonNegative a x) = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a -> a forall a. Num a => a -> a abs a x) signum :: NonNegative a -> NonNegative a signum (NonNegative a x) = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a -> a forall a. Num a => a -> a signum a x) fromInteger :: Integer -> NonNegative a fromInteger Integer x = a -> NonNegative a forall a. a -> NonNegative a NonNegative (Integer -> a forall a. Num a => Integer -> a fromInteger Integer x) instance Integral a => Integral (NonNegative a) where quotRem :: NonNegative a -> NonNegative a -> (NonNegative a, NonNegative a) quotRem (NonNegative a x) (NonNegative a y) = (a -> NonNegative a forall a. a -> NonNegative a NonNegative a q, a -> NonNegative a forall a. a -> NonNegative a NonNegative a r) where (a q, a r) = a x a -> a -> (a, a) forall a. Integral a => a -> a -> (a, a) `quotRem` a y toInteger :: NonNegative a -> Integer toInteger (NonNegative a x) = a -> Integer forall a. Integral a => a -> Integer toInteger a x instance (Num a, Ord a, Serial m a) => Serial m (NonNegative a) where series :: Series m (NonNegative a) series = a -> NonNegative a forall a. a -> NonNegative a NonNegative (a -> NonNegative a) -> Series m a -> Series m (NonNegative a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m a -> (a -> Bool) -> Series m a forall (m :: * -> *) a. Series m a -> (a -> Bool) -> Series m a `suchThat` (a -> a -> Bool forall a. Ord a => a -> a -> Bool >= a 0) instance Show a => Show (NonNegative a) where showsPrec :: Depth -> NonNegative a -> ShowS showsPrec Depth n (NonNegative a x) = Depth -> a -> ShowS forall a. Show a => Depth -> a -> ShowS showsPrec Depth n a x -- | 'NonZero' @x@ guarantees that \( x \ne 0 \). newtype NonZero a = NonZero { NonZero a -> a getNonZero :: a } deriving (NonZero a -> NonZero a -> Bool (NonZero a -> NonZero a -> Bool) -> (NonZero a -> NonZero a -> Bool) -> Eq (NonZero a) forall a. Eq a => NonZero a -> NonZero a -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: NonZero a -> NonZero a -> Bool $c/= :: forall a. Eq a => NonZero a -> NonZero a -> Bool == :: NonZero a -> NonZero a -> Bool $c== :: forall a. Eq a => NonZero a -> NonZero a -> Bool Eq, Eq (NonZero a) Eq (NonZero a) -> (NonZero a -> NonZero a -> Ordering) -> (NonZero a -> NonZero a -> Bool) -> (NonZero a -> NonZero a -> Bool) -> (NonZero a -> NonZero a -> Bool) -> (NonZero a -> NonZero a -> Bool) -> (NonZero a -> NonZero a -> NonZero a) -> (NonZero a -> NonZero a -> NonZero a) -> Ord (NonZero a) NonZero a -> NonZero a -> Bool NonZero a -> NonZero a -> Ordering NonZero a -> NonZero a -> NonZero a forall a. Eq a -> (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a forall a. Ord a => Eq (NonZero a) forall a. Ord a => NonZero a -> NonZero a -> Bool forall a. Ord a => NonZero a -> NonZero a -> Ordering forall a. Ord a => NonZero a -> NonZero a -> NonZero a min :: NonZero a -> NonZero a -> NonZero a $cmin :: forall a. Ord a => NonZero a -> NonZero a -> NonZero a max :: NonZero a -> NonZero a -> NonZero a $cmax :: forall a. Ord a => NonZero a -> NonZero a -> NonZero a >= :: NonZero a -> NonZero a -> Bool $c>= :: forall a. Ord a => NonZero a -> NonZero a -> Bool > :: NonZero a -> NonZero a -> Bool $c> :: forall a. Ord a => NonZero a -> NonZero a -> Bool <= :: NonZero a -> NonZero a -> Bool $c<= :: forall a. Ord a => NonZero a -> NonZero a -> Bool < :: NonZero a -> NonZero a -> Bool $c< :: forall a. Ord a => NonZero a -> NonZero a -> Bool compare :: NonZero a -> NonZero a -> Ordering $ccompare :: forall a. Ord a => NonZero a -> NonZero a -> Ordering $cp1Ord :: forall a. Ord a => Eq (NonZero a) Ord, a -> NonZero b -> NonZero a (a -> b) -> NonZero a -> NonZero b (forall a b. (a -> b) -> NonZero a -> NonZero b) -> (forall a b. a -> NonZero b -> NonZero a) -> Functor NonZero forall a b. a -> NonZero b -> NonZero a forall a b. (a -> b) -> NonZero a -> NonZero b forall (f :: * -> *). (forall a b. (a -> b) -> f a -> f b) -> (forall a b. a -> f b -> f a) -> Functor f <$ :: a -> NonZero b -> NonZero a $c<$ :: forall a b. a -> NonZero b -> NonZero a fmap :: (a -> b) -> NonZero a -> NonZero b $cfmap :: forall a b. (a -> b) -> NonZero a -> NonZero b Functor, NonZero a -> Bool (a -> m) -> NonZero a -> m (a -> b -> b) -> b -> NonZero a -> b (forall m. Monoid m => NonZero m -> m) -> (forall m a. Monoid m => (a -> m) -> NonZero a -> m) -> (forall m a. Monoid m => (a -> m) -> NonZero a -> m) -> (forall a b. (a -> b -> b) -> b -> NonZero a -> b) -> (forall a b. (a -> b -> b) -> b -> NonZero a -> b) -> (forall b a. (b -> a -> b) -> b -> NonZero a -> b) -> (forall b a. (b -> a -> b) -> b -> NonZero a -> b) -> (forall a. (a -> a -> a) -> NonZero a -> a) -> (forall a. (a -> a -> a) -> NonZero a -> a) -> (forall a. NonZero a -> [a]) -> (forall a. NonZero a -> Bool) -> (forall a. NonZero a -> Depth) -> (forall a. Eq a => a -> NonZero a -> Bool) -> (forall a. Ord a => NonZero a -> a) -> (forall a. Ord a => NonZero a -> a) -> (forall a. Num a => NonZero a -> a) -> (forall a. Num a => NonZero a -> a) -> Foldable NonZero forall a. Eq a => a -> NonZero a -> Bool forall a. Num a => NonZero a -> a forall a. Ord a => NonZero a -> a forall m. Monoid m => NonZero m -> m forall a. NonZero a -> Bool forall a. NonZero a -> Depth forall a. NonZero a -> [a] forall a. (a -> a -> a) -> NonZero a -> a forall m a. Monoid m => (a -> m) -> NonZero a -> m forall b a. (b -> a -> b) -> b -> NonZero a -> b forall a b. (a -> b -> b) -> b -> NonZero a -> b forall (t :: * -> *). (forall m. Monoid m => t m -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall m a. Monoid m => (a -> m) -> t a -> m) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall a b. (a -> b -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall b a. (b -> a -> b) -> b -> t a -> b) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. (a -> a -> a) -> t a -> a) -> (forall a. t a -> [a]) -> (forall a. t a -> Bool) -> (forall a. t a -> Depth) -> (forall a. Eq a => a -> t a -> Bool) -> (forall a. Ord a => t a -> a) -> (forall a. Ord a => t a -> a) -> (forall a. Num a => t a -> a) -> (forall a. Num a => t a -> a) -> Foldable t product :: NonZero a -> a $cproduct :: forall a. Num a => NonZero a -> a sum :: NonZero a -> a $csum :: forall a. Num a => NonZero a -> a minimum :: NonZero a -> a $cminimum :: forall a. Ord a => NonZero a -> a maximum :: NonZero a -> a $cmaximum :: forall a. Ord a => NonZero a -> a elem :: a -> NonZero a -> Bool $celem :: forall a. Eq a => a -> NonZero a -> Bool length :: NonZero a -> Depth $clength :: forall a. NonZero a -> Depth null :: NonZero a -> Bool $cnull :: forall a. NonZero a -> Bool toList :: NonZero a -> [a] $ctoList :: forall a. NonZero a -> [a] foldl1 :: (a -> a -> a) -> NonZero a -> a $cfoldl1 :: forall a. (a -> a -> a) -> NonZero a -> a foldr1 :: (a -> a -> a) -> NonZero a -> a $cfoldr1 :: forall a. (a -> a -> a) -> NonZero a -> a foldl' :: (b -> a -> b) -> b -> NonZero a -> b $cfoldl' :: forall b a. (b -> a -> b) -> b -> NonZero a -> b foldl :: (b -> a -> b) -> b -> NonZero a -> b $cfoldl :: forall b a. (b -> a -> b) -> b -> NonZero a -> b foldr' :: (a -> b -> b) -> b -> NonZero a -> b $cfoldr' :: forall a b. (a -> b -> b) -> b -> NonZero a -> b foldr :: (a -> b -> b) -> b -> NonZero a -> b $cfoldr :: forall a b. (a -> b -> b) -> b -> NonZero a -> b foldMap' :: (a -> m) -> NonZero a -> m $cfoldMap' :: forall m a. Monoid m => (a -> m) -> NonZero a -> m foldMap :: (a -> m) -> NonZero a -> m $cfoldMap :: forall m a. Monoid m => (a -> m) -> NonZero a -> m fold :: NonZero m -> m $cfold :: forall m. Monoid m => NonZero m -> m Foldable, Functor NonZero Foldable NonZero Functor NonZero -> Foldable NonZero -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonZero a -> f (NonZero b)) -> (forall (f :: * -> *) a. Applicative f => NonZero (f a) -> f (NonZero a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonZero a -> m (NonZero b)) -> (forall (m :: * -> *) a. Monad m => NonZero (m a) -> m (NonZero a)) -> Traversable NonZero (a -> f b) -> NonZero a -> f (NonZero b) forall (t :: * -> *). Functor t -> Foldable t -> (forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b)) -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)) -> (forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)) -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)) -> Traversable t forall (m :: * -> *) a. Monad m => NonZero (m a) -> m (NonZero a) forall (f :: * -> *) a. Applicative f => NonZero (f a) -> f (NonZero a) forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonZero a -> m (NonZero b) forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonZero a -> f (NonZero b) sequence :: NonZero (m a) -> m (NonZero a) $csequence :: forall (m :: * -> *) a. Monad m => NonZero (m a) -> m (NonZero a) mapM :: (a -> m b) -> NonZero a -> m (NonZero b) $cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> NonZero a -> m (NonZero b) sequenceA :: NonZero (f a) -> f (NonZero a) $csequenceA :: forall (f :: * -> *) a. Applicative f => NonZero (f a) -> f (NonZero a) traverse :: (a -> f b) -> NonZero a -> f (NonZero b) $ctraverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> NonZero a -> f (NonZero b) $cp2Traversable :: Foldable NonZero $cp1Traversable :: Functor NonZero Traversable) instance Real a => Real (NonZero a) where toRational :: NonZero a -> Rational toRational (NonZero a x) = a -> Rational forall a. Real a => a -> Rational toRational a x instance (Eq a, Num a, Bounded a) => Bounded (NonZero a) where minBound :: NonZero a minBound = let x :: a x = a forall a. Bounded a => a minBound in a -> NonZero a forall a. a -> NonZero a NonZero (if a x a -> a -> Bool forall a. Eq a => a -> a -> Bool == a 0 then a 1 else a x) maxBound :: NonZero a maxBound = let x :: a x = a forall a. Bounded a => a maxBound in a -> NonZero a forall a. a -> NonZero a NonZero (if a x a -> a -> Bool forall a. Eq a => a -> a -> Bool == a 0 then -a 1 else a x) instance Enum a => Enum (NonZero a) where toEnum :: Depth -> NonZero a toEnum Depth x = a -> NonZero a forall a. a -> NonZero a NonZero (Depth -> a forall a. Enum a => Depth -> a toEnum Depth x) fromEnum :: NonZero a -> Depth fromEnum (NonZero a x) = a -> Depth forall a. Enum a => a -> Depth fromEnum a x instance Num a => Num (NonZero a) where NonZero a x + :: NonZero a -> NonZero a -> NonZero a + NonZero a y = a -> NonZero a forall a. a -> NonZero a NonZero (a x a -> a -> a forall a. Num a => a -> a -> a + a y) NonZero a x * :: NonZero a -> NonZero a -> NonZero a * NonZero a y = a -> NonZero a forall a. a -> NonZero a NonZero (a x a -> a -> a forall a. Num a => a -> a -> a * a y) negate :: NonZero a -> NonZero a negate (NonZero a x) = a -> NonZero a forall a. a -> NonZero a NonZero (a -> a forall a. Num a => a -> a negate a x) abs :: NonZero a -> NonZero a abs (NonZero a x) = a -> NonZero a forall a. a -> NonZero a NonZero (a -> a forall a. Num a => a -> a abs a x) signum :: NonZero a -> NonZero a signum (NonZero a x) = a -> NonZero a forall a. a -> NonZero a NonZero (a -> a forall a. Num a => a -> a signum a x) fromInteger :: Integer -> NonZero a fromInteger Integer x = a -> NonZero a forall a. a -> NonZero a NonZero (Integer -> a forall a. Num a => Integer -> a fromInteger Integer x) instance Integral a => Integral (NonZero a) where quotRem :: NonZero a -> NonZero a -> (NonZero a, NonZero a) quotRem (NonZero a x) (NonZero a y) = (a -> NonZero a forall a. a -> NonZero a NonZero a q, a -> NonZero a forall a. a -> NonZero a NonZero a r) where (a q, a r) = a x a -> a -> (a, a) forall a. Integral a => a -> a -> (a, a) `quotRem` a y toInteger :: NonZero a -> Integer toInteger (NonZero a x) = a -> Integer forall a. Integral a => a -> Integer toInteger a x instance (Num a, Ord a, Serial m a) => Serial m (NonZero a) where series :: Series m (NonZero a) series = a -> NonZero a forall a. a -> NonZero a NonZero (a -> NonZero a) -> Series m a -> Series m (NonZero a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Series m a forall (m :: * -> *) a. Serial m a => Series m a series Series m a -> (a -> Bool) -> Series m a forall (m :: * -> *) a. Series m a -> (a -> Bool) -> Series m a `suchThat` (a -> a -> Bool forall a. Eq a => a -> a -> Bool /= a 0) instance Show a => Show (NonZero a) where showsPrec :: Depth -> NonZero a -> ShowS showsPrec Depth n (NonZero a x) = Depth -> a -> ShowS forall a. Show a => Depth -> a -> ShowS showsPrec Depth n a x -- | 'NonEmpty' @xs@ guarantees that @xs@ is not null. newtype NonEmpty a = NonEmpty { NonEmpty a -> [a] getNonEmpty :: [a] } instance (Serial m a) => Serial m (NonEmpty a) where series :: Series m (NonEmpty a) series = [a] -> NonEmpty a forall a. [a] -> NonEmpty a NonEmpty ([a] -> NonEmpty a) -> Series m [a] -> Series m (NonEmpty a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> (a -> [a] -> [a]) -> Series m [a] forall (m :: * -> *) a b c. (Serial m a, Serial m b) => (a -> b -> c) -> Series m c cons2 (:) instance Show a => Show (NonEmpty a) where showsPrec :: Depth -> NonEmpty a -> ShowS showsPrec Depth n (NonEmpty [a] x) = Depth -> [a] -> ShowS forall a. Show a => Depth -> a -> ShowS showsPrec Depth n [a] x -- }}} ------------------------------ -- Foreign.C.Types ------------------------------ -- {{{ #if MIN_VERSION_base(4,5,0) instance Monad m => Serial m CFloat where series :: Series m CFloat series = (Float -> CFloat) -> Series m CFloat forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Float -> CFloat CFloat instance Monad m => CoSerial m CFloat where coseries :: Series m b -> Series m (CFloat -> b) coseries Series m b rs = Series m b -> Series m (Float -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Float -> b) -> ((Float -> b) -> Series m (CFloat -> b)) -> Series m (CFloat -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Float -> b f -> (CFloat -> b) -> Series m (CFloat -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CFloat -> b) -> Series m (CFloat -> b)) -> (CFloat -> b) -> Series m (CFloat -> b) forall a b. (a -> b) -> a -> b $ \CFloat l -> case CFloat l of CFloat Float x -> Float -> b f Float x instance Monad m => Serial m CDouble where series :: Series m CDouble series = (Double -> CDouble) -> Series m CDouble forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Double -> CDouble CDouble instance Monad m => CoSerial m CDouble where coseries :: Series m b -> Series m (CDouble -> b) coseries Series m b rs = Series m b -> Series m (Double -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Double -> b) -> ((Double -> b) -> Series m (CDouble -> b)) -> Series m (CDouble -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Double -> b f -> (CDouble -> b) -> Series m (CDouble -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CDouble -> b) -> Series m (CDouble -> b)) -> (CDouble -> b) -> Series m (CDouble -> b) forall a b. (a -> b) -> a -> b $ \CDouble l -> case CDouble l of CDouble Double x -> Double -> b f Double x #if HASCBOOL instance Monad m => Serial m CBool where series :: Series m CBool series = (Word8 -> CBool) -> Series m CBool forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word8 -> CBool CBool instance Monad m => CoSerial m CBool where coseries :: Series m b -> Series m (CBool -> b) coseries Series m b rs = Series m b -> Series m (Word8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word8 -> b) -> ((Word8 -> b) -> Series m (CBool -> b)) -> Series m (CBool -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word8 -> b f -> (CBool -> b) -> Series m (CBool -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CBool -> b) -> Series m (CBool -> b)) -> (CBool -> b) -> Series m (CBool -> b) forall a b. (a -> b) -> a -> b $ \CBool l -> case CBool l of CBool Word8 x -> Word8 -> b f Word8 x #endif instance Monad m => Serial m CChar where series :: Series m CChar series = (Int8 -> CChar) -> Series m CChar forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int8 -> CChar CChar instance Monad m => CoSerial m CChar where coseries :: Series m b -> Series m (CChar -> b) coseries Series m b rs = Series m b -> Series m (Int8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int8 -> b) -> ((Int8 -> b) -> Series m (CChar -> b)) -> Series m (CChar -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int8 -> b f -> (CChar -> b) -> Series m (CChar -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CChar -> b) -> Series m (CChar -> b)) -> (CChar -> b) -> Series m (CChar -> b) forall a b. (a -> b) -> a -> b $ \CChar l -> case CChar l of CChar Int8 x -> Int8 -> b f Int8 x instance Monad m => Serial m CSChar where series :: Series m CSChar series = (Int8 -> CSChar) -> Series m CSChar forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int8 -> CSChar CSChar instance Monad m => CoSerial m CSChar where coseries :: Series m b -> Series m (CSChar -> b) coseries Series m b rs = Series m b -> Series m (Int8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int8 -> b) -> ((Int8 -> b) -> Series m (CSChar -> b)) -> Series m (CSChar -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int8 -> b f -> (CSChar -> b) -> Series m (CSChar -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CSChar -> b) -> Series m (CSChar -> b)) -> (CSChar -> b) -> Series m (CSChar -> b) forall a b. (a -> b) -> a -> b $ \CSChar l -> case CSChar l of CSChar Int8 x -> Int8 -> b f Int8 x instance Monad m => Serial m CUChar where series :: Series m CUChar series = (Word8 -> CUChar) -> Series m CUChar forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word8 -> CUChar CUChar instance Monad m => CoSerial m CUChar where coseries :: Series m b -> Series m (CUChar -> b) coseries Series m b rs = Series m b -> Series m (Word8 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word8 -> b) -> ((Word8 -> b) -> Series m (CUChar -> b)) -> Series m (CUChar -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word8 -> b f -> (CUChar -> b) -> Series m (CUChar -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUChar -> b) -> Series m (CUChar -> b)) -> (CUChar -> b) -> Series m (CUChar -> b) forall a b. (a -> b) -> a -> b $ \CUChar l -> case CUChar l of CUChar Word8 x -> Word8 -> b f Word8 x instance Monad m => Serial m CShort where series :: Series m CShort series = (Int16 -> CShort) -> Series m CShort forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int16 -> CShort CShort instance Monad m => CoSerial m CShort where coseries :: Series m b -> Series m (CShort -> b) coseries Series m b rs = Series m b -> Series m (Int16 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int16 -> b) -> ((Int16 -> b) -> Series m (CShort -> b)) -> Series m (CShort -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int16 -> b f -> (CShort -> b) -> Series m (CShort -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CShort -> b) -> Series m (CShort -> b)) -> (CShort -> b) -> Series m (CShort -> b) forall a b. (a -> b) -> a -> b $ \CShort l -> case CShort l of CShort Int16 x -> Int16 -> b f Int16 x instance Monad m => Serial m CUShort where series :: Series m CUShort series = (Word16 -> CUShort) -> Series m CUShort forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word16 -> CUShort CUShort instance Monad m => CoSerial m CUShort where coseries :: Series m b -> Series m (CUShort -> b) coseries Series m b rs = Series m b -> Series m (Word16 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word16 -> b) -> ((Word16 -> b) -> Series m (CUShort -> b)) -> Series m (CUShort -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word16 -> b f -> (CUShort -> b) -> Series m (CUShort -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUShort -> b) -> Series m (CUShort -> b)) -> (CUShort -> b) -> Series m (CUShort -> b) forall a b. (a -> b) -> a -> b $ \CUShort l -> case CUShort l of CUShort Word16 x -> Word16 -> b f Word16 x instance Monad m => Serial m CInt where series :: Series m CInt series = (Int32 -> CInt) -> Series m CInt forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int32 -> CInt CInt instance Monad m => CoSerial m CInt where coseries :: Series m b -> Series m (CInt -> b) coseries Series m b rs = Series m b -> Series m (Int32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int32 -> b) -> ((Int32 -> b) -> Series m (CInt -> b)) -> Series m (CInt -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int32 -> b f -> (CInt -> b) -> Series m (CInt -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CInt -> b) -> Series m (CInt -> b)) -> (CInt -> b) -> Series m (CInt -> b) forall a b. (a -> b) -> a -> b $ \CInt l -> case CInt l of CInt Int32 x -> Int32 -> b f Int32 x instance Monad m => Serial m CUInt where series :: Series m CUInt series = (Word32 -> CUInt) -> Series m CUInt forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word32 -> CUInt CUInt instance Monad m => CoSerial m CUInt where coseries :: Series m b -> Series m (CUInt -> b) coseries Series m b rs = Series m b -> Series m (Word32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word32 -> b) -> ((Word32 -> b) -> Series m (CUInt -> b)) -> Series m (CUInt -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word32 -> b f -> (CUInt -> b) -> Series m (CUInt -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUInt -> b) -> Series m (CUInt -> b)) -> (CUInt -> b) -> Series m (CUInt -> b) forall a b. (a -> b) -> a -> b $ \CUInt l -> case CUInt l of CUInt Word32 x -> Word32 -> b f Word32 x instance Monad m => Serial m CLong where series :: Series m CLong series = (Int64 -> CLong) -> Series m CLong forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CLong CLong instance Monad m => CoSerial m CLong where coseries :: Series m b -> Series m (CLong -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CLong -> b)) -> Series m (CLong -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CLong -> b) -> Series m (CLong -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CLong -> b) -> Series m (CLong -> b)) -> (CLong -> b) -> Series m (CLong -> b) forall a b. (a -> b) -> a -> b $ \CLong l -> case CLong l of CLong Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CULong where series :: Series m CULong series = (Word64 -> CULong) -> Series m CULong forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word64 -> CULong CULong instance Monad m => CoSerial m CULong where coseries :: Series m b -> Series m (CULong -> b) coseries Series m b rs = Series m b -> Series m (Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word64 -> b) -> ((Word64 -> b) -> Series m (CULong -> b)) -> Series m (CULong -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word64 -> b f -> (CULong -> b) -> Series m (CULong -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CULong -> b) -> Series m (CULong -> b)) -> (CULong -> b) -> Series m (CULong -> b) forall a b. (a -> b) -> a -> b $ \CULong l -> case CULong l of CULong Word64 x -> Word64 -> b f Word64 x instance Monad m => Serial m CPtrdiff where series :: Series m CPtrdiff series = (Int64 -> CPtrdiff) -> Series m CPtrdiff forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CPtrdiff CPtrdiff instance Monad m => CoSerial m CPtrdiff where coseries :: Series m b -> Series m (CPtrdiff -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CPtrdiff -> b)) -> Series m (CPtrdiff -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CPtrdiff -> b) -> Series m (CPtrdiff -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CPtrdiff -> b) -> Series m (CPtrdiff -> b)) -> (CPtrdiff -> b) -> Series m (CPtrdiff -> b) forall a b. (a -> b) -> a -> b $ \CPtrdiff l -> case CPtrdiff l of CPtrdiff Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CSize where series :: Series m CSize series = (Word64 -> CSize) -> Series m CSize forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word64 -> CSize CSize instance Monad m => CoSerial m CSize where coseries :: Series m b -> Series m (CSize -> b) coseries Series m b rs = Series m b -> Series m (Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word64 -> b) -> ((Word64 -> b) -> Series m (CSize -> b)) -> Series m (CSize -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word64 -> b f -> (CSize -> b) -> Series m (CSize -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CSize -> b) -> Series m (CSize -> b)) -> (CSize -> b) -> Series m (CSize -> b) forall a b. (a -> b) -> a -> b $ \CSize l -> case CSize l of CSize Word64 x -> Word64 -> b f Word64 x instance Monad m => Serial m CWchar where series :: Series m CWchar series = (Int32 -> CWchar) -> Series m CWchar forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int32 -> CWchar CWchar instance Monad m => CoSerial m CWchar where coseries :: Series m b -> Series m (CWchar -> b) coseries Series m b rs = Series m b -> Series m (Int32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int32 -> b) -> ((Int32 -> b) -> Series m (CWchar -> b)) -> Series m (CWchar -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int32 -> b f -> (CWchar -> b) -> Series m (CWchar -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CWchar -> b) -> Series m (CWchar -> b)) -> (CWchar -> b) -> Series m (CWchar -> b) forall a b. (a -> b) -> a -> b $ \CWchar l -> case CWchar l of CWchar Int32 x -> Int32 -> b f Int32 x instance Monad m => Serial m CSigAtomic where series :: Series m CSigAtomic series = (Int32 -> CSigAtomic) -> Series m CSigAtomic forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int32 -> CSigAtomic CSigAtomic instance Monad m => CoSerial m CSigAtomic where coseries :: Series m b -> Series m (CSigAtomic -> b) coseries Series m b rs = Series m b -> Series m (Int32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int32 -> b) -> ((Int32 -> b) -> Series m (CSigAtomic -> b)) -> Series m (CSigAtomic -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int32 -> b f -> (CSigAtomic -> b) -> Series m (CSigAtomic -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CSigAtomic -> b) -> Series m (CSigAtomic -> b)) -> (CSigAtomic -> b) -> Series m (CSigAtomic -> b) forall a b. (a -> b) -> a -> b $ \CSigAtomic l -> case CSigAtomic l of CSigAtomic Int32 x -> Int32 -> b f Int32 x instance Monad m => Serial m CLLong where series :: Series m CLLong series = (Int64 -> CLLong) -> Series m CLLong forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CLLong CLLong instance Monad m => CoSerial m CLLong where coseries :: Series m b -> Series m (CLLong -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CLLong -> b)) -> Series m (CLLong -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CLLong -> b) -> Series m (CLLong -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CLLong -> b) -> Series m (CLLong -> b)) -> (CLLong -> b) -> Series m (CLLong -> b) forall a b. (a -> b) -> a -> b $ \CLLong l -> case CLLong l of CLLong Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CULLong where series :: Series m CULLong series = (Word64 -> CULLong) -> Series m CULLong forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word64 -> CULLong CULLong instance Monad m => CoSerial m CULLong where coseries :: Series m b -> Series m (CULLong -> b) coseries Series m b rs = Series m b -> Series m (Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word64 -> b) -> ((Word64 -> b) -> Series m (CULLong -> b)) -> Series m (CULLong -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word64 -> b f -> (CULLong -> b) -> Series m (CULLong -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CULLong -> b) -> Series m (CULLong -> b)) -> (CULLong -> b) -> Series m (CULLong -> b) forall a b. (a -> b) -> a -> b $ \CULLong l -> case CULLong l of CULLong Word64 x -> Word64 -> b f Word64 x instance Monad m => Serial m CIntPtr where series :: Series m CIntPtr series = (Int64 -> CIntPtr) -> Series m CIntPtr forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CIntPtr CIntPtr instance Monad m => CoSerial m CIntPtr where coseries :: Series m b -> Series m (CIntPtr -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CIntPtr -> b)) -> Series m (CIntPtr -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CIntPtr -> b) -> Series m (CIntPtr -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CIntPtr -> b) -> Series m (CIntPtr -> b)) -> (CIntPtr -> b) -> Series m (CIntPtr -> b) forall a b. (a -> b) -> a -> b $ \CIntPtr l -> case CIntPtr l of CIntPtr Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CUIntPtr where series :: Series m CUIntPtr series = (Word64 -> CUIntPtr) -> Series m CUIntPtr forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word64 -> CUIntPtr CUIntPtr instance Monad m => CoSerial m CUIntPtr where coseries :: Series m b -> Series m (CUIntPtr -> b) coseries Series m b rs = Series m b -> Series m (Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word64 -> b) -> ((Word64 -> b) -> Series m (CUIntPtr -> b)) -> Series m (CUIntPtr -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word64 -> b f -> (CUIntPtr -> b) -> Series m (CUIntPtr -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUIntPtr -> b) -> Series m (CUIntPtr -> b)) -> (CUIntPtr -> b) -> Series m (CUIntPtr -> b) forall a b. (a -> b) -> a -> b $ \CUIntPtr l -> case CUIntPtr l of CUIntPtr Word64 x -> Word64 -> b f Word64 x instance Monad m => Serial m CIntMax where series :: Series m CIntMax series = (Int64 -> CIntMax) -> Series m CIntMax forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CIntMax CIntMax instance Monad m => CoSerial m CIntMax where coseries :: Series m b -> Series m (CIntMax -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CIntMax -> b)) -> Series m (CIntMax -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CIntMax -> b) -> Series m (CIntMax -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CIntMax -> b) -> Series m (CIntMax -> b)) -> (CIntMax -> b) -> Series m (CIntMax -> b) forall a b. (a -> b) -> a -> b $ \CIntMax l -> case CIntMax l of CIntMax Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CUIntMax where series :: Series m CUIntMax series = (Word64 -> CUIntMax) -> Series m CUIntMax forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word64 -> CUIntMax CUIntMax instance Monad m => CoSerial m CUIntMax where coseries :: Series m b -> Series m (CUIntMax -> b) coseries Series m b rs = Series m b -> Series m (Word64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word64 -> b) -> ((Word64 -> b) -> Series m (CUIntMax -> b)) -> Series m (CUIntMax -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word64 -> b f -> (CUIntMax -> b) -> Series m (CUIntMax -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUIntMax -> b) -> Series m (CUIntMax -> b)) -> (CUIntMax -> b) -> Series m (CUIntMax -> b) forall a b. (a -> b) -> a -> b $ \CUIntMax l -> case CUIntMax l of CUIntMax Word64 x -> Word64 -> b f Word64 x instance Monad m => Serial m CClock where series :: Series m CClock series = (Int64 -> CClock) -> Series m CClock forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CClock CClock instance Monad m => CoSerial m CClock where coseries :: Series m b -> Series m (CClock -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CClock -> b)) -> Series m (CClock -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CClock -> b) -> Series m (CClock -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CClock -> b) -> Series m (CClock -> b)) -> (CClock -> b) -> Series m (CClock -> b) forall a b. (a -> b) -> a -> b $ \CClock l -> case CClock l of CClock Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CTime where series :: Series m CTime series = (Int64 -> CTime) -> Series m CTime forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CTime CTime instance Monad m => CoSerial m CTime where coseries :: Series m b -> Series m (CTime -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CTime -> b)) -> Series m (CTime -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CTime -> b) -> Series m (CTime -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CTime -> b) -> Series m (CTime -> b)) -> (CTime -> b) -> Series m (CTime -> b) forall a b. (a -> b) -> a -> b $ \CTime l -> case CTime l of CTime Int64 x -> Int64 -> b f Int64 x instance Monad m => Serial m CUSeconds where series :: Series m CUSeconds series = (Word32 -> CUSeconds) -> Series m CUSeconds forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Word32 -> CUSeconds CUSeconds instance Monad m => CoSerial m CUSeconds where coseries :: Series m b -> Series m (CUSeconds -> b) coseries Series m b rs = Series m b -> Series m (Word32 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Word32 -> b) -> ((Word32 -> b) -> Series m (CUSeconds -> b)) -> Series m (CUSeconds -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Word32 -> b f -> (CUSeconds -> b) -> Series m (CUSeconds -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CUSeconds -> b) -> Series m (CUSeconds -> b)) -> (CUSeconds -> b) -> Series m (CUSeconds -> b) forall a b. (a -> b) -> a -> b $ \CUSeconds l -> case CUSeconds l of CUSeconds Word32 x -> Word32 -> b f Word32 x instance Monad m => Serial m CSUSeconds where series :: Series m CSUSeconds series = (Int64 -> CSUSeconds) -> Series m CSUSeconds forall (m :: * -> *) a b. Serial m a => (a -> b) -> Series m b newtypeCons Int64 -> CSUSeconds CSUSeconds instance Monad m => CoSerial m CSUSeconds where coseries :: Series m b -> Series m (CSUSeconds -> b) coseries Series m b rs = Series m b -> Series m (Int64 -> b) forall (m :: * -> *) a b. CoSerial m a => Series m b -> Series m (a -> b) newtypeAlts Series m b rs Series m (Int64 -> b) -> ((Int64 -> b) -> Series m (CSUSeconds -> b)) -> Series m (CSUSeconds -> b) forall (m :: * -> *) a b. MonadLogic m => m a -> (a -> m b) -> m b >>- \Int64 -> b f -> (CSUSeconds -> b) -> Series m (CSUSeconds -> b) forall (m :: * -> *) a. Monad m => a -> m a return ((CSUSeconds -> b) -> Series m (CSUSeconds -> b)) -> (CSUSeconds -> b) -> Series m (CSUSeconds -> b) forall a b. (a -> b) -> a -> b $ \CSUSeconds l -> case CSUSeconds l of CSUSeconds Int64 x -> Int64 -> b f Int64 x #endif -- }}}