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.

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)

An empty data type representing a magic number (a constant bytestring) via a phantom type.

The phantom type variable unambiguously defines a short, 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

(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)

Defined in Binrep.Type.Magic

Associated Types

type CBLen (Magic a) :: Natural

Methods

blen :: Magic a -> BLenT

(bs ~ MagicBytes a, ReifyBytes bs) => Get (Magic a)

Defined in Binrep.Type.Magic

Methods

get :: Getter (Magic a)

(bs ~ MagicBytes a, ReifyBytes bs) => Put (Magic a)

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

Strengthen (Magic a)

Strengthen the unit to some 'Magic a'.

Defined in Binrep.Type.Magic

Methods

strengthen :: Weak (Magic a) -> Validation (NonEmpty StrengthenFail) (Magic a)

Weaken (Magic a)

Weaken a 'Magic a' to the unit. Perhaps you prefer pattern matching on () over Magic, or wish a weak type to be fully divorced from its binrep origins.

Defined in Binrep.Type.Magic

Associated Types

type Weak (Magic a)

Methods

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

type Rep (Magic a)

Defined in Binrep.Type.Magic

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

type CBLen (Magic a)

Defined in Binrep.Type.Magic

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

type Weak (Magic a)

Defined in Binrep.Type.Magic

type Weak (Magic 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)

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]