Data.Bin

Binary natural numbers, Bin.

This module is designed to be imported qualified.

Binary natural numbers

data Bin

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

Arbitrary Bin

Defined in Data.Bin

Methods

arbitrary :: Gen Bin

shrink :: Bin -> [Bin]

CoArbitrary Bin

Defined in Data.Bin

Methods

coarbitrary :: Bin -> Gen b -> Gen b

Function Bin

Defined in Data.Bin

Methods

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

Data Bin

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

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

toConstr :: Bin -> Constr

dataTypeOf :: Bin -> DataType

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

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

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

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

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

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

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

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

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

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

Bits Bin

Defined in Data.Bin

Methods

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

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

xor :: Bin -> Bin -> Bin

complement :: Bin -> Bin

shift :: Bin -> Int -> Bin

rotate :: Bin -> Int -> Bin

zeroBits :: Bin

bit :: Int -> Bin

setBit :: Bin -> Int -> Bin

clearBit :: Bin -> Int -> Bin

complementBit :: Bin -> Int -> Bin

testBit :: Bin -> Int -> Bool

bitSizeMaybe :: Bin -> Maybe Int

bitSize :: Bin -> Int

isSigned :: Bin -> Bool

shiftL :: Bin -> Int -> Bin

unsafeShiftL :: Bin -> Int -> Bin

shiftR :: Bin -> Int -> Bin

unsafeShiftR :: Bin -> Int -> Bin

rotateL :: Bin -> Int -> Bin

rotateR :: Bin -> Int -> Bin

popCount :: Bin -> Int

Enum Bin

>>> 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]

Defined in Data.Bin

Methods

succ :: Bin -> Bin

pred :: Bin -> Bin

toEnum :: Int -> Bin

fromEnum :: Bin -> Int

enumFrom :: Bin -> [Bin]

enumFromThen :: Bin -> Bin -> [Bin]

enumFromTo :: Bin -> Bin -> [Bin]

enumFromThenTo :: Bin -> Bin -> Bin -> [Bin]

Num Bin

>>> 0 + 2 :: Bin
2

>>> 1 + 2 :: Bin
3

>>> 4 * 8 :: Bin
32

>>> 7 * 7 :: Bin
49

Defined in Data.Bin

Methods

(+) :: Bin -> Bin -> Bin

(-) :: Bin -> Bin -> Bin

(*) :: Bin -> Bin -> Bin

negate :: Bin -> Bin

abs :: Bin -> Bin

signum :: Bin -> Bin

fromInteger :: Integer -> Bin

Integral Bin

Defined in Data.Bin

Methods

quot :: Bin -> Bin -> Bin

rem :: Bin -> Bin -> Bin

div :: Bin -> Bin -> Bin

mod :: Bin -> Bin -> Bin

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

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

toInteger :: Bin -> Integer

Real Bin

Defined in Data.Bin

Methods

toRational :: Bin -> Rational

Show Bin

Bin is printed as Natural.

To see explicit structure, use explicitShow or explicitShowsPrec

Defined in Data.Bin

Methods

showsPrec :: Int -> Bin -> ShowS

show :: Bin -> String

showList :: [Bin] -> ShowS

NFData Bin

Defined in Data.Bin

Methods

rnf :: Bin -> ()

Eq Bin

Defined in Data.Bin

Methods

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

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

Ord Bin

Defined in Data.Bin

Methods

compare :: Bin -> Bin -> Ordering

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

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

(>) :: Bin -> Bin -> Bool

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

max :: Bin -> Bin -> Bin

min :: Bin -> Bin -> Bin

Hashable Bin

Defined in Data.Bin

Methods

hashWithSalt :: Int -> Bin -> Int

hash :: Bin -> Int

TestEquality SBin

Defined in Data.Type.Bin

Methods

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

EqP Pos

>>> eqp (top :: Pos Bin4) (top :: Pos Bin6)
True

>>> let xs = universe @Bin4; ys = universe @Bin6 in traverse_ print [ [ eqp x y | y <- ys ] | x <- xs ]
[True,False,False,False,False,False]
[False,True,False,False,False,False]
[False,False,True,False,False,False]
[False,False,False,True,False,False]

