{-# OPTIONS_GHC -Wno-orphans #-}

module Data.OpenApi.Compare.Validate.Schema.Traced
  ( Step (..),
    tracedAllOf,
    tracedAnyOf,
    tracedOneOf,
    tracedItems,
    tracedAdditionalProperties,
    tracedDiscriminator,
    tracedProperties,
    tracedConjunct,
    PartitionLocation (..),
    PartitionChoice (..),
    Partition,
  )
where

import qualified Data.Aeson as A
import Data.Functor
import qualified Data.HashMap.Strict.InsOrd as IOHM
import qualified Data.List.NonEmpty as NE
import Data.OpenApi
import Data.OpenApi.Compare.Subtree
import qualified Data.Set as S
import Data.Text (Text)

data PartitionChoice
  = CByEnumValue (S.Set A.Value)
  | CByProperties (S.Set Text) (S.Set Text) -- included, excluded
  deriving stock (PartitionChoice -> PartitionChoice -> Bool
(PartitionChoice -> PartitionChoice -> Bool)
-> (PartitionChoice -> PartitionChoice -> Bool)
-> Eq PartitionChoice
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PartitionChoice -> PartitionChoice -> Bool
$c/= :: PartitionChoice -> PartitionChoice -> Bool
== :: PartitionChoice -> PartitionChoice -> Bool
$c== :: PartitionChoice -> PartitionChoice -> Bool
Eq, Eq PartitionChoice
Eq PartitionChoice
-> (PartitionChoice -> PartitionChoice -> Ordering)
-> (PartitionChoice -> PartitionChoice -> Bool)
-> (PartitionChoice -> PartitionChoice -> Bool)
-> (PartitionChoice -> PartitionChoice -> Bool)
-> (PartitionChoice -> PartitionChoice -> Bool)
-> (PartitionChoice -> PartitionChoice -> PartitionChoice)
-> (PartitionChoice -> PartitionChoice -> PartitionChoice)
-> Ord PartitionChoice
PartitionChoice -> PartitionChoice -> Bool
PartitionChoice -> PartitionChoice -> Ordering
PartitionChoice -> PartitionChoice -> PartitionChoice
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PartitionChoice -> PartitionChoice -> PartitionChoice
$cmin :: PartitionChoice -> PartitionChoice -> PartitionChoice
max :: PartitionChoice -> PartitionChoice -> PartitionChoice
$cmax :: PartitionChoice -> PartitionChoice -> PartitionChoice
>= :: PartitionChoice -> PartitionChoice -> Bool
$c>= :: PartitionChoice -> PartitionChoice -> Bool
> :: PartitionChoice -> PartitionChoice -> Bool
$c> :: PartitionChoice -> PartitionChoice -> Bool
<= :: PartitionChoice -> PartitionChoice -> Bool
$c<= :: PartitionChoice -> PartitionChoice -> Bool
< :: PartitionChoice -> PartitionChoice -> Bool
$c< :: PartitionChoice -> PartitionChoice -> Bool
compare :: PartitionChoice -> PartitionChoice -> Ordering
$ccompare :: PartitionChoice -> PartitionChoice -> Ordering
$cp1Ord :: Eq PartitionChoice
Ord, Int -> PartitionChoice -> ShowS
[PartitionChoice] -> ShowS
PartitionChoice -> String
(Int -> PartitionChoice -> ShowS)
-> (PartitionChoice -> String)
-> ([PartitionChoice] -> ShowS)
-> Show PartitionChoice
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PartitionChoice] -> ShowS
$cshowList :: [PartitionChoice] -> ShowS
show :: PartitionChoice -> String
$cshow :: PartitionChoice -> String
showsPrec :: Int -> PartitionChoice -> ShowS
$cshowsPrec :: Int -> PartitionChoice -> ShowS
Show)

