-- {-# LANGUAGE PolyKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeOperators #-}

-- | Combinators for creating encoding using existing encodings.
-- 
-- @since 0.4.2.0
module Data.TypedEncoding.Instances.Support.Bool where

import           Data.TypedEncoding.Combinators.Unsafe
import           Data.TypedEncoding.Common.Types.Enc
import           Data.Proxy
import           Data.TypedEncoding.Common.Types
import           GHC.TypeLits

-- import           Data.TypedEncoding.Instances.Restriction.BoundedAlphaNums (encFBan)
-- import           Data.TypedEncoding

-- $setup
-- >>> :set -XDataKinds -XFlexibleInstances -XFlexibleContexts -XOverloadedStrings -XTypeApplications -XScopedTypeVariables
-- >>> import           Data.TypedEncoding
-- >>> import           Data.TypedEncoding.Instances.Restriction.BoundedAlphaNums (encFBan)

-- | Defines new encoding by specifying 2 encodings, one needs to succeed.
--  
-- @since 0.4.2.0
implEncOr' :: forall alg alg1 alg2 nm nm1 nm2 c str . (KnownSymbol nm) =>
               Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm2 alg2 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
implEncOr' :: Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncOr' Encoding (Either EncodeEx) nm1 alg1 c str
enc1 Encoding (Either EncodeEx) nm2 alg2 c str
enc2 = Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs c str
    -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Encoding (Either EncodeEx) nm alg c str
forall (nm :: Symbol) conf str (f :: * -> *) (alg :: Symbol).
Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs conf str
    -> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str))
