{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}

module Composite.Dhall () where

import Composite.Record
import Control.Applicative
import Data.Functor.Contravariant
import Data.Text (Text)
import Data.Void
import qualified Dhall as D
import Dhall.Core hiding (File, Text)
import Dhall.Map
import Dhall.Src
import GHC.TypeLits

unsafeExpectRecordLit ::
  Text -> Expr Src Void -> Dhall.Map.Map Text (RecordField Src Void)
unsafeExpectRecordLit :: Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecordLit Text
_ (RecordLit Map Text (RecordField Src Void)
kvs) =
  Map Text (RecordField Src Void)
kvs
unsafeExpectRecordLit Text
name Expr Src Void
expression =
  Text -> forall b. b
Dhall.Core.internalError
    (Text
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": Unexpected constructor: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Expr Src Void -> Text
forall a. Pretty a => a -> Text
Dhall.Core.pretty Expr Src Void
expression)

unsafeExpectRecord ::
  Text -> Expr Src Void -> Dhall.Map.Map Text (RecordField Src Void)
unsafeExpectRecord :: Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
_ (Record Map Text (RecordField Src Void)
kts) =
  Map Text (RecordField Src Void)
kts
unsafeExpectRecord Text
name Expr Src Void
expression =
  Text -> forall b. b
Dhall.Core.internalError
    (Text
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": Unexpected constructor: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Expr Src Void -> Text
forall a. Pretty a => a -> Text
Dhall.Core.pretty Expr Src Void
expression)

