Fix up the generators.

Author: robrix

semantic-core/test/Generators.hs

@@ -18,39 +18,40 @@ import qualified Hedgehog.Range as Range
 
 import Data.Core
 import Data.Name
+import Data.Term
 
 -- The 'prune' call here ensures that we don't spend all our time just generating
 -- fresh names for variables, since the length of variable names is not an
 -- interesting property as they parse regardless.
-name :: MonadGen m => m Name
-name = Gen.prune (User <$> names) where
+name :: MonadGen m => m (Named Name)
+name = Gen.prune ((Named . Ignored <*> User) <$> names) where
   names = Gen.text (Range.linear 1 10) Gen.lower
 
-boolean :: MonadGen m => m Core
-boolean = Bool <$> Gen.bool
+boolean :: MonadGen m => m (Term Core Name)
+boolean = bool <$> Gen.bool
 
-variable :: MonadGen m => m Core
-variable = Var <$> name
+variable :: MonadGen m => m (Term Core Name)
+variable = pure . namedValue <$> name
 
-ifthenelse :: MonadGen m => m Core -> m Core
-ifthenelse bod = Gen.subterm3 boolean bod bod If
+ifthenelse :: MonadGen m => m (Term Core Name) -> m (Term Core Name)
+ifthenelse bod = Gen.subterm3 boolean bod bod if'
 
-apply :: MonadGen m => m Core -> m Core
+apply :: MonadGen m => m (Term Core Name) -> m (Term Core Name)
 apply gen = go where
   go = Gen.recursive
     Gen.choice
-    [ Gen.subterm2 gen gen (:$)]
-    [ Gen.subterm2 go go (:$)  -- balanced
-    , Gen.subtermM go (\x -> Lam <$> name <*> pure x)
+    [ Gen.subterm2 gen gen ($$)]
+    [ Gen.subterm2 go go ($$)  -- balanced
+    , Gen.subtermM go (\x -> lam <$> name <*> pure x)
     ]
 
-lambda :: MonadGen m => m Core -> m Core
+lambda :: MonadGen m => m (Term Core Name) -> m (Term Core Name)
 lambda bod = do
   arg <- name
-  Gen.subterm bod (Lam arg)
+  Gen.subterm bod (lam arg)
 
-atoms :: MonadGen m => [m Core]
-atoms = [boolean, variable, pure Unit, pure Frame]
+atoms :: MonadGen m => [m (Term Core Name)]
+atoms = [boolean, variable, pure unit, pure frame]
 
-literal :: MonadGen m => m Core
+literal :: MonadGen m => m (Term Core Name)
 literal = Gen.recursive Gen.choice atoms [lambda literal]