data PartitionLocation
  = PHere
  | PInProperty Text PartitionLocation
  deriving stock (PartitionLocation -> PartitionLocation -> Bool
(PartitionLocation -> PartitionLocation -> Bool)
-> (PartitionLocation -> PartitionLocation -> Bool)
-> Eq PartitionLocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PartitionLocation -> PartitionLocation -> Bool
$c/= :: PartitionLocation -> PartitionLocation -> Bool
== :: PartitionLocation -> PartitionLocation -> Bool
$c== :: PartitionLocation -> PartitionLocation -> Bool
Eq, Eq PartitionLocation
Eq PartitionLocation
-> (PartitionLocation -> PartitionLocation -> Ordering)
-> (PartitionLocation -> PartitionLocation -> Bool)
-> (PartitionLocation -> PartitionLocation -> Bool)
-> (PartitionLocation -> PartitionLocation -> Bool)
-> (PartitionLocation -> PartitionLocation -> Bool)
-> (PartitionLocation -> PartitionLocation -> PartitionLocation)
-> (PartitionLocation -> PartitionLocation -> PartitionLocation)
-> Ord PartitionLocation
PartitionLocation -> PartitionLocation -> Bool
PartitionLocation -> PartitionLocation -> Ordering
PartitionLocation -> PartitionLocation -> PartitionLocation
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PartitionLocation -> PartitionLocation -> PartitionLocation
$cmin :: PartitionLocation -> PartitionLocation -> PartitionLocation
max :: PartitionLocation -> PartitionLocation -> PartitionLocation
$cmax :: PartitionLocation -> PartitionLocation -> PartitionLocation
>= :: PartitionLocation -> PartitionLocation -> Bool
$c>= :: PartitionLocation -> PartitionLocation -> Bool
> :: PartitionLocation -> PartitionLocation -> Bool
$c> :: PartitionLocation -> PartitionLocation -> Bool
<= :: PartitionLocation -> PartitionLocation -> Bool
$c<= :: PartitionLocation -> PartitionLocation -> Bool
< :: PartitionLocation -> PartitionLocation -> Bool
$c< :: PartitionLocation -> PartitionLocation -> Bool
compare :: PartitionLocation -> PartitionLocation -> Ordering
$ccompare :: PartitionLocation -> PartitionLocation -> Ordering
$cp1Ord :: Eq PartitionLocation
Ord, Int -> PartitionLocation -> ShowS
[PartitionLocation] -> ShowS
PartitionLocation -> String
(Int -> PartitionLocation -> ShowS)
-> (PartitionLocation -> String)
-> ([PartitionLocation] -> ShowS)
-> Show PartitionLocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PartitionLocation] -> ShowS
$cshowList :: [PartitionLocation] -> ShowS
show :: PartitionLocation -> String
$cshow :: PartitionLocation -> String
showsPrec :: Int -> PartitionLocation -> ShowS
$cshowsPrec :: Int -> PartitionLocation -> ShowS
Show)

type Partition = (PartitionLocation, PartitionChoice)

instance Steppable Schema (Referenced Schema) where
  data Step Schema (Referenced Schema)
    = AllOfStep Int
    | OneOfStep Int
    | AnyOfStep Int
    | ItemsObjectStep
    | ItemsArrayStep Int
    | AdditionalPropertiesStep
    | NotStep
    | ImplicitTopSchema
    deriving stock (Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
(Step Schema (Referenced Schema)
 -> Step Schema (Referenced Schema) -> Bool)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Bool)
-> Eq (Step Schema (Referenced Schema))
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c/= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
== :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c== :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
Eq, Eq (Step Schema (Referenced Schema))
Eq (Step Schema (Referenced Schema))
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Ordering)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Bool)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Bool)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Bool)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema) -> Bool)
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema))
-> (Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema)
    -> Step Schema (Referenced Schema))
-> Ord (Step Schema (Referenced Schema))
Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Ordering
Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
$cmin :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
max :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
$cmax :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema)
>= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c>= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
> :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c> :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
<= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c<= :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
< :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
$c< :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Bool
compare :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Ordering
$ccompare :: Step Schema (Referenced Schema)
-> Step Schema (Referenced Schema) -> Ordering
$cp1Ord :: Eq (Step Schema (Referenced Schema))
Ord, Int -> Step Schema (Referenced Schema) -> ShowS
[Step Schema (Referenced Schema)] -> ShowS
Step Schema (Referenced Schema) -> String
(Int -> Step Schema (Referenced Schema) -> ShowS)
-> (Step Schema (Referenced Schema) -> String)
-> ([Step Schema (Referenced Schema)] -> ShowS)
-> Show (Step Schema (Referenced Schema))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Step Schema (Referenced Schema)] -> ShowS
$cshowList :: [Step Schema (Referenced Schema)] -> ShowS
show :: Step Schema (Referenced Schema) -> String
$cshow :: Step Schema (Referenced Schema) -> String
showsPrec :: Int -> Step Schema (Referenced Schema) -> ShowS
$cshowsPrec :: Int -> Step Schema (Referenced Schema) -> ShowS
Show)

