{-# language DeriveDataTypeable #-}

module Autolib.Nat

  (Nat, nat, unNat )

where

import Autolib.ToDoc
import Autolib.Reader
import Data.Ix
import Data.Hashable
import System.Random
import Data.Data

newtype Nat = Nat { Nat -> Int
unNat :: Int }
  deriving (Nat -> Nat -> Bool
(Nat -> Nat -> Bool) -> (Nat -> Nat -> Bool) -> Eq Nat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Nat -> Nat -> Bool
== :: Nat -> Nat -> Bool
$c/= :: Nat -> Nat -> Bool
/= :: Nat -> Nat -> Bool
Eq, Eq Nat
Eq Nat =>
(Nat -> Nat -> Ordering)
-> (Nat -> Nat -> Bool)
-> (Nat -> Nat -> Bool)
-> (Nat -> Nat -> Bool)
-> (Nat -> Nat -> Bool)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> Ord Nat
Nat -> Nat -> Bool
Nat -> Nat -> Ordering
Nat -> Nat -> Nat
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
$ccompare :: Nat -> Nat -> Ordering
compare :: Nat -> Nat -> Ordering
$c< :: Nat -> Nat -> Bool
< :: Nat -> Nat -> Bool
$c<= :: Nat -> Nat -> Bool
<= :: Nat -> Nat -> Bool
$c> :: Nat -> Nat -> Bool
> :: Nat -> Nat -> Bool
$c>= :: Nat -> Nat -> Bool
>= :: Nat -> Nat -> Bool
$cmax :: Nat -> Nat -> Nat
max :: Nat -> Nat -> Nat
$cmin :: Nat -> Nat -> Nat
min :: Nat -> Nat -> Nat
Ord, Int -> Nat
Nat -> Int
Nat -> [Nat]
Nat -> Nat
Nat -> Nat -> [Nat]
Nat -> Nat -> Nat -> [Nat]
(Nat -> Nat)
-> (Nat -> Nat)
-> (Int -> Nat)
-> (Nat -> Int)
-> (Nat -> [Nat])
-> (Nat -> Nat -> [Nat])
-> (Nat -> Nat -> [Nat])
-> (Nat -> Nat -> Nat -> [Nat])
-> Enum Nat
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Nat -> Nat
succ :: Nat -> Nat
$cpred :: Nat -> Nat
pred :: Nat -> Nat
$ctoEnum :: Int -> Nat
toEnum :: Int -> Nat
$cfromEnum :: Nat -> Int
fromEnum :: Nat -> Int
$cenumFrom :: Nat -> [Nat]
enumFrom :: Nat -> [Nat]
$cenumFromThen :: Nat -> Nat -> [Nat]
enumFromThen :: Nat -> Nat -> [Nat]
$cenumFromTo :: Nat -> Nat -> [Nat]
enumFromTo :: Nat -> Nat -> [Nat]
$cenumFromThenTo :: Nat -> Nat -> Nat -> [Nat]
enumFromThenTo :: Nat -> Nat -> Nat -> [Nat]
Enum, Ord Nat
Ord Nat =>
((Nat, Nat) -> [Nat])
-> ((Nat, Nat) -> Nat -> Int)
-> ((Nat, Nat) -> Nat -> Int)
-> ((Nat, Nat) -> Nat -> Bool)
-> ((Nat, Nat) -> Int)
-> ((Nat, Nat) -> Int)
-> Ix Nat
(Nat, Nat) -> Int
(Nat, Nat) -> [Nat]
(Nat, Nat) -> Nat -> Bool
(Nat, Nat) -> Nat -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Nat, Nat) -> [Nat]
range :: (Nat, Nat) -> [Nat]
$cindex :: (Nat, Nat) -> Nat -> Int
index :: (Nat, Nat) -> Nat -> Int
$cunsafeIndex :: (Nat, Nat) -> Nat -> Int
unsafeIndex :: (Nat, Nat) -> Nat -> Int
$cinRange :: (Nat, Nat) -> Nat -> Bool
inRange :: (Nat, Nat) -> Nat -> Bool
$crangeSize :: (Nat, Nat) -> Int
rangeSize :: (Nat, Nat) -> Int
$cunsafeRangeSize :: (Nat, Nat) -> Int
unsafeRangeSize :: (Nat, Nat) -> Int
Ix, Integer -> Nat
Nat -> Nat
Nat -> Nat -> Nat
(Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat)
-> (Nat -> Nat)
-> (Nat -> Nat)
-> (Integer -> Nat)
-> Num Nat
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Nat -> Nat -> Nat
+ :: Nat -> Nat -> Nat
$c- :: Nat -> Nat -> Nat
- :: Nat -> Nat -> Nat
$c* :: Nat -> Nat -> Nat
* :: Nat -> Nat -> Nat
$cnegate :: Nat -> Nat
negate :: Nat -> Nat
$cabs :: Nat -> Nat
abs :: Nat -> Nat
$csignum :: Nat -> Nat
signum :: Nat -> Nat
$cfromInteger :: Integer -> Nat
fromInteger :: Integer -> Nat
Num, Enum Nat
Real Nat
(Real Nat, Enum Nat) =>
(Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat -> Nat)
-> (Nat -> Nat -> (Nat, Nat))
-> (Nat -> Nat -> (Nat, Nat))
-> (Nat -> Integer)
-> Integral Nat
Nat -> Integer
Nat -> Nat -> (Nat, Nat)
Nat -> Nat -> Nat
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Nat -> Nat -> Nat
quot :: Nat -> Nat -> Nat
$crem :: Nat -> Nat -> Nat
rem :: Nat -> Nat -> Nat
$cdiv :: Nat -> Nat -> Nat
div :: Nat -> Nat -> Nat
$cmod :: Nat -> Nat -> Nat
mod :: Nat -> Nat -> Nat
$cquotRem :: Nat -> Nat -> (Nat, Nat)
quotRem :: Nat -> Nat -> (Nat, Nat)
$cdivMod :: Nat -> Nat -> (Nat, Nat)
divMod :: Nat -> Nat -> (Nat, Nat)
$ctoInteger :: Nat -> Integer
toInteger :: Nat -> Integer
Integral, Num Nat
Ord Nat
(Num Nat, Ord Nat) => (Nat -> Rational) -> Real Nat
Nat -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Nat -> Rational
toRational :: Nat -> Rational
Real, Eq Nat
Eq Nat => (Int -> Nat -> Int) -> (Nat -> Int) -> Hashable Nat
Int -> Nat -> Int
Nat -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Nat -> Int
hashWithSalt :: Int -> Nat -> Int
$chash :: Nat -> Int
hash :: Nat -> Int
Hashable,(forall g. RandomGen g => (Nat, Nat) -> g -> (Nat, g))
-> (forall g. RandomGen g => g -> (Nat, g))
-> (forall g. RandomGen g => (Nat, Nat) -> g -> [Nat])
-> (forall g. RandomGen g => g -> [Nat])
-> Random Nat
forall g. RandomGen g => g -> [Nat]
forall g. RandomGen g => g -> (Nat, g)
forall g. RandomGen g => (Nat, Nat) -> g -> [Nat]
forall g. RandomGen g => (Nat, Nat) -> g -> (Nat, g)
forall a.
(forall g. RandomGen g => (a, a) -> g -> (a, g))
-> (forall g. RandomGen g => g -> (a, g))
-> (forall g. RandomGen g => (a, a) -> g -> [a])
-> (forall g. RandomGen g => g -> [a])
-> Random a
$crandomR :: forall g. RandomGen g => (Nat, Nat) -> g -> (Nat, g)
randomR :: forall g. RandomGen g => (Nat, Nat) -> g -> (Nat, g)
$crandom :: forall g. RandomGen g => g -> (Nat, g)
random :: forall g. RandomGen g => g -> (Nat, g)
$crandomRs :: forall g. RandomGen g => (Nat, Nat) -> g -> [Nat]
randomRs :: forall g. RandomGen g => (Nat, Nat) -> g -> [Nat]
$crandoms :: forall g. RandomGen g => g -> [Nat]
randoms :: forall g. RandomGen g => g -> [Nat]
Random, Typeable Nat
Typeable Nat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Nat -> c Nat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Nat)
-> (Nat -> Constr)
-> (Nat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Nat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Nat))
-> ((forall b. Data b => b -> b) -> Nat -> Nat)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r)
-> (forall u. (forall d. Data d => d -> u) -> Nat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Nat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Nat -> m Nat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Nat -> m Nat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Nat -> m Nat)
-> Data Nat
Nat -> Constr
Nat -> DataType
(forall b. Data b => b -> b) -> Nat -> Nat
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Nat -> u
forall u. (forall d. Data d => d -> u) -> Nat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Nat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Nat -> c Nat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Nat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Nat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Nat -> c Nat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Nat -> c Nat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Nat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Nat
$ctoConstr :: Nat -> Constr
toConstr :: Nat -> Constr
$cdataTypeOf :: Nat -> DataType
dataTypeOf :: Nat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Nat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Nat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Nat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Nat)
$cgmapT :: (forall b. Data b => b -> b) -> Nat -> Nat
gmapT :: (forall b. Data b => b -> b) -> Nat -> Nat
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Nat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Nat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Nat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Nat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Nat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Nat -> m Nat
Data)

nat :: Int -> Nat
nat Int
x | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 = Int -> Nat
Nat Int
x

instance ToDoc Nat where
  toDocPrec :: Int -> Nat -> Doc
toDocPrec Int
p (Nat Int
n) = Int -> Int -> Doc
forall a. ToDoc a => Int -> a -> Doc
toDocPrec Int
p Int
n

instance Show Nat where
  showsPrec :: Int -> Nat -> ShowS
showsPrec Int
p (Nat Int
n) = Int -> Int -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p Int
n

instance Reader Nat where
  atomic_readerPrec :: Int -> Parser Nat
atomic_readerPrec Int
p = Integer -> Nat
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Nat)
-> ParsecT String () Identity Integer -> Parser Nat
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Integer
my_natural