Binrep.Type.Magic

Magic numbers (also just magic): short constant bytestrings usually found at the top of a file, included as a safety check for parsing.

TODO rename: MagicBytes -> MagicVals, and have ByteVal be a "consumer" of MagicVals where each value must be a byte. (It's conceivable that we have another consumer which makes each value into a non-empty list of bytes, LE/BE.)

TODO unassociated type fams bad (maybe). turn into class -- and turn the reifier into a default method! (TODO think about this)

There are two main flavors of magics:

• "random" bytes e.g. Zstandard: 28 B5 2F FD
• printable ASCII bytes e.g. Ogg: 4F 67 67 53 -> OggS

For bytewise magics, use type-level Natural lists. For ASCII magics, use Symbols (type-level strings).

Previously, I squashed these into a representationally-safe type. Now the check only occurs during reification. So you are able to define invalid magics now (bytes over 255, non-ASCII characters), and potentially use them, but you'll get a clear type error like "no instance for ByteVal 256" when attempting to reify.

String magics are restricted to ASCII, and will type error during reification otherwise. If you really want UTF-8, please read UTF8.

Documentation

data Magic (a :: k)

Constructors

Magic

Instances

(Typeable a, Typeable k) => Data (Magic a)

Defined in Binrep.Type.Magic

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Magic a -> c (Magic a)

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

toConstr :: Magic a -> Constr

dataTypeOf :: Magic a -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Magic a -> Magic a

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

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

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

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

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

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

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

Generic (Magic a)

Defined in Binrep.Type.Magic

Associated Types

type Rep (Magic a) :: Type -> Type

Methods

from :: Magic a -> Rep (Magic a) x

to :: Rep (Magic a) x -> Magic a

Show (Magic a)

Defined in Binrep.Type.Magic

Methods

showsPrec :: Int -> Magic a -> ShowS

show :: Magic a -> String

showList :: [Magic a] -> ShowS

KnownNat (Length (MagicVals a)) => BLen (Magic a)

Assumes magic values are individual bytes.

Defined in Binrep.Type.Magic

Methods

blen :: Magic a -> BLenT

(bs ~ MagicVals a, ByteVals bs) => Get (Magic a)

Forces magic values to be individual bytes.

TODO improve show - maybe hexbytestring goes here? lol

Defined in Binrep.Type.Magic

Methods

get :: Getter (Magic a)

(bs ~ MagicVals a, ByteVals bs) => Put (Magic a)

Forces magic values to be individual bytes.

Defined in Binrep.Type.Magic

Methods

put :: Magic a -> Builder

Eq (Magic a)

Defined in Binrep.Type.Magic

Methods

(==) :: Magic a -> Magic a -> Bool

(/=) :: Magic a -> Magic a -> Bool

type Rep (Magic a)

Defined in Binrep.Type.Magic

type Rep (Magic a) = D1 ('MetaData "Magic" "Binrep.Type.Magic" "binrep-0.2.0-inplace" 'False) (C1 ('MetaCons "Magic" 'PrefixI 'False) (U1 :: Type -> Type))

type CBLen (Magic a)

Assumes magic values are individual bytes.

Defined in Binrep.Type.Magic

type CBLen (Magic a) = Length (MagicVals a)

type family MagicVals (a :: k) :: [Natural]

Instances

type MagicVals (a :: Symbol)

Defined in Binrep.Type.Magic

type MagicVals (a :: Symbol) = SymbolUnicodeCodepoints a

type MagicVals (a :: [Natural])

Defined in Binrep.Type.Magic

type MagicVals (a :: [Natural]) = a

type family SymbolUnicodeCodepoints (a :: Symbol) :: [Natural] where ...

Equations

SymbolUnicodeCodepoints a = CharListUnicodeCodepoints (SymbolAsCharList a)

type family CharListUnicodeCodepoints (a :: [Char]) :: [Natural] where ...

Equations

CharListUnicodeCodepoints '[] = '[]

CharListUnicodeCodepoints (c ': cs) = CharToNat c ': CharListUnicodeCodepoints cs

type family SymbolAsCharList (a :: Symbol) :: [Char] where ...

Equations

SymbolAsCharList a = SymbolAsCharList' (UnconsSymbol a)

type family SymbolAsCharList' (a :: Maybe (Char, Symbol)) :: [Char] where ...

Equations

SymbolAsCharList' 'Nothing = '[]

SymbolAsCharList' ('Just '(c, s)) = c ': SymbolAsCharList' (UnconsSymbol s)