instance Steppable (Referenced Schema) (Referenced Schema) where
  data Step (Referenced Schema) (Referenced Schema)
    = -- | Invariant (for better memoization only): the "tail" of the trace is
      -- the "least" of the traces of the conjuncted schemata
      ConjunctedWith (NE.NonEmpty (Trace (Referenced Schema)))
    | Partitioned Partition
    deriving stock (Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
(Step (Referenced Schema) (Referenced Schema)
 -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> Eq (Step (Referenced Schema) (Referenced Schema))
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c/= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
== :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c== :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
Eq, Eq (Step (Referenced Schema) (Referenced Schema))
Eq (Step (Referenced Schema) (Referenced Schema))
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Ordering)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema) -> Bool)
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema))
-> (Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema)
    -> Step (Referenced Schema) (Referenced Schema))
-> Ord (Step (Referenced Schema) (Referenced Schema))
Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Ordering
Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
$cmin :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
max :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
$cmax :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema)
>= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c>= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
> :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c> :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
<= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c<= :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
< :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
$c< :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Bool
compare :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Ordering
$ccompare :: Step (Referenced Schema) (Referenced Schema)
-> Step (Referenced Schema) (Referenced Schema) -> Ordering
$cp1Ord :: Eq (Step (Referenced Schema) (Referenced Schema))
Ord, Int -> Step (Referenced Schema) (Referenced Schema) -> ShowS
[Step (Referenced Schema) (Referenced Schema)] -> ShowS
Step (Referenced Schema) (Referenced Schema) -> String
(Int -> Step (Referenced Schema) (Referenced Schema) -> ShowS)
-> (Step (Referenced Schema) (Referenced Schema) -> String)
-> ([Step (Referenced Schema) (Referenced Schema)] -> ShowS)
-> Show (Step (Referenced Schema) (Referenced Schema))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Step (Referenced Schema) (Referenced Schema)] -> ShowS
$cshowList :: [Step (Referenced Schema) (Referenced Schema)] -> ShowS
show :: Step (Referenced Schema) (Referenced Schema) -> String
$cshow :: Step (Referenced Schema) (Referenced Schema) -> String
showsPrec :: Int -> Step (Referenced Schema) (Referenced Schema) -> ShowS
$cshowsPrec :: Int -> Step (Referenced Schema) (Referenced Schema) -> ShowS
Show)

instance Steppable Schema (Definitions (Referenced Schema)) where
  data Step Schema (Definitions (Referenced Schema)) = PropertiesStep
    deriving stock (Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
(Step Schema (Definitions (Referenced Schema))
 -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> Eq (Step Schema (Definitions (Referenced Schema)))
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c/= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
== :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c== :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
Eq, Eq (Step Schema (Definitions (Referenced Schema)))
Eq (Step Schema (Definitions (Referenced Schema)))
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Ordering)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)) -> Bool)
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)))
-> (Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema))
    -> Step Schema (Definitions (Referenced Schema)))
-> Ord (Step Schema (Definitions (Referenced Schema)))
Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Ordering
Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
$cmin :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
max :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
$cmax :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema))
>= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c>= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
> :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c> :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
<= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c<= :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
< :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
$c< :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Bool
compare :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Ordering
$ccompare :: Step Schema (Definitions (Referenced Schema))
-> Step Schema (Definitions (Referenced Schema)) -> Ordering
$cp1Ord :: Eq (Step Schema (Definitions (Referenced Schema)))
Ord, Int -> Step Schema (Definitions (Referenced Schema)) -> ShowS
[Step Schema (Definitions (Referenced Schema))] -> ShowS
Step Schema (Definitions (Referenced Schema)) -> String
(Int -> Step Schema (Definitions (Referenced Schema)) -> ShowS)
-> (Step Schema (Definitions (Referenced Schema)) -> String)
-> ([Step Schema (Definitions (Referenced Schema))] -> ShowS)
-> Show (Step Schema (Definitions (Referenced Schema)))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Step Schema (Definitions (Referenced Schema))] -> ShowS
$cshowList :: [Step Schema (Definitions (Referenced Schema))] -> ShowS
show :: Step Schema (Definitions (Referenced Schema)) -> String
$cshow :: Step Schema (Definitions (Referenced Schema)) -> String
showsPrec :: Int -> Step Schema (Definitions (Referenced Schema)) -> ShowS
$cshowsPrec :: Int -> Step Schema (Definitions (Referenced Schema)) -> ShowS
Show)

