WAGS.Universe.Bin

data Bit

A single bit

data I :: Bit

An on bit

Instances

• BinSucc Bn (Bc I Bn)
• BinSucc (Bc O r) (Bc I r)
• (BinSucc r r') => BinSucc (Bc I r) (Bc O r')
• BinSub' False (Bc I r) Bn (Bc I r)
• BinSub' True (Bc I r) Bn (Bc O r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc O o) (Bc I r)
• (BinSub' True i o r) => BinSub' False (Bc O i) (Bc I o) (Bc I r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc I o) (Bc O r)
• (BinSub' False (Bc I i) (Bc I o) x) => BinSub' True (Bc I i) (Bc O o) x
• (BinSub' True i o r) => BinSub' True (Bc O i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc I i) (Bc I o) x
• Beq O I False
• Beq I O False
• Beq I I True
• AllZerosToNull (Bc I o) (Bc I o)
• (RemoveTrailingZeros r r') => RemoveTrailingZeros (Bc I r) (Bc I r')
• (BinToInt r) => BinToInt (Bc I r)

data O :: Bit

An off bit

Instances

• BinSucc (Bc O r) (Bc I r)
• (BinSucc r r') => BinSucc (Bc I r) (Bc O r')
• BinSub' True (Bc I r) Bn (Bc O r)
• BinSub' False (Bc O r) Bn (Bc O r)
• (BinSub' True r Bn o) => BinSub' True (Bc O r) Bn o
• (BinSub' False i o r) => BinSub' False (Bc O i) (Bc O o) (Bc O r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc O o) (Bc I r)
• (BinSub' True i o r) => BinSub' False (Bc O i) (Bc I o) (Bc I r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc O i) (Bc O o) x
• (BinSub' False (Bc I i) (Bc I o) x) => BinSub' True (Bc I i) (Bc O o) x
• (BinSub' True i o r) => BinSub' True (Bc O i) (Bc I o) (Bc O r)
• Beq O O True
• Beq O I False
• Beq I O False
• (AllZerosToNull o x) => AllZerosToNull (Bc O o) x
• (AllZerosToNull r n, RemoveTrailingZeros r r', BinEq n Bn tf, Gate tf Bn (Bc O r') x) => RemoveTrailingZeros (Bc O r) x
• (BinToInt r) => BinToInt (Bc O r)

data Bits

0 or more bits. Note that, in all of the class operations on Bits, the lowest bit is in the leftmost position and the calculation proceeds from left to right. This is the opposite of how bits are usually represented (lowest on the right and highest on the left) but is more compuationally efficient.

data Bc :: Bit -> Bits -> Bits

Cons for bits

Instances

• BinSucc Bn (Bc I Bn)
• BinSucc (Bc O r) (Bc I r)
• (BinSucc r r') => BinSucc (Bc I r) (Bc O r')
• BinSub' False (Bc I r) Bn (Bc I r)
• BinSub' True (Bc I r) Bn (Bc O r)
• BinSub' False (Bc O r) Bn (Bc O r)
• (BinSub' True r Bn o) => BinSub' True (Bc O r) Bn o
• BinSub' True Bn (Bc x y) Bn
• BinSub' False Bn (Bc x y) Bn
• (BinSub' False i o r) => BinSub' False (Bc O i) (Bc O o) (Bc O r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc O o) (Bc I r)
• (BinSub' True i o r) => BinSub' False (Bc O i) (Bc I o) (Bc I r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc O i) (Bc O o) x
• (BinSub' False (Bc I i) (Bc I o) x) => BinSub' True (Bc I i) (Bc O o) x
• (BinSub' True i o r) => BinSub' True (Bc O i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc I i) (Bc I o) x
• BinEq Bn (Bc x y) False
• BinEq (Bc x y) Bn False
• (Beq a x tf, BinEq b y rest, And tf rest r) => BinEq (Bc a b) (Bc x y) r
• AllZerosToNull (Bc I o) (Bc I o)
• (AllZerosToNull o x) => AllZerosToNull (Bc O o) x
• (RemoveTrailingZeros r r') => RemoveTrailingZeros (Bc I r) (Bc I r')
• (AllZerosToNull r n, RemoveTrailingZeros r r', BinEq n Bn tf, Gate tf Bn (Bc O r') x) => RemoveTrailingZeros (Bc O r) x
• (BinToInt r) => BinToInt (Bc O r)
• (BinToInt r) => BinToInt (Bc I r)

data Bn :: Bits

Nil for bits

Instances

• BinSucc Bn (Bc I Bn)
• BinSub' False (Bc I r) Bn (Bc I r)
• BinSub' True (Bc I r) Bn (Bc O r)
• BinSub' False (Bc O r) Bn (Bc O r)
• (BinSub' True r Bn o) => BinSub' True (Bc O r) Bn o
• BinSub' True Bn (Bc x y) Bn
• BinSub' True Bn Bn Bn
• BinSub' False Bn (Bc x y) Bn
• BinSub' False Bn Bn Bn
• BinEq Bn Bn True
• BinEq Bn (Bc x y) False
• BinEq (Bc x y) Bn False
• AllZerosToNull Bn Bn
• RemoveTrailingZeros Bn Bn
• BinToInt Bn

type Ptr = Bits

Ptr is an alias for bits

data PtrList

A list of pointers

data PtrListCons :: Ptr -> PtrList -> PtrList

Cons for a pointer list

Instances

• PtrListKeepSingleton (PtrListCons a PtrListNil) PtrListNil (PtrListCons a PtrListNil)
• PtrListKeepSingleton PtrListNil (PtrListCons a PtrListNil) (PtrListCons a PtrListNil)

data PtrListNil :: PtrList

Nil for a pointer list

Instances

• PtrListKeepSingleton PtrListNil PtrListNil PtrListNil
• PtrListKeepSingleton (PtrListCons a PtrListNil) PtrListNil (PtrListCons a PtrListNil)
• PtrListKeepSingleton PtrListNil (PtrListCons a PtrListNil) (PtrListCons a PtrListNil)

toInt' :: forall (i :: Bits). BinToInt i => Proxy i -> Int

Cast a binary value to an int

toInt :: forall (i :: Bits). BinToInt i => Int

Cast a binary value to an int

class BinSucc (i :: Bits) (o :: Bits) | i -> o

Class representing the successor function for binary values.

Instances

• BinSucc Bn (Bc I Bn)
• BinSucc (Bc O r) (Bc I r)
• (BinSucc r r') => BinSucc (Bc I r) (Bc O r')

class BinSub (l :: Bits) (r :: Bits) (o :: Bits) | l r -> o

Class representing subtraction of binary values if l is greater than r and Bn otherwise.

Instances

• (BinSub' False l r o', RemoveTrailingZeros o' o) => BinSub l r o

class BinSub' (carrying :: Type) (l :: Bits) (r :: Bits) (o :: Bits) | carrying l r -> o

Internal class helping with binary subtraction.

Instances

• BinSub' False (Bc I r) Bn (Bc I r)
• BinSub' True (Bc I r) Bn (Bc O r)
• BinSub' False (Bc O r) Bn (Bc O r)
• (BinSub' True r Bn o) => BinSub' True (Bc O r) Bn o
• BinSub' True Bn (Bc x y) Bn
• BinSub' True Bn Bn Bn
• BinSub' False Bn (Bc x y) Bn
• BinSub' False Bn Bn Bn
• (BinSub' False i o r) => BinSub' False (Bc O i) (Bc O o) (Bc O r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc O o) (Bc I r)
• (BinSub' True i o r) => BinSub' False (Bc O i) (Bc I o) (Bc I r)
• (BinSub' False i o r) => BinSub' False (Bc I i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc O i) (Bc O o) x
• (BinSub' False (Bc I i) (Bc I o) x) => BinSub' True (Bc I i) (Bc O o) x
• (BinSub' True i o r) => BinSub' True (Bc O i) (Bc I o) (Bc O r)
• (BinSub' False (Bc O i) (Bc I o) x) => BinSub' True (Bc I i) (Bc I o) x

class Beq (a :: Bit) (b :: Bit) (tf :: Type) | a b -> tf

Class asking if two bits are equal and responding t if true and f otherwise, aka NOT XOR.

Instances

• Beq O O True
• Beq O I False
• Beq I O False
• Beq I I True

class BinEq (a :: Bits) (b :: Bits) (tf :: Type) | a b -> tf

Class asking if two binary values are equal and responding t if true and f otherwise.

Instances

• BinEq Bn Bn True
• BinEq Bn (Bc x y) False
• BinEq (Bc x y) Bn False
• (Beq a x tf, BinEq b y rest, And tf rest r) => BinEq (Bc a b) (Bc x y) r

class AllZerosToNull (i :: Bits) (o :: Bits) | i -> o

Class that turns a list of Os to Bn.

Instances

• AllZerosToNull Bn Bn
• AllZerosToNull (Bc I o) (Bc I o)
• (AllZerosToNull o x) => AllZerosToNull (Bc O o) x

class RemoveTrailingZeros (i :: Bits) (o :: Bits) | i -> o

Class that removes trailing 0s from a binary number.

Instances

• RemoveTrailingZeros Bn Bn
• (RemoveTrailingZeros r r') => RemoveTrailingZeros (Bc I r) (Bc I r')
• (AllZerosToNull r n, RemoveTrailingZeros r r', BinEq n Bn tf, Gate tf Bn (Bc O r') x) => RemoveTrailingZeros (Bc O r) x

Operator alias for WAGS.Universe.Bin.PtrListCons (right-associative / precedence 5)

class PtrListKeepSingleton (ptrListA :: PtrList) (ptrListB :: PtrList) (ptrListC :: PtrList) | ptrListA ptrListB -> ptrListC

Like Alt for a list of pointers that also serves as an assertion that the positive result, if one exists, is a single pointer.

Instances

• PtrListKeepSingleton PtrListNil PtrListNil PtrListNil
• PtrListKeepSingleton (PtrListCons a PtrListNil) PtrListNil (PtrListCons a PtrListNil)
• PtrListKeepSingleton PtrListNil (PtrListCons a PtrListNil) (PtrListCons a PtrListNil)

class BinToInt (i :: Bits)  where

Internal helper class to cast a binary value to an int.

Members

• toInt'' :: Int -> Proxy i -> Int

  Not for public use - used internally in public functions toInt' and toInt.

Instances

• BinToInt Bn
• (BinToInt r) => BinToInt (Bc O r)
• (BinToInt r) => BinToInt (Bc I r)