Binrep.Type.Magic

Magic numbers (also just magic): short constant bytestrings usually found at the top of a file, often used as an early sanity check.

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)

A singleton data type representing a "magic number" via a phantom type.

The phantom type variable unambiguously defines a constant bytestring. A handful of types are supported for using magics conveniently, e.g. for pure ASCII magics, you may use a Symbol type-level string.

Constructors

Magic

Instances

IsCBLen (Magic a :: Type)

The byte length of a magic is known at compile time.

Defined in Binrep.Type.Magic

Associated Types

type CBLen (Magic a) :: Natural

(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 (MagicBytes a)) => BLen (Magic a)

The byte length of a magic is obtained via reifying.

Defined in Binrep.Type.Magic

Methods

blen :: Magic a -> Int

(bs ~ MagicBytes a, ParseReifyBytesW64 bs, ReifyBytesW64 bs, KnownNat (Length bs)) => Get (Magic a)

Defined in Binrep.Type.Magic

Methods

get :: Getter (Magic a)

(bs ~ MagicBytes a, ParseReifyBytesW64 bs, ReifyBytesW64 bs, KnownNat (Length bs)) => GetC (Magic a)

Defined in Binrep.Type.Magic

Methods

getC :: GetterC (Magic a)

(bs ~ MagicBytes a, ReifyBytesW64 bs, KnownNat (Length bs)) => Put (Magic a)

Defined in Binrep.Type.Magic

Methods

put :: Magic a -> Putter

(bs ~ MagicBytes a, ReifyBytesW64 bs) => PutC (Magic a)

Defined in Binrep.Type.Magic

Methods

putC :: Magic a -> PutterC

Eq (Magic a)

Defined in Binrep.Type.Magic

Methods

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

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

Strengthen (Magic a)

Strengthen the unit to some Magic a.

Defined in Binrep.Type.Magic

Methods

strengthen :: Weak (Magic a) -> Result (Magic a)

Weaken (Magic a)

Weaken a Magic a to the unit.

Defined in Binrep.Type.Magic

Associated Types

type Weak (Magic a)

Methods

weaken :: Magic a -> Weak (Magic a)

type CBLen (Magic a :: Type)

Defined in Binrep.Type.Magic

type CBLen (Magic a :: Type) = Length (MagicBytes a)

type Rep (Magic a)

Defined in Binrep.Type.Magic

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

type Weak (Magic a)

Defined in Binrep.Type.Magic

type Weak (Magic a) = ()

type family Length (a :: [k]) :: Natural where ...

The length of a type-level list.

Equations

Length '[] = 0

Length (a ': as) = 1 + Length as

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)

class Magical (a :: k)

Types which define a magic value.

Associated Types

type MagicBytes a :: [Natural]

How to turn the type into a list of bytes.

Instances

Magical (sym :: Symbol)

Type-level symbols are turned into their Unicode codepoints - but multibyte characters aren't handled, so they'll simply be overlarge bytes, which will fail further down.

Defined in Binrep.Type.Magic

Associated Types

type MagicBytes sym :: [Natural]

Magical (ns :: [Natural])

Type-level naturals go as-is. (Make sure you don't go over 255, though!)

Defined in Binrep.Type.Magic

Associated Types

type MagicBytes ns :: [Natural]