instance Steppable Schema Discriminator where
  data Step Schema Discriminator = DiscriminatorStep
    deriving stock (Step Schema Discriminator -> Step Schema Discriminator -> Bool
(Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> (Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> Eq (Step Schema Discriminator)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c/= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
== :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c== :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
Eq, Eq (Step Schema Discriminator)
Eq (Step Schema Discriminator)
-> (Step Schema Discriminator
    -> Step Schema Discriminator -> Ordering)
-> (Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> (Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> (Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> (Step Schema Discriminator -> Step Schema Discriminator -> Bool)
-> (Step Schema Discriminator
    -> Step Schema Discriminator -> Step Schema Discriminator)
-> (Step Schema Discriminator
    -> Step Schema Discriminator -> Step Schema Discriminator)
-> Ord (Step Schema Discriminator)
Step Schema Discriminator -> Step Schema Discriminator -> Bool
Step Schema Discriminator -> Step Schema Discriminator -> Ordering
Step Schema Discriminator
-> Step Schema Discriminator -> Step Schema Discriminator
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Step Schema Discriminator
-> Step Schema Discriminator -> Step Schema Discriminator
$cmin :: Step Schema Discriminator
-> Step Schema Discriminator -> Step Schema Discriminator
max :: Step Schema Discriminator
-> Step Schema Discriminator -> Step Schema Discriminator
$cmax :: Step Schema Discriminator
-> Step Schema Discriminator -> Step Schema Discriminator
>= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c>= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
> :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c> :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
<= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c<= :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
< :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
$c< :: Step Schema Discriminator -> Step Schema Discriminator -> Bool
compare :: Step Schema Discriminator -> Step Schema Discriminator -> Ordering
$ccompare :: Step Schema Discriminator -> Step Schema Discriminator -> Ordering
$cp1Ord :: Eq (Step Schema Discriminator)
Ord, Int -> Step Schema Discriminator -> ShowS
[Step Schema Discriminator] -> ShowS
Step Schema Discriminator -> String
(Int -> Step Schema Discriminator -> ShowS)
-> (Step Schema Discriminator -> String)
-> ([Step Schema Discriminator] -> ShowS)
-> Show (Step Schema Discriminator)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Step Schema Discriminator] -> ShowS
$cshowList :: [Step Schema Discriminator] -> ShowS
show :: Step Schema Discriminator -> String
$cshow :: Step Schema Discriminator -> String
showsPrec :: Int -> Step Schema Discriminator -> ShowS
$cshowsPrec :: Int -> Step Schema Discriminator -> ShowS
Show)

instance Steppable Discriminator (Definitions (Referenced Schema)) where
  data Step Discriminator (Definitions (Referenced Schema)) = DiscriminatorMapping
    deriving stock (Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
(Step Discriminator (Definitions (Referenced Schema))
 -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> Eq (Step Discriminator (Definitions (Referenced Schema)))
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c/= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
== :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c== :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
Eq, Eq (Step Discriminator (Definitions (Referenced Schema)))
Eq (Step Discriminator (Definitions (Referenced Schema)))
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema))
    -> Ordering)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)) -> Bool)
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)))
-> (Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema))
    -> Step Discriminator (Definitions (Referenced Schema)))
-> Ord (Step Discriminator (Definitions (Referenced Schema)))
Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Ordering
Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
$cmin :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
max :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
$cmax :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema))
>= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c>= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
> :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c> :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
<= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c<= :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
< :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
$c< :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Bool
compare :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Ordering
$ccompare :: Step Discriminator (Definitions (Referenced Schema))
-> Step Discriminator (Definitions (Referenced Schema)) -> Ordering
$cp1Ord :: Eq (Step Discriminator (Definitions (Referenced Schema)))
Ord, Int
-> Step Discriminator (Definitions (Referenced Schema)) -> ShowS
[Step Discriminator (Definitions (Referenced Schema))] -> ShowS
Step Discriminator (Definitions (Referenced Schema)) -> String
(Int
 -> Step Discriminator (Definitions (Referenced Schema)) -> ShowS)