Since: 0.1.3

Defined in Data.Bin.Pos

Methods

eqp :: forall (a :: k) (b :: k). Pos a -> Pos b -> Bool

EqP SBin

Since: 0.1.3

Defined in Data.Type.Bin

Methods

eqp :: forall (a :: k) (b :: k). SBin a -> SBin b -> Bool

GNFData SBin

Since: 0.1.2

Defined in Data.Type.Bin

Methods

grnf :: forall (a :: k). SBin a -> ()

GEq SBin

Since: 0.1.2

Defined in Data.Type.Bin

Methods

geq :: forall (a :: k) (b :: k). SBin a -> SBin b -> Maybe (a :~: b)

GShow Pos

Since: 0.1.3

Defined in Data.Bin.Pos

Methods

gshowsPrec :: forall (a :: k). Int -> Pos a -> ShowS

GShow SBin

Since: 0.1.2

Defined in Data.Type.Bin

Methods

gshowsPrec :: forall (a :: k). Int -> SBin a -> ShowS

OrdP Pos

>>> let xs = universe @Bin4; ys = universe @Bin6 in traverse_ print [ [ comparep x y | y <- ys ] | x <- xs ]
[EQ,LT,LT,LT,LT,LT]
[GT,EQ,LT,LT,LT,LT]
[GT,GT,EQ,LT,LT,LT]
[GT,GT,GT,EQ,LT,LT]

Since: 0.1.3

Defined in Data.Bin.Pos

Methods

comparep :: forall (a :: k) (b :: k). Pos a -> Pos b -> Ordering

toNatural :: Bin -> Natural

Convert Bin to Natural

>>> toNatural 0
0

>>> toNatural 2
2

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

fromNatural :: Natural -> Bin

Convert Natural to Nat

>>> fromNatural 4
4

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

toNat :: Bin -> Nat

Convert from Bin to Nat.

>>> toNat 5
5

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

fromNat :: Nat -> Bin

Convert from Nat to Bin.

>>> fromNat 5
5

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

cata

Arguments

:: a

\(0\)

-> a

\(1\)

-> (a -> a)

\(2x\)

-> (a -> a)

\(2x + 1\)

-> Bin

-> a

Fold Bin.

Positive natural numbers

data BinP

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

Arbitrary BinP

Defined in Data.BinP

Methods

arbitrary :: Gen BinP

shrink :: BinP -> [BinP]

CoArbitrary BinP

Defined in Data.BinP

Methods

coarbitrary :: BinP -> Gen b -> Gen b

Function BinP

Defined in Data.BinP

Methods

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

Data BinP

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

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

toConstr :: BinP -> Constr

dataTypeOf :: BinP -> DataType

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

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

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

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

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

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

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

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

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

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

Bits BinP

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

Defined in Data.BinP

Methods

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

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

xor :: BinP -> BinP -> BinP

complement :: BinP -> BinP

shift :: BinP -> Int -> BinP

rotate :: BinP -> Int -> BinP

zeroBits :: BinP

bit :: Int -> BinP

setBit :: BinP -> Int -> BinP

clearBit :: BinP -> Int -> BinP

complementBit :: BinP -> Int -> BinP

testBit :: BinP -> Int -> Bool

bitSizeMaybe :: BinP -> Maybe Int

bitSize :: BinP -> Int

isSigned :: BinP -> Bool

shiftL :: BinP -> Int -> BinP

unsafeShiftL :: BinP -> Int -> BinP

shiftR :: BinP -> Int -> BinP

unsafeShiftR :: BinP -> Int -> BinP

rotateL :: BinP -> Int -> BinP

rotateR :: BinP -> Int -> BinP

popCount :: BinP -> Int

Enum BinP

Defined in Data.BinP

Methods

succ :: BinP -> BinP

pred :: BinP -> BinP

toEnum :: Int -> BinP

fromEnum :: BinP -> Int

enumFrom :: BinP -> [BinP]

enumFromThen :: BinP -> BinP -> [BinP]

enumFromTo :: BinP -> BinP -> [BinP]

enumFromThenTo :: BinP -> BinP -> BinP -> [BinP]

Num BinP

