bin-0.1: Bin: binary natural numbers.
Safe Haskell Safe-Inferred
Language Haskell2010

Data.Bin

Description

Binary natural numbers, Bin .

This module is designed to be imported qualified.

Synopsis

Binary natural numbers

data Bin Source #

Binary natural numbers.

Numbers are represented in little-endian order, the representation is unique. 

>>> mapM_ (putStrLn .  explicitShow) [0 .. 7]
BZ
BP BE
BP (B0 BE)
BP (B1 BE)
BP (B0 (B0 BE))
BP (B1 (B0 BE))
BP (B0 (B1 BE))
BP (B1 (B1 BE))

Constructors

BZ

zero

BP BinP

non-zero

Instances

Instances details
Enum Bin Source # 
>>> take 10 $ iterate succ BZ
[0,1,2,3,4,5,6,7,8,9]

>>> take 10 [BZ ..]
[0,1,2,3,4,5,6,7,8,9]
Instance details

Defined in Data.Bin

Methods

succ :: Bin -> Bin Source #

pred :: Bin -> Bin Source #

toEnum :: Int -> Bin Source #

fromEnum :: Bin -> Int Source #

enumFrom :: Bin -> [ Bin ] Source #

enumFromThen :: Bin -> Bin -> [ Bin ] Source #

enumFromTo :: Bin -> Bin -> [ Bin ] Source #

enumFromThenTo :: Bin -> Bin -> Bin -> [ Bin ] Source #

Eq Bin Source #
Instance details

Defined in Data.Bin

Methods

(==) :: Bin -> Bin -> Bool Source #

(/=) :: Bin -> Bin -> Bool Source #

Integral Bin Source #
Instance details

Defined in Data.Bin

Methods

quot :: Bin -> Bin -> Bin Source #

rem :: Bin -> Bin -> Bin Source #

div :: Bin -> Bin -> Bin Source #

mod :: Bin -> Bin -> Bin Source #

quotRem :: Bin -> Bin -> ( Bin , Bin ) Source #

divMod :: Bin -> Bin -> ( Bin , Bin ) Source #

toInteger :: Bin -> Integer Source #

Data Bin Source #
Instance details

Defined in Data.Bin

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Bin -> c Bin Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Bin Source #

toConstr :: Bin -> Constr Source #

dataTypeOf :: Bin -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Bin ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Bin ) Source #

gmapT :: ( forall b. Data b => b -> b) -> Bin -> Bin Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Bin -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Bin -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> Bin -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> Bin -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Bin -> m Bin Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Bin -> m Bin Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Bin -> m Bin Source #

Num Bin Source # 
>>> 0 + 2 :: Bin
2

>>> 1 + 2 :: Bin
3

>>> 4 * 8 :: Bin
32

>>> 7 * 7 :: Bin
49
Instance details

Defined in Data.Bin

Methods

(+) :: Bin -> Bin -> Bin Source #

(-) :: Bin -> Bin -> Bin Source #

(*) :: Bin -> Bin -> Bin Source #

negate :: Bin -> Bin Source #

abs :: Bin -> Bin Source #

signum :: Bin -> Bin Source #

fromInteger :: Integer -> Bin Source #

Ord Bin Source #
Instance details

Defined in Data.Bin

Methods

compare :: Bin -> Bin -> Ordering Source #

(<) :: Bin -> Bin -> Bool Source #

(<=) :: Bin -> Bin -> Bool Source #

(>) :: Bin -> Bin -> Bool Source #

(>=) :: Bin -> Bin -> Bool Source #

max :: Bin -> Bin -> Bin Source #

min :: Bin -> Bin -> Bin Source #

Real Bin Source #
Instance details

Defined in Data.Bin

Methods

toRational :: Bin -> Rational Source #

Show Bin Source #

Bin is printed as Natural .

To see explicit structure, use explicitShow or explicitShowsPrec

Instance details

Defined in Data.Bin

Methods

showsPrec :: Int -> Bin -> ShowS Source #

show :: Bin -> String Source #

showList :: [ Bin ] -> ShowS Source #

Function Bin Source #
Instance details

Defined in Data.Bin

Methods

function :: ( Bin -> b) -> Bin :-> b Source #

Arbitrary Bin Source #
Instance details

Defined in Data.Bin

Methods

arbitrary :: Gen Bin Source #

shrink :: Bin -> [ Bin ] Source #

CoArbitrary Bin Source #
Instance details

Defined in Data.Bin

Methods

coarbitrary :: Bin -> Gen b -> Gen b Source #

Bits Bin Source #
Instance details

Defined in Data.Bin

Methods

(.&.) :: Bin -> Bin -> Bin Source #