instance D.ToDhall (Rec f '[]) where
  injectWith :: InputNormalizer -> Encoder (Rec f '[])
injectWith = Encoder (Rec f '[]) -> InputNormalizer -> Encoder (Rec f '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Encoder :: forall a. (a -> Expr Src Void) -> Expr Src Void -> Encoder a
D.Encoder {Expr Src Void
Rec f '[] -> Expr Src Void
forall s a. Expr s a
forall p s a. p -> Expr s a
embed :: Rec f '[] -> Expr Src Void
declared :: Expr Src Void
declared :: forall s a. Expr s a
embed :: forall p s a. p -> Expr s a
..})
    where
      embed :: p -> Expr s a
embed p
_ = Map Text (RecordField s a) -> Expr s a
forall s a. Map Text (RecordField s a) -> Expr s a
RecordLit Map Text (RecordField s a)
forall a. Monoid a => a
mempty
      declared :: Expr s a
declared = Map Text (RecordField s a) -> Expr s a
forall s a. Map Text (RecordField s a) -> Expr s a
Record Map Text (RecordField s a)
forall a. Monoid a => a
mempty

instance (KnownSymbol s, D.ToDhall (Record xs), D.ToDhall x) => D.ToDhall (Record (s :-> x ': xs)) where
  injectWith :: InputNormalizer -> Encoder (Record ((s :-> x) : xs))
injectWith = do
    let f :: s :-> x
        f :: s :-> x
f = s :-> x
forall a. HasCallStack => a
undefined
    let name :: Text
name = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
f
    let D.Encoder x -> Expr Src Void
embedL Expr Src Void
declaredL = Encoder x
forall a. ToDhall a => Encoder a
D.inject
    let D.Encoder Record xs -> Expr Src Void
embedR Expr Src Void
declaredR = Encoder (Record xs)
forall a. ToDhall a => Encoder a
D.inject
    let embed :: Record ((s :-> x) : xs) -> Expr Src Void
embed (x
s :*: Record xs
xs) = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
RecordLit (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
name (Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (x -> Expr Src Void
embedL x
s)) Map Text (RecordField Src Void)
mapR)
          where
            mapR :: Map Text (RecordField Src Void)
mapR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecordLit Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expr Src Void -> Map Text (RecordField Src Void)
forall a b. (a -> b) -> a -> b
$ Record xs -> Expr Src Void
embedR Record xs
xs
    let declared :: Expr Src Void
declared = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
name (Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField Expr Src Void
declaredL) Map Text (RecordField Src Void)
mapR)
          where
            mapR :: Map Text (RecordField Src Void)
mapR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" Expr Src Void
declaredR
    Encoder (Record ((s :-> x) : xs))
-> InputNormalizer -> Encoder (Record ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Encoder (Record ((s :-> x) : xs))
 -> InputNormalizer -> Encoder (Record ((s :-> x) : xs)))
-> Encoder (Record ((s :-> x) : xs))
-> InputNormalizer
-> Encoder (Record ((s :-> x) : xs))
forall a b. (a -> b) -> a -> b
$ Encoder :: forall a. (a -> Expr Src Void) -> Expr Src Void -> Encoder a
D.Encoder {Expr Src Void
Record ((s :-> x) : xs) -> Expr Src Void
declared :: Expr Src Void
embed :: Record ((s :-> x) : xs) -> Expr Src Void
embed :: Record ((s :-> x) : xs) -> Expr Src Void
declared :: Expr Src Void
..}

instance (KnownSymbol s, D.ToDhall (Rec Maybe xs), D.ToDhall x) => D.ToDhall (Rec Maybe (s :-> x ': xs)) where
  injectWith :: InputNormalizer -> Encoder (Rec Maybe ((s :-> x) : xs))
injectWith = do
    let f :: s :-> x
        f :: s :-> x
f = s :-> x
forall a. HasCallStack => a
undefined
    let name :: Text
name = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
f
    let D.Encoder Maybe x -> Expr Src Void
embedL Expr Src Void
declaredL = Encoder (Maybe x)
forall a. ToDhall a => Encoder a
D.inject
    let D.Encoder Rec Maybe xs -> Expr Src Void
embedR Expr Src Void
declaredR = Encoder (Rec Maybe xs)
forall a. ToDhall a => Encoder a
D.inject
    let embed :: Rec Maybe ((s :-> x) : xs) -> Expr Src Void
embed (Maybe x
s :^: Rec Maybe xs
xs) = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
RecordLit (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
name (Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Maybe x -> Expr Src Void
embedL Maybe x
s)) Map Text (RecordField Src Void)
mapR)
          where
            mapR :: Map Text (RecordField Src Void)
mapR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecordLit Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expr Src Void -> Map Text (RecordField Src Void)
forall a b. (a -> b) -> a -> b
$ Rec Maybe xs -> Expr Src Void
embedR Rec Maybe xs
xs
    let declared :: Expr Src Void
declared = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
name (Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField Expr Src Void
declaredL) Map Text (RecordField Src Void)
mapR)
          where
            mapR :: Map Text (RecordField Src Void)
mapR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" Expr Src Void
declaredR
    Encoder (Rec Maybe ((s :-> x) : xs))
-> InputNormalizer -> Encoder (Rec Maybe ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Encoder (Rec Maybe ((s :-> x) : xs))
 -> InputNormalizer -> Encoder (Rec Maybe ((s :-> x) : xs)))
-> Encoder (Rec Maybe ((s :-> x) : xs))
-> InputNormalizer
-> Encoder (Rec Maybe ((s :-> x) : xs))
forall a b. (a -> b) -> a -> b
$ Encoder :: forall a. (a -> Expr Src Void) -> Expr Src Void -> Encoder a
D.Encoder {Expr Src Void
Rec Maybe ((s :-> x) : xs) -> Expr Src Void
declared :: Expr Src Void
embed :: Rec Maybe ((s :-> x) : xs) -> Expr Src Void
embed :: Rec Maybe ((s :-> x) : xs) -> Expr Src Void
declared :: Expr Src Void
..}

instance D.FromDhall (Rec f '[]) where
  autoWith :: InputNormalizer -> Decoder (Rec f '[])
autoWith InputNormalizer
_ = Decoder :: forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder {Expector (Expr Src Void)
Expr Src Void -> Validation (ExtractErrors Src Void) (Rec f '[])
forall s a. Validation ExpectedTypeErrors (Expr s a)
forall (f :: * -> *) p (a :: * -> *).
Applicative f =>
p -> f (Rec a '[])
extract :: Expr Src Void -> Validation (ExtractErrors Src Void) (Rec f '[])
expected :: Expector (Expr Src Void)
expected :: forall s a. Validation ExpectedTypeErrors (Expr s a)
extract :: forall (f :: * -> *) p (a :: * -> *).
Applicative f =>
p -> f (Rec a '[])
..}
    where
      extract :: p -> f (Rec a '[])
extract p
_ = Rec a '[] -> f (Rec a '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure Rec a '[]
forall u (a :: u -> *). Rec a '[]
RNil
      expected :: Validation ExpectedTypeErrors (Expr s a)
expected = Expr s a -> Validation ExpectedTypeErrors (Expr s a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr s a -> Validation ExpectedTypeErrors (Expr s a))
-> Expr s a -> Validation ExpectedTypeErrors (Expr s a)
forall a b. (a -> b) -> a -> b
$ Map Text (RecordField s a) -> Expr s a
forall s a. Map Text (RecordField s a) -> Expr s a
Record ([(Text, RecordField s a)] -> Map Text (RecordField s a)
forall k v. Ord k => [(k, v)] -> Map k v
Dhall.Map.fromList [])

instance (KnownSymbol s, D.FromDhall (Record xs), D.FromDhall x) => D.FromDhall (Record (s :-> x ': xs)) where
  autoWith :: InputNormalizer -> Decoder (Record ((s :-> x) : xs))
autoWith = do
    let nL :: s :-> x
        nL :: s :-> x
nL = s :-> x
forall a. HasCallStack => a
undefined

    let nameL :: Text
nameL = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
nL

    D.Decoder Expr Src Void -> Extractor Src Void x
extractL Expector (Expr Src Void)
expectedL <- FromDhall x => InputNormalizer -> Decoder x
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @x

    D.Decoder Expr Src Void -> Extractor Src Void (Record xs)
extractR Expector (Expr Src Void)
expectedR <- FromDhall (Record xs) => InputNormalizer -> Decoder (Record xs)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Record xs)

    let ktsR :: Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedR

    let expected :: Expector (Expr Src Void)
expected = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Map Text (RecordField Src Void) -> Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
nameL (RecordField Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> (Expr Src Void -> RecordField Src Void)
-> Expr Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Expr Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation
     ExpectedTypeErrors
     (Map Text (RecordField Src Void)
      -> Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedL Validation
  ExpectedTypeErrors
  (Map Text (RecordField Src Void)
   -> Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR)
    let extract :: Expr Src Void
-> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
extract Expr Src Void
expression = do
          let die :: Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
die = Expector (Expr Src Void)
-> Expr Src Void
-> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
forall s a b. Expector (Expr s a) -> Expr s a -> Extractor s a b
D.typeError Expector (Expr Src Void)
expected Expr Src Void
expression

          case Expr Src Void
expression of
            RecordLit Map Text (RecordField Src Void)
kvs ->
              case RecordField Src Void -> Expr Src Void
forall s a. RecordField s a -> Expr s a
Dhall.Core.recordFieldValue (RecordField Src Void -> Expr Src Void)
-> Maybe (RecordField Src Void) -> Maybe (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> Map Text (RecordField Src Void) -> Maybe (RecordField Src Void)
forall k v. Ord k => k -> Map k v -> Maybe v
Dhall.Map.lookup Text
nameL Map Text (RecordField Src Void)
kvs of
                Just Expr Src Void
expressionL ->
                  (x -> Record xs -> Record ((s :-> x) : xs))
-> Extractor Src Void x
-> Extractor Src Void (Record xs)
-> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
                    x -> Record xs -> Record ((s :-> x) : xs)
forall a (rs :: [*]) (s :: Symbol).
a -> Rec Identity rs -> Rec Identity ((s :-> a) : rs)
(:*:)
                    (Expr Src Void -> Extractor Src Void x
extractL Expr Src Void
expressionL)
                    (Expr Src Void -> Extractor Src Void (Record xs)
extractR Expr Src Void
expression)
                Maybe (Expr Src Void)
_ -> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
die
            Expr Src Void
_ -> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
die
    Decoder (Record ((s :-> x) : xs))
-> InputNormalizer -> Decoder (Record ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr Src Void
 -> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs)))
-> Expector (Expr Src Void) -> Decoder (Record ((s :-> x) : xs))
forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder Expr Src Void
-> Validation (ExtractErrors Src Void) (Record ((s :-> x) : xs))
extract Expector (Expr Src Void)
expected)

instance (KnownSymbol s, D.FromDhall (Rec Maybe xs), D.FromDhall x) => D.FromDhall (Rec Maybe (s :-> x ': xs)) where
  autoWith :: InputNormalizer -> Decoder (Rec Maybe ((s :-> x) : xs))
autoWith = do
    let nL :: s :-> x
        nL :: s :-> x
nL = s :-> x
forall a. HasCallStack => a
undefined

    let nameL :: Text
nameL = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
nL

    D.Decoder Expr Src Void -> Extractor Src Void (Maybe x)
extractL Expector (Expr Src Void)
expectedL <- FromDhall (Maybe x) => InputNormalizer -> Decoder (Maybe x)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Maybe x)

    D.Decoder Expr Src Void -> Extractor Src Void (Rec Maybe xs)
extractR Expector (Expr Src Void)
expectedR <- FromDhall (Rec Maybe xs) =>
InputNormalizer -> Decoder (Rec Maybe xs)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Rec Maybe xs)

    let ktsR :: Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedR

    let expected :: Expector (Expr Src Void)
expected = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Map Text (RecordField Src Void) -> Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
nameL (RecordField Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> (Expr Src Void -> RecordField Src Void)
-> Expr Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Expr Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation
     ExpectedTypeErrors
     (Map Text (RecordField Src Void)
      -> Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedL Validation
  ExpectedTypeErrors
  (Map Text (RecordField Src Void)
   -> Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR)
    let extract :: Expr Src Void
-> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
extract Expr Src Void
expression = do
          let die :: Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
die = Expector (Expr Src Void)
-> Expr Src Void
-> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
forall s a b. Expector (Expr s a) -> Expr s a -> Extractor s a b
D.typeError Expector (Expr Src Void)
expected Expr Src Void
expression

          case Expr Src Void
expression of
            RecordLit Map Text (RecordField Src Void)
kvs ->
              case RecordField Src Void -> Expr Src Void
forall s a. RecordField s a -> Expr s a
Dhall.Core.recordFieldValue (RecordField Src Void -> Expr Src Void)
-> Maybe (RecordField Src Void) -> Maybe (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> Map Text (RecordField Src Void) -> Maybe (RecordField Src Void)
forall k v. Ord k => k -> Map k v -> Maybe v
Dhall.Map.lookup Text
nameL Map Text (RecordField Src Void)
kvs of
                Just Expr Src Void
expressionL ->
                  (Maybe x -> Rec Maybe xs -> Rec Maybe ((s :-> x) : xs))
-> Extractor Src Void (Maybe x)
-> Extractor Src Void (Rec Maybe xs)
-> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
                    Maybe x -> Rec Maybe xs -> Rec Maybe ((s :-> x) : xs)
forall (f :: * -> *) a (rs :: [*]) (s :: Symbol).
Functor f =>
f a -> Rec f rs -> Rec f ((s :-> a) : rs)
(:^:)
                    (Expr Src Void -> Extractor Src Void (Maybe x)
extractL Expr Src Void
expressionL)
                    (Expr Src Void -> Extractor Src Void (Rec Maybe xs)
extractR Expr Src Void
expression)
                Maybe (Expr Src Void)
_ -> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
die
            Expr Src Void
_ -> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
die
    Decoder (Rec Maybe ((s :-> x) : xs))
-> InputNormalizer -> Decoder (Rec Maybe ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr Src Void
 -> Validation
      (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs)))
-> Expector (Expr Src Void) -> Decoder (Rec Maybe ((s :-> x) : xs))
forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder Expr Src Void
-> Validation (ExtractErrors Src Void) (Rec Maybe ((s :-> x) : xs))
extract Expector (Expr Src Void)
expected)

deriving newtype instance (D.FromDhall b, D.ToDhall x) => D.FromDhall (Op b x)

deriving newtype instance (D.ToDhall x) => D.FromDhall (Predicate x)

deriving newtype instance (D.ToDhall x) => D.FromDhall (Equivalence x)

instance (KnownSymbol s, D.FromDhall (Rec (Op b) xs), D.FromDhall b, D.ToDhall x) => D.FromDhall (Rec (Op b) (s :-> x ': xs)) where
  autoWith :: InputNormalizer -> Decoder (Rec (Op b) ((s :-> x) : xs))
autoWith = do
    let nL :: s :-> x
        nL :: s :-> x
nL = s :-> x
forall a. HasCallStack => a
undefined

    let nameL :: Text
nameL = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
nL

    D.Decoder Expr Src Void -> Extractor Src Void (Op b x)
extractL Expector (Expr Src Void)
expectedL <- FromDhall (Op b x) => InputNormalizer -> Decoder (Op b x)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Op b x)

    D.Decoder Expr Src Void -> Extractor Src Void (Rec (Op b) xs)
extractR Expector (Expr Src Void)
expectedR <- FromDhall (Rec (Op b) xs) =>
InputNormalizer -> Decoder (Rec (Op b) xs)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Rec (Op b) xs)

    let ktsR :: Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedR

    let expected :: Expector (Expr Src Void)
expected = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Map Text (RecordField Src Void) -> Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
nameL (RecordField Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> (Expr Src Void -> RecordField Src Void)
-> Expr Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Expr Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation
     ExpectedTypeErrors
     (Map Text (RecordField Src Void)
      -> Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedL Validation
  ExpectedTypeErrors
  (Map Text (RecordField Src Void)
   -> Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR)
    let extract :: Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
extract Expr Src Void
expression = do
          let die :: Validation (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
die = Expector (Expr Src Void)
-> Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
forall s a b. Expector (Expr s a) -> Expr s a -> Extractor s a b
D.typeError Expector (Expr Src Void)
expected Expr Src Void
expression

          case Expr Src Void
expression of
            RecordLit Map Text (RecordField Src Void)
kvs ->
              case RecordField Src Void -> Expr Src Void
forall s a. RecordField s a -> Expr s a
Dhall.Core.recordFieldValue (RecordField Src Void -> Expr Src Void)
-> Maybe (RecordField Src Void) -> Maybe (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> Map Text (RecordField Src Void) -> Maybe (RecordField Src Void)
forall k v. Ord k => k -> Map k v -> Maybe v
Dhall.Map.lookup Text
nameL Map Text (RecordField Src Void)
kvs of
                Just Expr Src Void
expressionL ->
                  (Op b (s :-> x) -> Rec (Op b) xs -> Rec (Op b) ((s :-> x) : xs))
-> Validation (ExtractErrors Src Void) (Op b (s :-> x))
-> Extractor Src Void (Rec (Op b) xs)
-> Validation
     (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
                    Op b (s :-> x) -> Rec (Op b) xs -> Rec (Op b) ((s :-> x) : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
(:&)
                    (((s :-> x) -> x) -> Op b x -> Op b (s :-> x)
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap (s :-> x) -> x
forall (s :: Symbol) a. (s :-> a) -> a
getVal (Op b x -> Op b (s :-> x))
-> Extractor Src Void (Op b x)
-> Validation (ExtractErrors Src Void) (Op b (s :-> x))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr Src Void -> Extractor Src Void (Op b x)
extractL Expr Src Void
expressionL)
                    (Expr Src Void -> Extractor Src Void (Rec (Op b) xs)
extractR Expr Src Void
expression)
                Maybe (Expr Src Void)
_ -> Validation (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
die
            Expr Src Void
_ -> Validation (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
die
    Decoder (Rec (Op b) ((s :-> x) : xs))
-> InputNormalizer -> Decoder (Rec (Op b) ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr Src Void
 -> Validation
      (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs)))
-> Expector (Expr Src Void)
-> Decoder (Rec (Op b) ((s :-> x) : xs))
forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec (Op b) ((s :-> x) : xs))
extract Expector (Expr Src Void)
expected)

instance (KnownSymbol s, D.FromDhall (Rec Predicate xs), D.ToDhall x) => D.FromDhall (Rec Predicate (s :-> x ': xs)) where
  autoWith :: InputNormalizer -> Decoder (Rec Predicate ((s :-> x) : xs))
autoWith = do
    let nL :: s :-> x
        nL :: s :-> x
nL = s :-> x
forall a. HasCallStack => a
undefined

    let nameL :: Text
nameL = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
nL

    D.Decoder Expr Src Void -> Extractor Src Void (Predicate x)
extractL Expector (Expr Src Void)
expectedL <- FromDhall (Predicate x) => InputNormalizer -> Decoder (Predicate x)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Predicate x)

    D.Decoder Expr Src Void -> Extractor Src Void (Rec Predicate xs)
extractR Expector (Expr Src Void)
expectedR <- FromDhall (Rec Predicate xs) =>
InputNormalizer -> Decoder (Rec Predicate xs)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Rec Predicate xs)

    let ktsR :: Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedR

    let expected :: Expector (Expr Src Void)
expected = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Map Text (RecordField Src Void) -> Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
nameL (RecordField Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> (Expr Src Void -> RecordField Src Void)
-> Expr Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Expr Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation
     ExpectedTypeErrors
     (Map Text (RecordField Src Void)
      -> Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedL Validation
  ExpectedTypeErrors
  (Map Text (RecordField Src Void)
   -> Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR)
    let extract :: Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
extract Expr Src Void
expression = do
          let die :: Validation
  (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
die = Expector (Expr Src Void)
-> Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
forall s a b. Expector (Expr s a) -> Expr s a -> Extractor s a b
D.typeError Expector (Expr Src Void)
expected Expr Src Void
expression

          case Expr Src Void
expression of
            RecordLit Map Text (RecordField Src Void)
kvs ->
              case RecordField Src Void -> Expr Src Void
forall s a. RecordField s a -> Expr s a
Dhall.Core.recordFieldValue (RecordField Src Void -> Expr Src Void)
-> Maybe (RecordField Src Void) -> Maybe (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> Map Text (RecordField Src Void) -> Maybe (RecordField Src Void)
forall k v. Ord k => k -> Map k v -> Maybe v
Dhall.Map.lookup Text
nameL Map Text (RecordField Src Void)
kvs of
                Just Expr Src Void
expressionL ->
                  (Predicate (s :-> x)
 -> Rec Predicate xs -> Rec Predicate ((s :-> x) : xs))
-> Validation (ExtractErrors Src Void) (Predicate (s :-> x))
-> Extractor Src Void (Rec Predicate xs)
-> Validation
     (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
                    Predicate (s :-> x)
-> Rec Predicate xs -> Rec Predicate ((s :-> x) : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
(:&)
                    (((s :-> x) -> x) -> Predicate x -> Predicate (s :-> x)
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap (s :-> x) -> x
forall (s :: Symbol) a. (s :-> a) -> a
getVal (Predicate x -> Predicate (s :-> x))
-> Extractor Src Void (Predicate x)
-> Validation (ExtractErrors Src Void) (Predicate (s :-> x))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr Src Void -> Extractor Src Void (Predicate x)
extractL Expr Src Void
expressionL)
                    (Expr Src Void -> Extractor Src Void (Rec Predicate xs)
extractR Expr Src Void
expression)
                Maybe (Expr Src Void)
_ -> Validation
  (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
die
            Expr Src Void
_ -> Validation
  (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
die
    Decoder (Rec Predicate ((s :-> x) : xs))
-> InputNormalizer -> Decoder (Rec Predicate ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr Src Void
 -> Validation
      (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs)))
-> Expector (Expr Src Void)
-> Decoder (Rec Predicate ((s :-> x) : xs))
forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Predicate ((s :-> x) : xs))
extract Expector (Expr Src Void)
expected)

instance (KnownSymbol s, D.FromDhall (Rec Equivalence xs), D.ToDhall x) => D.FromDhall (Rec Equivalence (s :-> x ': xs)) where
  autoWith :: InputNormalizer -> Decoder (Rec Equivalence ((s :-> x) : xs))
autoWith = do
    let nL :: s :-> x
        nL :: s :-> x
nL = s :-> x
forall a. HasCallStack => a
undefined

    let nameL :: Text
nameL = (s :-> x) -> Text
forall (s :: Symbol) a. KnownSymbol s => (s :-> a) -> Text
valName s :-> x
nL

    D.Decoder Expr Src Void -> Extractor Src Void (Equivalence x)
extractL Expector (Expr Src Void)
expectedL <- FromDhall (Equivalence x) =>
InputNormalizer -> Decoder (Equivalence x)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Equivalence x)

    D.Decoder Expr Src Void -> Extractor Src Void (Rec Equivalence xs)
extractR Expector (Expr Src Void)
expectedR <- FromDhall (Rec Equivalence xs) =>
InputNormalizer -> Decoder (Rec Equivalence xs)
forall a. FromDhall a => InputNormalizer -> Decoder a
D.autoWith @(Rec Equivalence xs)

    let ktsR :: Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR = Text -> Expr Src Void -> Map Text (RecordField Src Void)
unsafeExpectRecord Text
"Composite Record" (Expr Src Void -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedR

    let expected :: Expector (Expr Src Void)
expected = Map Text (RecordField Src Void) -> Expr Src Void
forall s a. Map Text (RecordField s a) -> Expr s a
Record (Map Text (RecordField Src Void) -> Expr Src Void)
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text
-> RecordField Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall k v. Ord k => k -> v -> Map k v -> Map k v
Dhall.Map.insert Text
nameL (RecordField Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> (Expr Src Void -> RecordField Src Void)
-> Expr Src Void
-> Map Text (RecordField Src Void)
-> Map Text (RecordField Src Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr Src Void -> RecordField Src Void
forall s a. Expr s a -> RecordField s a
Dhall.Core.makeRecordField (Expr Src Void
 -> Map Text (RecordField Src Void)
 -> Map Text (RecordField Src Void))
-> Expector (Expr Src Void)
-> Validation
     ExpectedTypeErrors
     (Map Text (RecordField Src Void)
      -> Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expector (Expr Src Void)
expectedL Validation
  ExpectedTypeErrors
  (Map Text (RecordField Src Void)
   -> Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
-> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Validation ExpectedTypeErrors (Map Text (RecordField Src Void))
ktsR)
    let extract :: Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
extract Expr Src Void
expression = do
          let die :: Validation
  (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
die = Expector (Expr Src Void)
-> Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
forall s a b. Expector (Expr s a) -> Expr s a -> Extractor s a b
D.typeError Expector (Expr Src Void)
expected Expr Src Void
expression

          case Expr Src Void
expression of
            RecordLit Map Text (RecordField Src Void)
kvs ->
              case RecordField Src Void -> Expr Src Void
forall s a. RecordField s a -> Expr s a
Dhall.Core.recordFieldValue (RecordField Src Void -> Expr Src Void)
-> Maybe (RecordField Src Void) -> Maybe (Expr Src Void)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> Map Text (RecordField Src Void) -> Maybe (RecordField Src Void)
forall k v. Ord k => k -> Map k v -> Maybe v
Dhall.Map.lookup Text
nameL Map Text (RecordField Src Void)
kvs of
                Just Expr Src Void
expressionL ->
                  (Equivalence (s :-> x)
 -> Rec Equivalence xs -> Rec Equivalence ((s :-> x) : xs))
-> Validation (ExtractErrors Src Void) (Equivalence (s :-> x))
-> Extractor Src Void (Rec Equivalence xs)
-> Validation
     (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
                    Equivalence (s :-> x)
-> Rec Equivalence xs -> Rec Equivalence ((s :-> x) : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
(:&)
                    (((s :-> x) -> x) -> Equivalence x -> Equivalence (s :-> x)
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap (s :-> x) -> x
forall (s :: Symbol) a. (s :-> a) -> a
getVal (Equivalence x -> Equivalence (s :-> x))
-> Extractor Src Void (Equivalence x)
-> Validation (ExtractErrors Src Void) (Equivalence (s :-> x))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr Src Void -> Extractor Src Void (Equivalence x)
extractL Expr Src Void
expressionL)
                    (Expr Src Void -> Extractor Src Void (Rec Equivalence xs)
extractR Expr Src Void
expression)
                Maybe (Expr Src Void)
_ -> Validation
  (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
die
            Expr Src Void
_ -> Validation
  (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
die
    Decoder (Rec Equivalence ((s :-> x) : xs))
-> InputNormalizer -> Decoder (Rec Equivalence ((s :-> x) : xs))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Expr Src Void
 -> Validation
      (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs)))
-> Expector (Expr Src Void)
-> Decoder (Rec Equivalence ((s :-> x) : xs))
forall a.
(Expr Src Void -> Extractor Src Void a)
-> Expector (Expr Src Void) -> Decoder a
D.Decoder Expr Src Void
-> Validation
     (ExtractErrors Src Void) (Rec Equivalence ((s :-> x) : xs))
extract Expector (Expr Src Void)
expected)