Merge branch 'master' into nightly

Author: MaximilianAlgehed

README.md

@@ -1,2 +1,5 @@
+
 # constrained-generators
+[![Coverage Status](https://coveralls.io/repos/github/input-output-hk/constrained-generators/badge.svg?branch=master)](https://coveralls.io/github/input-output-hk/constrained-generators?branch=master)
+
 Framework for generating constrained random data using a subset of first order logic

constrained-generators.cabal

@@ -79,7 +79,7 @@ library
     -Wunused-packages
 
   build-depends:
-    QuickCheck >=2.14 && <2.18,
+    QuickCheck >=2.15.0.1 && <2.18,
     base >=4.18 && <5,
     base-orphans,
     containers,
@@ -114,7 +114,7 @@ library examples
     -Wunused-packages
 
   build-depends:
-    QuickCheck >=2.14,
+    QuickCheck >=2.15.0.1,
     base >=4.18 && <5,
     constrained-generators,
     containers,
@@ -125,7 +125,9 @@ test-suite constrained-tests
   type: exitcode-stdio-1.0
   main-is: Tests.hs
   hs-source-dirs: test
-  other-modules: Constrained.Tests
+  other-modules:
+    Constrained.Tests
+    Constrained.GraphSpec
   default-language: Haskell2010
   ghc-options:
     -Wall
@@ -138,7 +140,7 @@ test-suite constrained-tests
     -rtsopts
 
   build-depends:
-    QuickCheck,
+    QuickCheck >= 2.15.0.1,
     base,
     constrained-generators,
     containers,

examples/Constrained/Examples/BinTree.hs

@@ -76,6 +76,8 @@ instance HasSpec a => HasSpec (BinTree a) where
       : (BinNode left a <$> shrinkWithTypeSpec s right)
       ++ ((\l -> BinNode l a right) <$> shrinkWithTypeSpec s left)
 
+  fixupWithTypeSpec _ _ = Nothing
+
   cardinalTypeSpec _ = mempty
 
   toPreds t (BinTreeSpec msz s) =

examples/Constrained/Examples/CheatSheet.hs

@@ -364,7 +364,7 @@ tightFit0 = constrained' $ \x y ->
 --         TypeSpec (Cartesian TrueSpec (MemberSpec [0])) []
 --         ---
 --         assert $ Equal (Fst (ToGeneric v_3)) v_1
---   Env {unEnv = fromList [(v_0,EnvValue 0)]}
+--   Env (fromList [(v_0,EnvValue 0)])
 -- genFromSpecT ErrorSpec{} with explanation:
 -- [1..-1]
 

src/Constrained/Base.hs

@@ -101,10 +101,6 @@ import Constrained.GenT
 import Constrained.Generic
 import Constrained.List hiding (toList)
 import Constrained.TypeErrors
-import Control.Monad.Writer (
-  Writer,
-  tell,
- )
 import Data.Foldable (
   toList,
  )
@@ -492,6 +488,12 @@ class
   -- | Shrink an `a` with the aide of a `TypeSpec`
   shrinkWithTypeSpec :: TypeSpec a -> a -> [a]
 
+  -- | Try to make an `a` conform to `TypeSpec` with minimal changes. When
+  -- `fixupWithSpec ts a` returns `Just a'`, it should be the case that
+  -- `conformsTo a' ts`. There are no constraints in the `Nothing` case. A
+  -- non-trivial implementation of this function is important for shrinking.
+  fixupWithTypeSpec :: TypeSpec a -> a -> Maybe a
+
   -- | Convert a spec to predicates:
   -- The key property here is:
   --   ∀ a. a `conformsTo` spec == a `conformsTo` constrained (\t -> toPreds t spec)
@@ -524,12 +526,6 @@ class
   alternateShow :: TypeSpec a -> BinaryShow
   alternateShow _ = NonBinary
 
-  monadConformsTo :: a -> TypeSpec a -> Writer [String] Bool
-  monadConformsTo x spec =
-    if conformsTo @a x spec
-      then pure True
-      else tell ["Fails by " ++ show spec] >> pure False
-
   -- | For some types (especially finite ones) there may be much better ways to construct
   --   a Specification than the default method of just adding a large 'bad' list to TypSpec. This
   --   function allows each HasSpec instance to decide.
@@ -608,6 +604,13 @@ class
     [a]
   shrinkWithTypeSpec spec a = map fromSimpleRep $ shrinkWithTypeSpec spec (toSimpleRep a)
 
+  default fixupWithTypeSpec ::
+    GenericallyInstantiated a =>
+    TypeSpec a ->
+    a ->
+    Maybe a
+  fixupWithTypeSpec spec a = fromSimpleRep <$> fixupWithTypeSpec spec (toSimpleRep a)
+
   default cardinalTypeSpec ::
     GenericallyInstantiated a =>
     TypeSpec a ->
@@ -628,6 +631,7 @@ instance HasSpec Bool where
   cardinalTypeSpec _ = equalSpec 2
   cardinalTrueSpec = equalSpec 2
   shrinkWithTypeSpec _ = shrink
+  fixupWithTypeSpec _ = Just
   conformsTo _ _ = True
   toPreds _ _ = TruePred
 
@@ -637,6 +641,7 @@ instance HasSpec () where
   combineSpec _ _ = typeSpec ()
   _ `conformsTo` _ = True
   shrinkWithTypeSpec _ _ = []
+  fixupWithTypeSpec _ _ = pure ()
   genFromTypeSpec _ = pure ()
   toPreds _ _ = TruePred
   cardinalTypeSpec _ = MemberSpec (pure 1)

src/Constrained/Conformance.hs

@@ -14,7 +14,7 @@ module Constrained.Conformance (
   conformsToSpec,
   conformsToSpecE,
   satisfies,
-  checkPred,
+  checkPredE,
   checkPredsE,
 ) where
 
@@ -34,59 +34,9 @@ import Data.Semigroup (sconcat)
 import Prettyprinter hiding (cat)
 import Test.QuickCheck (Property, Testable, property)
 
--- =========================================================================
-
--- | Does the Pred evaluate to true under the given Env.
---   If it doesn't, some explanation appears in the failure of the monad 'm'
-checkPred :: forall m. MonadGenError m => Env -> Pred -> m Bool
-checkPred env = \case
-  p@(ElemPred bool term xs) -> do
-    v <- runTerm env term
-    case (elem v xs, bool) of
-      (True, True) -> pure True
-      (True, False) -> fatalErrorNE ("notElemPred reduces to True" :| [show p])
-      (False, True) -> fatalErrorNE ("elemPred reduces to False" :| [show p])
-      (False, False) -> pure True
-  Monitor {} -> pure True
-  Subst x t p -> checkPred env $ substitutePred x t p
-  Assert t -> runTerm env t
-  GenHint {} -> pure True
-  p@(Reifies t' t f) -> do
-    val <- runTerm env t
-    val' <- runTerm env t'
-    explainNE (NE.fromList ["Reification:", "  " ++ show p]) $ pure (f val == val')
-  ForAll t (x :-> p) -> do
-    set <- runTerm env t
-    and
-      <$> sequence
-        [ checkPred env' p
-        | v <- forAllToList set
-        , let env' = Env.extend x v env
-        ]
-  Case t bs -> do
-    v <- runTerm env t
-    runCaseOn v (mapList thing bs) (\x val ps -> checkPred (Env.extend x val env) ps)
-  When bt p -> do
-    b <- runTerm env bt
-    if b then checkPred env p else pure True
-  TruePred -> pure True
-  FalsePred es -> explainNE es $ pure False
-  DependsOn {} -> pure True
-  And ps -> checkPreds env ps
-  Let t (x :-> p) -> do
-    val <- runTerm env t
-    checkPred (Env.extend x val env) p
-  Exists k (x :-> p) -> do
-    a <- runGE $ k (errorGE . explain "checkPred: Exists" . runTerm env)
-    checkPred (Env.extend x a env) p
-  Explain es p -> explainNE es $ checkPred env p
-
-checkPreds :: (MonadGenError m, Traversable t) => Env -> t Pred -> m Bool
-checkPreds env ps = and <$> mapM (checkPred env) ps
-
 -- ==========================================================
 
--- | Like checkPred, But it takes [Pred] rather than a single Pred,
+-- | Like checkPredE, But it takes [Pred] rather than a single Pred,
 --   and it builds a much more involved explanation if it fails.
 --   Does the Pred evaluate to True under the given Env?
 --   If it doesn't, an involved explanation appears in the (Just message)
@@ -101,8 +51,9 @@ checkPredsE msgs env ps =
     [] -> Nothing
     (x : xs) -> Just (NE.nub (sconcat (x NE.:| xs)))
 
--- | An involved explanation for a single Pred
---   The most important explanations come when an assertion fails.
+-- | Does the Pred evaluate to true under the given Env. An involved
+-- explanation for a single Pred in case of failure and `Nothing` otherwise.
+-- The most important explanations come when an assertion fails.
 checkPredE :: Env -> NE.NonEmpty String -> Pred -> Maybe (NE.NonEmpty String)
 checkPredE env msgs = \case
   p@(ElemPred bool t xs) ->

src/Constrained/Env.hs

@@ -27,7 +27,7 @@ import Prettyprinter
 import Prelude hiding (lookup)
 
 -- | Typed environments for mapping @t`Var` a@ to @a@
-newtype Env = Env {unEnv :: Map EnvKey EnvValue}
+newtype Env = Env (Map EnvKey EnvValue)
   deriving newtype (Semigroup, Monoid)
   deriving stock (Show)
 

src/Constrained/Generation.hs

@@ -25,6 +25,7 @@ module Constrained.Generation (
   genFromSpecT,
   genFromSpecWithSeed,
   shrinkWithSpec,
+  fixupWithSpec,
   simplifySpec,
 
   -- ** Debugging
@@ -155,15 +156,71 @@ shrinkWithSpec (simplifySpec -> spec) a = filter (`conformsToSpec` spec) $ case
   ExplainSpec _ s -> shrinkWithSpec s a
   -- TODO: filter on can't if we have a known to be sound shrinker
   TypeSpec s _ -> shrinkWithTypeSpec s a
-  -- TODO: The better way of doing this is to compute the dependency graph,
-  -- shrink one variable at a time, and fixup the rest of the variables
-  SuspendedSpec {} -> shr a
+  SuspendedSpec x p -> shrinkFromPreds p x a ++ shr a
   MemberSpec {} -> shr a
   TrueSpec -> shr a
   ErrorSpec {} -> []
   where
     shr = shrinkWithTypeSpec (emptySpec @a)
 
+shrinkFromPreds :: HasSpec a => Pred -> Var a -> a -> [a]
+shrinkFromPreds p
+  | Result plan <- prepareLinearization p = \x a -> listFromGE $ do
+      -- NOTE: we do this to e.g. guard against bad construction functions in Exists
+      case checkPredE (Env.singleton x a) (NE.fromList []) p of
+        Nothing -> pure ()
+        Just err -> explainNE err $ fatalError "Trying to shrink a bad value, don't do that!"
+      -- Get an `env` for the original value
+      initialEnv <- envFromPred (Env.singleton x a) p
+      return
+        [ a'
+        | -- Shrink the initialEnv
+        env' <- shrinkEnvFromPlan initialEnv plan
+        , -- Get the value of the constrained variable `x` in the shrunk env
+        Just a' <- [Env.lookup env' x]
+        , -- NOTE: this is necessary because it's possible that changing
+        -- a particular value in the env during shrinking might not result
+        -- in the value of `x` changing and there is no better way to know than
+        -- to do this.
+        a' /= a
+        ]
+  | otherwise = error "Bad pred"
+
+-- Start with a valid Env for the plan and try to shrink it
+shrinkEnvFromPlan :: Env -> SolverPlan -> [Env]
+shrinkEnvFromPlan initialEnv SolverPlan {..} = go mempty solverPlan
+  where
+    go :: Env -> [SolverStage] -> [Env]
+    go _ [] = [] -- In this case we decided to keep every variable the same so nothing to return
+    go env ((unsafeSubstStage env -> SolverStage {..}) : plan) = do
+      Just a <- [Env.lookup initialEnv stageVar]
+      -- Two cases:
+      --  - either we shrink this value and try to fixup every value later on in the plan or
+      [ fixedEnv
+        | a' <- shrinkWithSpec stageSpec a
+        , let env' = Env.extend stageVar a' env
+        , Just fixedEnv <- [fixupPlan env' plan]
+        ]
+        --  - we keep this value the way it is and try to shrink some later value
+        ++ go (Env.extend stageVar a env) plan
+
+    -- Fix the rest of the plan given an environment `env` for the plan so far
+    fixupPlan :: Env -> [SolverStage] -> Maybe Env
+    fixupPlan env [] = pure env
+    fixupPlan env ((unsafeSubstStage env -> SolverStage {..}) : plan) =
+      case Env.lookup (env <> initialEnv) stageVar >>= fixupWithSpec stageSpec of
+        Nothing -> Nothing
+        Just a -> fixupPlan (Env.extend stageVar a env) plan
+
+-- Try to fix a value w.r.t a specification
+fixupWithSpec :: forall a. HasSpec a => Specification a -> a -> Maybe a
+fixupWithSpec spec a
+  | a `conformsToSpec` spec = Just a
+  | otherwise = case spec of
+      MemberSpec (a' :| _) -> Just a'
+      TypeSpec ts _ -> fixupWithTypeSpec ts a >>= \ a' -> a' <$  guard (conformsToSpec a' spec)
+      _ -> listToMaybe $ filter (`conformsToSpec` spec) (shrinkWithSpec TrueSpec a)
+
 -- Debugging --------------------------------------------------------------
 
 -- | A version of `genFromSpecT` that runs in the IO monad. Good for debugging.
@@ -197,6 +254,10 @@ prettyPlan (simplifySpec -> spec)
 
 -- ---------------------- Building a plan -----------------------------------
 
+unsafeSubstStage :: Env -> SolverStage -> SolverStage
+unsafeSubstStage env (SolverStage y ps spec relevant) =
+  normalizeSolverStage $ SolverStage y (substPred env <$> ps) spec relevant
+
 substStage :: HasSpec a => Set Name -> Var a -> a -> SolverStage -> SolverStage
 substStage rel' x val (SolverStage y ps spec relevant) =
   normalizeSolverStage $ SolverStage y (substPred env <$> ps) spec relevant'
@@ -1105,6 +1166,9 @@ instance (HasSpec a, HasSpec b, KnownNat (CountCases b)) => HasSpec (Sum a b) wh
   shrinkWithTypeSpec (SumSpec _ sa _) (SumLeft a) = SumLeft <$> shrinkWithSpec sa a
   shrinkWithTypeSpec (SumSpec _ _ sb) (SumRight b) = SumRight <$> shrinkWithSpec sb b
 
+  fixupWithTypeSpec (SumSpec _ sa _) (SumLeft a) = SumLeft <$> fixupWithSpec sa a
+  fixupWithTypeSpec (SumSpec _ _ sb) (SumRight b) = SumRight <$> fixupWithSpec sb b
+
   toPreds ct (SumSpec h sa sb) =
     Case
       ct