-> Encoding f nm alg conf str
UnsafeMkEncoding Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy forall (xs :: [Symbol]).
Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f
   where 
       f :: forall xs . Enc xs c str -> Either EncodeEx (Enc (nm ': xs) c str)
       f :: Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f Enc @[Symbol] xs c str
enc = 
           case Encoding (Either EncodeEx) nm1 alg1 c str
-> Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm1 xs) c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Encoding f nm alg conf str
-> Enc @[Symbol] xs conf str
-> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str)
runEncoding' @alg1 @nm1 Encoding (Either EncodeEx) nm1 alg1 c str
enc1 Enc @[Symbol] xs c str
enc of
               Right Enc @[Symbol] ((':) @Symbol nm1 xs) c str
r -> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. b -> Either a b
Right (Enc @[Symbol] ((':) @Symbol nm xs) c str
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ (str -> str)
-> Enc @[Symbol] ((':) @Symbol nm1 xs) c str
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
forall k1 k2 s1 s2 (e1 :: k1) c (e2 :: k2).
(s1 -> s2) -> Enc @k1 e1 c s1 -> Enc @k2 e2 c s2
withUnsafeCoerce str -> str
forall a. a -> a
id Enc @[Symbol] ((':) @Symbol nm1 xs) c str
r
               Left (EncodeEx Proxy @Symbol x
_ a
err1) -> 
                   case Encoding (Either EncodeEx) nm2 alg2 c str
-> Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm2 xs) c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Encoding f nm alg conf str
-> Enc @[Symbol] xs conf str
-> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str)
runEncoding' @alg2 @nm2 Encoding (Either EncodeEx) nm2 alg2 c str
enc2 Enc @[Symbol] xs c str
enc of 
                       Right Enc @[Symbol] ((':) @Symbol nm2 xs) c str
r -> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. b -> Either a b
Right (Enc @[Symbol] ((':) @Symbol nm xs) c str
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ (str -> str)
-> Enc @[Symbol] ((':) @Symbol nm2 xs) c str
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
forall k1 k2 s1 s2 (e1 :: k1) c (e2 :: k2).
(s1 -> s2) -> Enc @k1 e1 c s1 -> Enc @k2 e2 c s2
withUnsafeCoerce str -> str
forall a. a -> a
id Enc @[Symbol] ((':) @Symbol nm2 xs) c str
r
                       Left (EncodeEx Proxy @Symbol x
_ a
err2) -> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> (a, a) -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) (a
err1, a
err2)

implEncOr :: forall nm nm1 nm2 c str . (KnownSymbol nm) =>
               Encoding (Either EncodeEx) nm1 nm1 c str 
               -> Encoding (Either EncodeEx) nm2 nm2 c str 
               -> Encoding (Either EncodeEx) nm nm c str 
implEncOr :: Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm2 nm2 c str
-> Encoding (Either EncodeEx) nm nm c str
implEncOr = forall (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
KnownSymbol nm =>
Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm2 nm2 c str
-> Encoding (Either EncodeEx) nm nm c str
forall (alg :: Symbol) (alg1 :: Symbol) (alg2 :: Symbol)
       (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
KnownSymbol nm =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncOr' @nm @nm1 @nm2             



-- |
-- 
-- >>> let tst = _implEncOr @"r-tst:999(9)" @"r-ban:9999" @"r-ban:999" @() @String encFBan encFBan
--
-- >>> fmap displ $ _runEncoding tst $ toEncoding () "123"
-- Right "Enc '[r-tst:999(9)] () (String 123)"
--
-- >>> fmap displ $ _runEncoding tst $ toEncoding () "1234"
-- Right "Enc '[r-tst:999(9)] () (String 1234)"
--
-- >>> fmap displ $ _runEncoding tst $ toEncoding () "12345"
-- Left (EncodeEx "r-tst:999(9)" (("Input list has wrong size expecting 4 but length \"12345\" == 5","Input list has wrong size expecting 3 but length \"12345\" == 5")))
--
-- @since 0.4.2.0
_implEncOr :: forall nm nm1 nm2 c str alg alg1 alg2. 
              (
                KnownSymbol nm
              , Algorithm nm alg
              , Algorithm nm1 alg1
              , Algorithm nm2 alg2
               ) =>
               Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm2 alg2 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
_implEncOr :: Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
_implEncOr = forall (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
KnownSymbol nm =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
forall (alg :: Symbol) (alg1 :: Symbol) (alg2 :: Symbol)
       (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
KnownSymbol nm =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncOr' @alg @alg1 @alg2      


-- | Defines new encoding by specifying 2 encodings, both needs to succeed and produce the same payload.
--  
-- @since 0.4.2.0
implEncAnd' :: forall alg alg1 alg2 nm nm1 nm2 c str . (KnownSymbol nm, Eq str) =>
               Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm2 alg2 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
implEncAnd' :: Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncAnd' Encoding (Either EncodeEx) nm1 alg1 c str
enc1 Encoding (Either EncodeEx) nm2 alg2 c str
enc2 = Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs c str
    -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Encoding (Either EncodeEx) nm alg c str
forall (nm :: Symbol) conf str (f :: * -> *) (alg :: Symbol).
Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs conf str
    -> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str))
-> Encoding f nm alg conf str
UnsafeMkEncoding Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy forall (xs :: [Symbol]).
Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f
   where 
       f :: forall xs . Enc xs c str -> Either EncodeEx (Enc (nm ': xs) c str)
       f :: Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f Enc @[Symbol] xs c str
enc = 
            case (Encoding (Either EncodeEx) nm1 alg1 c str
-> Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm1 xs) c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Encoding f nm alg conf str
-> Enc @[Symbol] xs conf str
-> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str)
runEncoding' @alg1 @nm1 Encoding (Either EncodeEx) nm1 alg1 c str
enc1 Enc @[Symbol] xs c str
enc, Encoding (Either EncodeEx) nm2 alg2 c str
-> Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm2 xs) c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Encoding f nm alg conf str
-> Enc @[Symbol] xs conf str
-> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str)
runEncoding' @alg2 @nm2 Encoding (Either EncodeEx) nm2 alg2 c str
enc2 Enc @[Symbol] xs c str
enc) of
                (Right Enc @[Symbol] ((':) @Symbol nm1 xs) c str
r1, Right Enc @[Symbol] ((':) @Symbol nm2 xs) c str
r2) -> if Enc @[Symbol] ((':) @Symbol nm1 xs) c str -> str
forall k (enc :: k) conf str. Enc @k enc conf str -> str
getPayload Enc @[Symbol] ((':) @Symbol nm1 xs) c str
r1 str -> str -> Bool
forall a. Eq a => a -> a -> Bool
== Enc @[Symbol] ((':) @Symbol nm2 xs) c str -> str
forall k (enc :: k) conf str. Enc @k enc conf str -> str
getPayload Enc @[Symbol] ((':) @Symbol nm2 xs) c str
r2 
                                       then Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. b -> Either a b
Right (Enc @[Symbol] ((':) @Symbol nm xs) c str
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ (str -> str)
-> Enc @[Symbol] ((':) @Symbol nm1 xs) c str
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
forall k1 k2 s1 s2 (e1 :: k1) c (e2 :: k2).
(s1 -> s2) -> Enc @k1 e1 c s1 -> Enc @k2 e2 c s2
withUnsafeCoerce str -> str
forall a. a -> a
id Enc @[Symbol] ((':) @Symbol nm1 xs) c str
r1
                                       else EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> [Char] -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) [Char]
"Non-matching encodings"
                (Left (EncodeEx Proxy @Symbol x
_ a
err1), Left (EncodeEx Proxy @Symbol x
_ a
err2)) -> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> (a, a) -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) (a
err1, a
err2)
                (Left (EncodeEx Proxy @Symbol x
_ a
err), Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm2 xs) c str)
_) -> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> (a, ()) -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) (a
err, ())
                (Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm1 xs) c str)
_, Left (EncodeEx Proxy @Symbol x
_ a
err)) -> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> ((), a) -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) ((), a
err)

implEncAnd :: forall nm nm1 nm2 c str . (KnownSymbol nm, Eq str) =>
               Encoding (Either EncodeEx) nm1 nm1 c str 
               -> Encoding (Either EncodeEx) nm2 nm2 c str 
               -> Encoding (Either EncodeEx) nm nm c str 
implEncAnd :: Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm2 nm2 c str
-> Encoding (Either EncodeEx) nm nm c str
implEncAnd = forall (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
(KnownSymbol nm, Eq str) =>
Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm2 nm2 c str
-> Encoding (Either EncodeEx) nm nm c str
forall (alg :: Symbol) (alg1 :: Symbol) (alg2 :: Symbol)
       (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
(KnownSymbol nm, Eq str) =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncAnd' @nm @nm1 @nm2             

-- | 
--
-- >>> let tst2 = _implEncAnd @"r-tst:99" @"r-ban:9Z" @"r-ban:Z9" @() @String encFBan encFBan
--
-- >>> fmap displ $ _runEncoding tst2 $ toEncoding () "99"
-- Right "Enc '[r-tst:99] () (String 99)"
--
-- >>> fmap displ $ _runEncoding tst2 $ toEncoding () "AB"
-- Left (EncodeEx "r-tst:99" (("'A' not bounded by '9'","'B' not bounded by '9'")))
--
-- @since 0.4.2.0
_implEncAnd :: forall nm nm1 nm2 c str alg alg1 alg2. 
              (
                KnownSymbol nm
              , Eq str
              , Algorithm nm alg
              , Algorithm nm1 alg1
              , Algorithm nm2 alg2
               ) =>
               Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm2 alg2 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
_implEncAnd :: Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
_implEncAnd = forall (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
(KnownSymbol nm, Eq str) =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
forall (alg :: Symbol) (alg1 :: Symbol) (alg2 :: Symbol)
       (nm :: Symbol) (nm1 :: Symbol) (nm2 :: Symbol) c str.
(KnownSymbol nm, Eq str) =>
Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm2 alg2 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncAnd' @alg @alg1 @alg2

-- | Defines new encoding which succeeds only if specified encoding fails.
-- It that happens, it applies given transformation function.    
--  
-- @since 0.4.2.0
implEncNot' :: forall alg alg1 nm nm1 c str . (KnownSymbol nm) =>
               (str -> str)
               -> Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
implEncNot' :: (str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncNot' str -> str
fn Encoding (Either EncodeEx) nm1 alg1 c str
enc1 = Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs c str
    -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Encoding (Either EncodeEx) nm alg c str
forall (nm :: Symbol) conf str (f :: * -> *) (alg :: Symbol).
Proxy @Symbol nm
-> (forall (xs :: [Symbol]).
    Enc @[Symbol] xs conf str
    -> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str))
-> Encoding f nm alg conf str
UnsafeMkEncoding Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy forall (xs :: [Symbol]).
Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f
   where 
       f :: forall xs . Enc xs c str -> Either EncodeEx (Enc (nm ': xs) c str)
       f :: Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
f Enc @[Symbol] xs c str
enc = 
           case Encoding (Either EncodeEx) nm1 alg1 c str
-> Enc @[Symbol] xs c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm1 xs) c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Encoding f nm alg conf str
-> Enc @[Symbol] xs conf str
-> f (Enc @[Symbol] ((':) @Symbol nm xs) conf str)
runEncoding' @alg1 @nm1 Encoding (Either EncodeEx) nm1 alg1 c str
enc1 Enc @[Symbol] xs c str
enc of
               Left EncodeEx
_ -> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. b -> Either a b
Right (Enc @[Symbol] ((':) @Symbol nm xs) c str
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ (str -> str)
-> Enc @[Symbol] xs c str
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
forall k1 k2 s1 s2 (e1 :: k1) c (e2 :: k2).
(s1 -> s2) -> Enc @k1 e1 c s1 -> Enc @k2 e2 c s2
withUnsafeCoerce str -> str
fn Enc @[Symbol] xs c str
enc
               Right Enc @[Symbol] ((':) @Symbol nm1 xs) c str
_ ->  EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. a -> Either a b
Left (EncodeEx
 -> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str))
-> EncodeEx
-> Either EncodeEx (Enc @[Symbol] ((':) @Symbol nm xs) c str)
forall a b. (a -> b) -> a -> b
$ Proxy @Symbol nm -> [Char] -> EncodeEx
forall a (x :: Symbol).
(Show a, KnownSymbol x) =>
Proxy @Symbol x -> a -> EncodeEx
EncodeEx (Proxy @Symbol nm
forall k (t :: k). Proxy @k t
Proxy :: Proxy nm) [Char]
"Negated encoding succeeded"

implEncNot :: forall nm nm1 c str . (KnownSymbol nm) =>
               (str -> str)
               -> Encoding (Either EncodeEx) nm1 nm1 c str 
               -> Encoding (Either EncodeEx) nm nm c str 
implEncNot :: (str -> str)
-> Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm nm c str
implEncNot = forall (nm :: Symbol) (nm1 :: Symbol) c str.
KnownSymbol nm =>
(str -> str)
-> Encoding (Either EncodeEx) nm1 nm1 c str
-> Encoding (Either EncodeEx) nm nm c str
forall (alg :: Symbol) (alg1 :: Symbol) (nm :: Symbol)
       (nm1 :: Symbol) c str.
KnownSymbol nm =>
(str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncNot' @nm @nm1             

_implEncNot :: forall nm nm1 c str alg alg1 . 
              (
                KnownSymbol nm
              , Algorithm nm alg
              , Algorithm nm1 alg1
               ) =>
               (str -> str)
               -> Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
_implEncNot :: (str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
_implEncNot = forall (nm :: Symbol) (nm1 :: Symbol) c str.
KnownSymbol nm =>
(str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
forall (alg :: Symbol) (alg1 :: Symbol) (nm :: Symbol)
       (nm1 :: Symbol) c str.
KnownSymbol nm =>
(str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncNot' @alg @alg1

-- | Defines restriction encoding that succeeds when specified encoding fails
--  
--
-- >>> let tst3 = _implREncNot @"r-tstnot:99" @"r-ban:99" @() @String encFBan 
--
-- >>> fmap displ $ _runEncoding tst3 $ toEncoding () "AA"
-- Right "Enc '[r-tstnot:99] () (String AA)"
--
-- >>> fmap displ $ _runEncoding tst3 $ toEncoding () "99"
-- Left (EncodeEx "r-tstnot:99" ("Negated encoding succeeded"))
--
-- @since 0.4.2.0
_implREncNot :: forall nm nm1 c str alg alg1 . 
              (
                KnownSymbol nm
              , Algorithm nm alg
              , Algorithm nm1 alg1
               ) =>
               Encoding (Either EncodeEx) nm1 alg1 c str 
               -> Encoding (Either EncodeEx) nm alg c str 
_implREncNot :: Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
_implREncNot = (str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
forall (alg :: Symbol) (alg1 :: Symbol) (nm :: Symbol)
       (nm1 :: Symbol) c str.
KnownSymbol nm =>
(str -> str)
-> Encoding (Either EncodeEx) nm1 alg1 c str
-> Encoding (Either EncodeEx) nm alg c str
implEncNot' @alg @alg1 str -> str
forall a. a -> a
id