-> (Step Discriminator (Definitions (Referenced Schema)) -> String)
-> ([Step Discriminator (Definitions (Referenced Schema))]
    -> ShowS)
-> Show (Step Discriminator (Definitions (Referenced Schema)))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Step Discriminator (Definitions (Referenced Schema))] -> ShowS
$cshowList :: [Step Discriminator (Definitions (Referenced Schema))] -> ShowS
show :: Step Discriminator (Definitions (Referenced Schema)) -> String
$cshow :: Step Discriminator (Definitions (Referenced Schema)) -> String
showsPrec :: Int
-> Step Discriminator (Definitions (Referenced Schema)) -> ShowS
$cshowsPrec :: Int
-> Step Discriminator (Definitions (Referenced Schema)) -> ShowS
Show)

tracedAllOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedAllOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedAllOf Traced Schema
sch =
  Schema -> Maybe [Referenced Schema]
_schemaAllOf (Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch) Maybe [Referenced Schema]
-> ([Referenced Schema] -> [Traced (Referenced Schema)])
-> Maybe [Traced (Referenced Schema)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \[Referenced Schema]
xs ->
    [Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (Int -> Step Schema (Referenced Schema)
AllOfStep Int
i)) Referenced Schema
x | (Int
i, Referenced Schema
x) <- [Int] -> [Referenced Schema] -> [(Int, Referenced Schema)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] [Referenced Schema]
xs]

tracedAnyOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedAnyOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedAnyOf Traced Schema
sch =
  Schema -> Maybe [Referenced Schema]
_schemaAnyOf (Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch) Maybe [Referenced Schema]
-> ([Referenced Schema] -> [Traced (Referenced Schema)])
-> Maybe [Traced (Referenced Schema)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \[Referenced Schema]
xs ->
    [Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (Int -> Step Schema (Referenced Schema)
AnyOfStep Int
i)) Referenced Schema
x | (Int
i, Referenced Schema
x) <- [Int] -> [Referenced Schema] -> [(Int, Referenced Schema)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] [Referenced Schema]
xs]

tracedOneOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedOneOf :: Traced Schema -> Maybe [Traced (Referenced Schema)]
tracedOneOf Traced Schema
sch =
  Schema -> Maybe [Referenced Schema]
_schemaOneOf (Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch) Maybe [Referenced Schema]
-> ([Referenced Schema] -> [Traced (Referenced Schema)])
-> Maybe [Traced (Referenced Schema)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \[Referenced Schema]
xs ->
    [Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (Int -> Step Schema (Referenced Schema)
OneOfStep Int
i)) Referenced Schema
x | (Int
i, Referenced Schema
x) <- [Int] -> [Referenced Schema] -> [(Int, Referenced Schema)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] [Referenced Schema]
xs]

tracedItems :: Traced Schema -> Maybe (Either (Traced (Referenced Schema)) [Traced (Referenced Schema)])
tracedItems :: Traced Schema
-> Maybe
     (Either (Traced (Referenced Schema)) [Traced (Referenced Schema)])
tracedItems Traced Schema
sch =
  Schema -> Maybe OpenApiItems
_schemaItems (Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch) Maybe OpenApiItems
-> (OpenApiItems
    -> Either
         (Traced (Referenced Schema)) [Traced (Referenced Schema)])
-> Maybe
     (Either (Traced (Referenced Schema)) [Traced (Referenced Schema)])
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
    OpenApiItemsObject Referenced Schema
x -> Traced (Referenced Schema)
-> Either (Traced (Referenced Schema)) [Traced (Referenced Schema)]
forall a b. a -> Either a b
Left (Traced (Referenced Schema)
 -> Either
      (Traced (Referenced Schema)) [Traced (Referenced Schema)])
-> Traced (Referenced Schema)
-> Either (Traced (Referenced Schema)) [Traced (Referenced Schema)]
forall a b. (a -> b) -> a -> b
$ Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step Step Schema (Referenced Schema)
ItemsObjectStep) Referenced Schema
x
    OpenApiItemsArray [Referenced Schema]
xs ->
      [Traced (Referenced Schema)]