Defined in Data.BinP

Methods

(+) :: BinP -> BinP -> BinP

(-) :: BinP -> BinP -> BinP

(*) :: BinP -> BinP -> BinP

negate :: BinP -> BinP

abs :: BinP -> BinP

signum :: BinP -> BinP

fromInteger :: Integer -> BinP

Integral BinP

Defined in Data.BinP

Methods

quot :: BinP -> BinP -> BinP

rem :: BinP -> BinP -> BinP

div :: BinP -> BinP -> BinP

mod :: BinP -> BinP -> BinP

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

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

toInteger :: BinP -> Integer

Real BinP

Defined in Data.BinP

Methods

toRational :: BinP -> Rational

Show BinP

Defined in Data.BinP

Methods

showsPrec :: Int -> BinP -> ShowS

show :: BinP -> String

showList :: [BinP] -> ShowS

NFData BinP

Defined in Data.BinP

Methods

rnf :: BinP -> ()

Eq BinP

Defined in Data.BinP

Methods

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

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

Ord BinP

>>> sort [ 1 .. 9 :: BinP ]
[1,2,3,4,5,6,7,8,9]

>>> sort $ reverse [ 1 .. 9 :: BinP ]
[1,2,3,4,5,6,7,8,9]

>>> sort $ [ 1 .. 9 ] ++ [ 1 .. 9 :: BinP ]
[1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9]

Defined in Data.BinP

Methods

compare :: BinP -> BinP -> Ordering

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

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

(>) :: BinP -> BinP -> Bool

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

max :: BinP -> BinP -> BinP

min :: BinP -> BinP -> BinP

Hashable BinP

Defined in Data.BinP

Methods

hashWithSalt :: Int -> BinP -> Int

hash :: BinP -> Int

TestEquality SBinP

Defined in Data.Type.BinP

Methods

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

EqP PosP

Since: 0.1.3

Defined in Data.BinP.PosP

Methods

eqp :: forall (a :: k) (b :: k). PosP a -> PosP b -> Bool

EqP SBinP

Since: 0.1.3

Defined in Data.Type.BinP

Methods

eqp :: forall (a :: k) (b :: k). SBinP a -> SBinP b -> Bool

GNFData SBinP

Since: 0.1.2

Defined in Data.Type.BinP

Methods

grnf :: forall (a :: k). SBinP a -> ()

GEq SBinP

Since: 0.1.2

Defined in Data.Type.BinP

Methods

geq :: forall (a :: k) (b :: k). SBinP a -> SBinP b -> Maybe (a :~: b)

GShow PosP

Since: 0.1.3

Defined in Data.BinP.PosP

Methods

gshowsPrec :: forall (a :: k). Int -> PosP a -> ShowS

GShow SBinP

Since: 0.1.2

Defined in Data.Type.BinP

Methods

gshowsPrec :: forall (a :: k). Int -> SBinP a -> ShowS

OrdP PosP

Since: 0.1.3

Defined in Data.BinP.PosP

Methods

comparep :: forall (a :: k) (b :: k). PosP a -> PosP b -> Ordering

SNatI n => GShow (PosP' n :: BinP -> Type)

Since: 0.1.3

Defined in Data.BinP.PosP

Methods

gshowsPrec :: forall (a :: k). Int -> PosP' n a -> ShowS

Showing

explicitShow :: Bin -> String

show displaying a structure of Bin.

>>> explicitShow 0
"BZ"

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

explicitShowsPrec :: Int -> Bin -> ShowS

showsPrec displaying a structure of Bin.

Extras

predP :: BinP -> Bin

This is a total function.

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

mult2 :: Bin -> Bin

mult2Plus1 :: Bin -> BinP

Data.Bits

andP :: BinP -> BinP -> Bin

xorP :: BinP -> BinP -> Bin

complementBitP :: BinP -> Int -> Bin

clearBitP :: BinP -> Int -> Bin

Aliases

bin0 :: Bin

bin1 :: Bin

bin2 :: Bin

bin3 :: Bin

bin4 :: Bin

bin5 :: Bin

bin6 :: Bin

bin7 :: Bin

bin8 :: Bin

bin9 :: Bin