Typewise there’s no problem with layered encodings. All I was trying to say was that I’m not sure what advantages it offers for data encodings since it isn’t possible to look at an encoded string and “see past” the first layer. Even for “multiply-escaped” strings I’m not sure if it’s possible to look at the string and see what type to give it in order to do the correct sequence of de-escaping.

I think it might be worth taking your point into consideration when comming up with the API for the string escaping library, but for data encodings I’m not convinced that a “layered type” is worth it in practice. Hell, I’m not even sure using a phantom type to record one level of encoding is worth it in practice.

But once past that, there’s no problem with nested encodings. Something UUEncoded then XMLEscaped would be of type Encoded XMLEsc (Encoded UUEnc String). You’ll have to tweak your definition of encode/decode to wrap or unwrap just one layer of encoding. It might be useful to define a NullEncoding that does nothing to get you from raw data to encoded data; then all your functions can work on encoded data.

It looks like the approach here would be to incarcerate a string into one encoding, decode, and then incarcerate it into a different encoding….

module Main where

import Data.Word

{-
'encoding' is a phantom type. It's not expressed in the structure of
the data (so no overhead), but the compiler knows about it and can use
it to typecheck.  'a' is a real type.  'Encoded encoding a' means an
'a', but wrapped in 'Encoded' so we know it's encoded, not raw data.
The compiler knows what kind of encoding you're using (the phantom
type), but once the code is compiled and known to work correctly, that
information is discarded and vanishes.
-}
data Encoded encoding a = Encoded a

{-
Here we define what it means to be a DataEncoding.
-}
class DataEncoding encoding where
    encode :: [Word8] -> Encoded encoding String
    decode :: Encoded encoding String -> [Word8]
    chop :: Int -> Encoded encoding String -> Encoded encoding [String]
    unchop :: Encoded encoding [String] -> Encoded encoding String
    liberate :: Encoded encoding a -> a
    incarcerate :: a -> Encoded encoding a

{-
Here we define one of the encodings.  The encoding doesn't have to
carry any information; it's just a tag to tell the compiler which
implementation of encode/decode/chop/etc. to use.  In fact, since it's
a phantom type which gets thrown out after compilation, there wouldn't
be any point to having it store data.
-}

data B16 = B16

{-
Here we define how we want to implement the functions for B16.
-}
instance DataEncoding B16 where
    encode ws = Encoded (b16Encode ws)
    decode (Encoded str) = b16Decode str
    chop n (Encoded str) = Encoded (b16Chop n str)
    unchop (Encoded strs) = Encoded (b16Upchop strs)
    liberate (Encoded whatever) = whatever
    incarcerate whatever = Encoded whatever

{-
Here are a bunch of dummy implementations of your functions.  They're
here just to provide the right type signatures.
-}

b16Encode :: [Word8] -> String
b16Encode = error "b16Encode"

b16Decode :: String -> [Word8]
b16Decode = error "b16Decode"

b16Chop :: Int -> String -> [String]
b16Chop = error "b16Chop"

b16Unchop :: [String] -> String
b16Unchop = error "b16Unchop"