-> Either (Traced (Referenced Schema)) [Traced (Referenced Schema)]
forall a b. b -> Either a b
Right
        [Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (Int -> Step Schema (Referenced Schema)
ItemsArrayStep Int
i)) Referenced Schema
x | (Int
i, Referenced Schema
x) <- [Int] -> [Referenced Schema] -> [(Int, Referenced Schema)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] [Referenced Schema]
xs]

tracedAdditionalProperties :: Traced Schema -> Maybe (Either Bool (Traced (Referenced Schema)))
tracedAdditionalProperties :: Traced Schema -> Maybe (Either Bool (Traced (Referenced Schema)))
tracedAdditionalProperties Traced Schema
sch =
  Schema -> Maybe AdditionalProperties
_schemaAdditionalProperties (Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch) Maybe AdditionalProperties
-> (AdditionalProperties
    -> Either Bool (Traced (Referenced Schema)))
-> Maybe (Either Bool (Traced (Referenced Schema)))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \case
    AdditionalPropertiesAllowed Bool
b -> Bool -> Either Bool (Traced (Referenced Schema))
forall a b. a -> Either a b
Left Bool
b
    AdditionalPropertiesSchema Referenced Schema
x -> Traced (Referenced Schema)
-> Either Bool (Traced (Referenced Schema))
forall a b. b -> Either a b
Right (Traced (Referenced Schema)
 -> Either Bool (Traced (Referenced Schema)))
-> Traced (Referenced Schema)
-> Either Bool (Traced (Referenced Schema))
forall a b. (a -> b) -> a -> b
$ Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step Step Schema (Referenced Schema)
AdditionalPropertiesStep) Referenced Schema
x

tracedDiscriminator :: Traced Schema -> Maybe (Traced Discriminator)
tracedDiscriminator :: Traced Schema -> Maybe (Traced Discriminator)
tracedDiscriminator = EnvT (Trace Discriminator) Identity (Maybe Discriminator)
-> Maybe (Traced Discriminator)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence (EnvT (Trace Discriminator) Identity (Maybe Discriminator)
 -> Maybe (Traced Discriminator))
-> (Traced Schema
    -> EnvT (Trace Discriminator) Identity (Maybe Discriminator))
-> Traced Schema
-> Maybe (Traced Discriminator)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Step Schema Discriminator
-> Traced' Schema (Maybe Discriminator)
-> EnvT (Trace Discriminator) Identity (Maybe Discriminator)
forall a a' b.
Steppable a a' =>
Step a a' -> Traced' a b -> Traced' a' b
stepTraced Step Schema Discriminator
DiscriminatorStep (Traced' Schema (Maybe Discriminator)
 -> EnvT (Trace Discriminator) Identity (Maybe Discriminator))
-> (Traced Schema -> Traced' Schema (Maybe Discriminator))
-> Traced Schema
-> EnvT (Trace Discriminator) Identity (Maybe Discriminator)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Schema -> Maybe Discriminator)
-> Traced Schema -> Traced' Schema (Maybe Discriminator)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Schema -> Maybe Discriminator
_schemaDiscriminator

tracedProperties :: Traced Schema -> IOHM.InsOrdHashMap Text (Traced (Referenced Schema))
tracedProperties :: Traced Schema -> InsOrdHashMap Text (Traced (Referenced Schema))
tracedProperties Traced Schema
sch =
  (Text -> Referenced Schema -> Traced (Referenced Schema))