(.|.) :: Bin -> Bin -> Bin Source #

xor :: Bin -> Bin -> Bin Source #

complement :: Bin -> Bin Source #

shift :: Bin -> Int -> Bin Source #

rotate :: Bin -> Int -> Bin Source #

zeroBits :: Bin Source #

bit :: Int -> Bin Source #

setBit :: Bin -> Int -> Bin Source #

clearBit :: Bin -> Int -> Bin Source #

complementBit :: Bin -> Int -> Bin Source #

testBit :: Bin -> Int -> Bool Source #

bitSizeMaybe :: Bin -> Maybe Int Source #

bitSize :: Bin -> Int Source #

isSigned :: Bin -> Bool Source #

shiftL :: Bin -> Int -> Bin Source #

unsafeShiftL :: Bin -> Int -> Bin Source #

shiftR :: Bin -> Int -> Bin Source #

unsafeShiftR :: Bin -> Int -> Bin Source #

rotateL :: Bin -> Int -> Bin Source #

rotateR :: Bin -> Int -> Bin Source #

popCount :: Bin -> Int Source #

NFData Bin Source #
Instance details

Defined in Data.Bin

Methods

rnf :: Bin -> () Source #

Hashable Bin Source #
Instance details

Defined in Data.Bin

Methods

hashWithSalt :: Int -> Bin -> Int Source #

hash :: Bin -> Int Source #

TestEquality SBin Source #
Instance details

Defined in Data.Type.Bin

Methods

testEquality :: forall (a :: k) (b :: k). SBin a -> SBin b -> Maybe (a :~: b) Source #

toNatural :: Bin -> Natural Source #

Convert Bin to Natural 

>>> toNatural 0
0

>>> toNatural 2
2

>>> toNatural $ BP $ B0 $ B1 $ BE
6

fromNatural :: Natural -> Bin Source #

Convert Natural to Nat 

>>> fromNatural 4
4

>>> explicitShow (fromNatural 4)
"BP (B0 (B0 BE))"

toNat :: Bin -> Nat Source #

Convert from Bin to Nat . 

>>> toNat 5
5

>>> N.explicitShow (toNat 5)
"S (S (S (S (S Z))))"

fromNat :: Nat -> Bin Source #

Convert from Nat to Bin . 

>>> fromNat 5
5

>>> explicitShow (fromNat 5)
"BP (B1 (B0 BE))"

cata Source #

Arguments

:: a

\(0\)

-> a

\(1\)

-> (a -> a)

\(2x\)

-> (a -> a)

\(2x + 1\)

-> Bin
-> a

Fold Bin .

Positive natural numbers

data BinP Source #

Non-zero binary natural numbers.

We could have called this type Bin1 , but that's used as type alias for promoted BP BE in Data.Type.Bin .

Constructors

BE

one

B0 BinP

mult2

B1 BinP

mult2 plus 1

Instances

Instances details
Enum BinP Source #
Instance details

Defined in Data.BinP

Methods

succ :: BinP -> BinP Source #

pred :: BinP -> BinP Source #

toEnum :: Int -> BinP Source #

fromEnum :: BinP -> Int Source #

enumFrom :: BinP -> [ BinP ] Source #

enumFromThen :: BinP -> BinP -> [ BinP ] Source #

enumFromTo :: BinP -> BinP -> [ BinP ] Source #

enumFromThenTo :: BinP -> BinP -> BinP -> [ BinP ] Source #

Eq BinP Source #
Instance details

Defined in Data.BinP

Methods

(==) :: BinP -> BinP -> Bool Source #

(/=) :: BinP -> BinP -> Bool Source #

Integral BinP Source #
Instance details

Defined in Data.BinP

Methods

quot :: BinP -> BinP -> BinP Source #

rem :: BinP -> BinP -> BinP Source #

div :: BinP -> BinP -> BinP Source #

mod :: BinP -> BinP -> BinP Source #

quotRem :: BinP -> BinP -> ( BinP , BinP ) Source #

divMod :: BinP -> BinP -> ( BinP , BinP ) Source #

toInteger :: BinP -> Integer Source #

Data BinP Source #
Instance details

Defined in Data.BinP

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> BinP -> c BinP Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c BinP Source #

toConstr :: BinP -> Constr Source #

dataTypeOf :: BinP -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c BinP ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c BinP ) Source #

gmapT :: ( forall b. Data b => b -> b) -> BinP -> BinP Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> BinP -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> BinP -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> BinP -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> BinP -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> BinP -> m BinP Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> BinP -> m BinP Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> BinP -> m BinP Source #

Num BinP Source #
Instance details

Defined in Data.BinP

Methods