-> Definitions (Referenced Schema)
-> InsOrdHashMap Text (Traced (Referenced Schema))
forall k v1 v2.
(k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
IOHM.mapWithKey
    (\Text
k -> Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced Schema -> Paths Step TraceRoot Schema
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced Schema
sch Paths Step TraceRoot Schema
-> Paths Step Schema (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step Schema (Definitions (Referenced Schema))
-> Paths Step Schema (Definitions (Referenced Schema))
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step Step Schema (Definitions (Referenced Schema))
PropertiesStep Paths Step Schema (Definitions (Referenced Schema))
-> Paths Step (Definitions (Referenced Schema)) (Referenced Schema)
-> Paths Step Schema (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step (Definitions (Referenced Schema)) (Referenced Schema)
-> Paths Step (Definitions (Referenced Schema)) (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (Text -> Step (Definitions (Referenced Schema)) (Referenced Schema)
forall k v. k -> Step (InsOrdHashMap k v) v
InsOrdHashMapKeyStep Text
k)))
    (Schema -> Definitions (Referenced Schema)
_schemaProperties (Schema -> Definitions (Referenced Schema))
-> Schema -> Definitions (Referenced Schema)
forall a b. (a -> b) -> a -> b
$ Traced Schema -> Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract Traced Schema
sch)

tracedConjunct :: NE.NonEmpty (Traced (Referenced Schema)) -> Traced (Referenced Schema)
tracedConjunct :: NonEmpty (Traced (Referenced Schema)) -> Traced (Referenced Schema)
tracedConjunct NonEmpty (Traced (Referenced Schema))
refSchemas = case (Traced (Referenced Schema) -> Trace (Referenced Schema))
-> NonEmpty (Traced (Referenced Schema))
-> NonEmpty (Traced (Referenced Schema))
forall o a. Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
NE.sortWith Traced (Referenced Schema) -> Trace (Referenced Schema)
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask NonEmpty (Traced (Referenced Schema))
refSchemas of
  (Traced (Referenced Schema)
rs NE.:| []) -> Traced (Referenced Schema)
rs
  (Traced (Referenced Schema)
rs1 NE.:| Traced (Referenced Schema)
rs2 : [Traced (Referenced Schema)]
rss) ->
    Trace (Referenced Schema)
-> Referenced Schema -> Traced (Referenced Schema)
forall a. Trace a -> a -> Traced a
traced (Traced (Referenced Schema) -> Trace (Referenced Schema)
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask Traced (Referenced Schema)
rs1 Trace (Referenced Schema)
-> Paths Step (Referenced Schema) (Referenced Schema)
-> Trace (Referenced Schema)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Step (Referenced Schema) (Referenced Schema)
-> Paths Step (Referenced Schema) (Referenced Schema)
forall k (q :: k -> k -> *) (a :: k) (b :: k).
NiceQuiver q a b =>
q a b -> Paths q a b
step (NonEmpty (Trace (Referenced Schema))
-> Step (Referenced Schema) (Referenced Schema)
ConjunctedWith (NonEmpty (Trace (Referenced Schema))
 -> Step (Referenced Schema) (Referenced Schema))
-> NonEmpty (Trace (Referenced Schema))
-> Step (Referenced Schema) (Referenced Schema)
forall a b. (a -> b) -> a -> b
$ Traced (Referenced Schema) -> Trace (Referenced Schema)
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
ask (Traced (Referenced Schema) -> Trace (Referenced Schema))
-> NonEmpty (Traced (Referenced Schema))
-> NonEmpty (Trace (Referenced Schema))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Traced (Referenced Schema)
rs2 Traced (Referenced Schema)
-> [Traced (Referenced Schema)]
-> NonEmpty (Traced (Referenced Schema))
forall a. a -> [a] -> NonEmpty a
NE.:| [Traced (Referenced Schema)]
rss)) (Referenced Schema -> Traced (Referenced Schema))
-> Referenced Schema -> Traced (Referenced Schema)
forall a b. (a -> b) -> a -> b
$
      Schema -> Referenced Schema
forall a. a -> Referenced a
Inline Schema
forall a. Monoid a => a
mempty {_schemaAllOf :: Maybe [Referenced Schema]
_schemaAllOf = [Referenced Schema] -> Maybe [Referenced Schema]
forall a. a -> Maybe a
Just ([Referenced Schema] -> Maybe [Referenced Schema])
-> [Referenced Schema] -> Maybe [Referenced Schema]
forall a b. (a -> b) -> a -> b
$ Traced (Referenced Schema) -> Referenced Schema
forall (w :: * -> *) a. Comonad w => w a -> a
extract (Traced (Referenced Schema) -> Referenced Schema)
-> [Traced (Referenced Schema)] -> [Referenced Schema]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Traced (Referenced Schema)
rs1 Traced (Referenced Schema)
-> [Traced (Referenced Schema)] -> [Traced (Referenced Schema)]
forall a. a -> [a] -> [a]
: Traced (Referenced Schema)
rs2 Traced (Referenced Schema)
-> [Traced (Referenced Schema)] -> [Traced (Referenced Schema)]
forall a. a -> [a] -> [a]
: [Traced (Referenced Schema)]
rss}