(+) :: BinP -> BinP -> BinP Source #

(-) :: BinP -> BinP -> BinP Source #

(*) :: BinP -> BinP -> BinP Source #

negate :: BinP -> BinP Source #

abs :: BinP -> BinP Source #

signum :: BinP -> BinP Source #

fromInteger :: Integer -> BinP Source #

Ord BinP Source # 
>>> sort [1 .. 9 :: BinP]
[1,2,3,4,5,6,7,8,9]
Instance details

Defined in Data.BinP

Methods

compare :: BinP -> BinP -> Ordering Source #

(<) :: BinP -> BinP -> Bool Source #

(<=) :: BinP -> BinP -> Bool Source #

(>) :: BinP -> BinP -> Bool Source #

(>=) :: BinP -> BinP -> Bool Source #

max :: BinP -> BinP -> BinP Source #

min :: BinP -> BinP -> BinP Source #

Real BinP Source #
Instance details

Defined in Data.BinP

Methods

toRational :: BinP -> Rational Source #

Show BinP Source #
Instance details

Defined in Data.BinP

Methods

showsPrec :: Int -> BinP -> ShowS Source #

show :: BinP -> String Source #

showList :: [ BinP ] -> ShowS Source #

Function BinP Source #
Instance details

Defined in Data.BinP

Methods

function :: ( BinP -> b) -> BinP :-> b Source #

Arbitrary BinP Source #
Instance details

Defined in Data.BinP

Methods

arbitrary :: Gen BinP Source #

shrink :: BinP -> [ BinP ] Source #

CoArbitrary BinP Source #
Instance details

Defined in Data.BinP

Methods

coarbitrary :: BinP -> Gen b -> Gen b Source #

Bits BinP Source #

NOTE : .&. , xor , shiftR and rotateR are __NOT_ implemented. They may make number zero.

Instance details

Defined in Data.BinP

Methods

(.&.) :: BinP -> BinP -> BinP Source #

(.|.) :: BinP -> BinP -> BinP Source #

xor :: BinP -> BinP -> BinP Source #

complement :: BinP -> BinP Source #

shift :: BinP -> Int -> BinP Source #

rotate :: BinP -> Int -> BinP Source #

zeroBits :: BinP Source #

bit :: Int -> BinP Source #

setBit :: BinP -> Int -> BinP Source #

clearBit :: BinP -> Int -> BinP Source #

complementBit :: BinP -> Int -> BinP Source #

testBit :: BinP -> Int -> Bool Source #

bitSizeMaybe :: BinP -> Maybe Int Source #

bitSize :: BinP -> Int Source #

isSigned :: BinP -> Bool Source #

shiftL :: BinP -> Int -> BinP Source #

unsafeShiftL :: BinP -> Int -> BinP Source #

shiftR :: BinP -> Int -> BinP Source #

unsafeShiftR :: BinP -> Int -> BinP Source #

rotateL :: BinP -> Int -> BinP Source #

rotateR :: BinP -> Int -> BinP Source #

popCount :: BinP -> Int Source #

NFData BinP Source #
Instance details

Defined in Data.BinP

Methods

rnf :: BinP -> () Source #

Hashable BinP Source #
Instance details

Defined in Data.BinP

Methods

hashWithSalt :: Int -> BinP -> Int Source #

hash :: BinP -> Int Source #

TestEquality SBinP Source #
Instance details

Defined in Data.Type.BinP

Methods

testEquality :: forall (a :: k) (b :: k). SBinP a -> SBinP b -> Maybe (a :~: b) Source #

Showing

explicitShow :: Bin -> String Source #

show displaying a structure of Bin . 

>>> explicitShow 0
"BZ"

>>> explicitShow 2
"BP (B0 BE)"

explicitShowsPrec :: Int -> Bin -> ShowS Source #

showsPrec displaying a structure of Bin .

Extras

predP :: BinP -> Bin Source #

This is a total function. 

>>> map predP [1..10]
[0,1,2,3,4,5,6,7,8,9]

mult2 :: Bin -> Bin Source #

mult2Plus1 :: Bin -> BinP Source #

Data.Bits

andP :: BinP -> BinP -> Bin Source #

xorP :: BinP -> BinP -> Bin Source #

complementBitP :: BinP -> Int -> Bin Source #

clearBitP :: BinP -> Int -> Bin Source #

Aliases

bin0 :: Bin Source #

bin1 :: Bin Source #

bin2 :: Bin Source #

bin3 :: Bin Source #

bin4 :: Bin Source #

bin5 :: Bin Source #

bin6 :: Bin Source #

bin7 :: Bin Source #

bin8 :: Bin Source #

bin9 :: Bin Source #