Minor clean up

Author: Lucsanszky

eras/conway/impl/testlib/Test/Cardano/Ledger/Conway/Era.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE UndecidableSuperClasses #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 

eras/mary/impl/testlib/Test/Cardano/Ledger/Mary/TreeDiff.hs

@@ -30,4 +30,4 @@ instance ToExpr AssetName where
 
 deriving newtype instance ToExpr (CompactForm MaryValue)
 
-instance ToExpr (TxBody MaryEra) -- TODO: investigate
+instance ToExpr (TxBody MaryEra)

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Ast.hs

@@ -934,7 +934,7 @@ targetMaybeEnv root (x :$ y) env =
   targetMaybeEnv root y env >>= targetMaybeEnv root x
 targetMaybeEnv _ _ _ = Nothing
 
-runPred :: forall era. (EraTest era, Reflect era) => Env era -> Pred era -> Typed Bool
+runPred :: (EraTest era, Reflect era) => Env era -> Pred era -> Typed Bool
 runPred env (MetaSize w x) = do
   sz <- runTerm env x
   case sz of
@@ -1004,14 +1004,14 @@ runPred env (Maybe x tar ps) = do
   case m of
     Nothing -> pure True
     (Just y) -> do
-      ans <- mapM (runPred (bind @era tar y env)) ps
+      ans <- mapM (runPred (bind tar y env)) ps
       pure (and ans)
 -- choose should have been removed by the Rewrite phase.
 runPred _ (Choose _ _ _) = pure True -- We can't really test this. failT ["Choose predicate in runPred", show p]
 runPred env (ForEach _sz term pat ps) = do
   -- size <- runTerm env _sz
   ts <- getList <$> runTerm env term
-  bs <- mapM (\t -> runPreds @era (bindPat t env pat) (filter (not . extendableSumsTo pat) ps)) ts
+  bs <- mapM (\t -> runPreds (bindPat t env pat) (filter (not . extendableSumsTo pat) ps)) ts
   pure (and bs)
 runPred env (SubMap x y) = do
   x2 <- runTerm env x
@@ -1078,12 +1078,12 @@ extendableSumsTo pat (SumSplit _ t _ [One s]) =
 extendableSumsTo _ _ = False
 
 -- | run a bunch of Preds, and and together the results
-runPreds :: forall era. (EraTest era, Reflect era) => Env era -> [Pred era] -> Typed Bool
+runPreds :: (EraTest era, Reflect era) => Env era -> [Pred era] -> Typed Bool
 runPreds env ps = do
   bs <- mapM (runPred env) ps
   pure (and bs)
 
-bind :: forall era r t. (EraTest era, Reflect era) => RootTarget era r t -> t -> Env era -> Env era
+bind :: (EraTest era, Reflect era) => RootTarget era r t -> t -> Env era -> Env era
 bind (Simple (Var v)) x env = storeVar v x env
 bind (Lensed (Var v) _) x env = storeVar v x env
 bind t _ _ = error ("Non simple Target in bind: " ++ show t)

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Examples.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE AllowAmbiguousTypes #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -72,7 +71,6 @@ stoi :: OrderInfo
 stoi = standardOrderInfo
 
 genMaybeCounterExample ::
-  forall era.
   (Reflect era, EraTest era) =>
   String ->
   Bool ->
@@ -83,7 +81,7 @@ genMaybeCounterExample ::
 genMaybeCounterExample _testname loud order cs target = do
   let cs3 = removeEqual cs []
   let cs4 = removeSameVar cs3 []
-  graph@(DependGraph _) <- monadTyped $ compile @era order cs
+  graph@(DependGraph _) <- monadTyped $ compile order cs
   let messages1 =
         if listEq cpeq cs4 cs
           then ["Constraints", show cs, "Rewriting is idempotent"]
@@ -140,13 +138,12 @@ testn testname loud order cs target = do
 
 -- | Test that 'cs' :: [Pred] does NOT have a solution. We expect a failure
 failn ::
-  forall era.
   (Reflect era, EraTest era) =>
   String -> Bool -> OrderInfo -> [Pred era] -> Assembler era -> IO ()
 failn message loud order cs target = do
   shouldThrow
     ( do
-        result <- generate (genMaybeCounterExample @era message loud order cs target)
+        result <- generate (genMaybeCounterExample message loud order cs target)
         case result of
           Nothing -> putStrLn (message ++ " should have failed but it did not.")
           Just counter ->
@@ -211,15 +208,15 @@ test3 = testn @MaryEra "Test 3. PState example" False stoi cs (Assemble pstateT)
 
 -- ==============================
 
-test4 :: forall era. (Reflect era, EraTest era) => IO ()
-test4 = failn @era "Test 4. Inconsistent Size" False stoi cs Skip
+test4 :: IO ()
+test4 = failn @MaryEra "Test 4. Inconsistent Size" False stoi cs Skip
   where
     cs =
       [ Sized (ExactSize 5) rewards
       , SumsTo (Right (Coin 1)) (Lit CoinR (Coin 5)) GTH [SumMap rewards]
       ]
 
-test5 :: EraTest MaryEra => IO ()
+test5 :: IO ()
 test5 = failn @MaryEra "Test 5. Bad Sum, impossible partition." False stoi cs Skip
   where
     cs =
@@ -269,11 +266,11 @@ constraints proof =
   ]
 
 -- | Test that we can find a viable variable ordering
-test6 :: forall era. (EraTest era, Reflect era) => Bool -> IO ()
+test6 :: Bool -> IO ()
 test6 loud = do
   putStrLn "testing: find a viable order of variables"
   when loud $ putStrLn "======================================================="
-  case runTyped (compile standardOrderInfo $ constraints (reify @era)) of
+  case runTyped (compile standardOrderInfo $ constraints Shelley) of
     Right x ->
       if loud
         then print x
@@ -458,10 +455,10 @@ test13 =
 
 -- ==============================================
 
-test14 :: forall era. (EraTest era, Reflect era) => IO ()
+test14 :: IO ()
 test14 =
   failn
-    @era
+    @AllegraEra
     "Test 14. Catch unsolveable use of Sized"
     False
     stoi
@@ -822,11 +819,11 @@ allExampleTests =
     , testIO
         "test 19 Test of projOnDom function"
         (generate (help19 Mary))
-    , testIO "Test 4. Inconsistent Size" (test4 @MaryEra)
+    , testIO "Test 4. Inconsistent Size" test4
     , testIO "Test 5. Bad Sum, impossible partition." test5
-    , testIO "Test6. Find a viable order of variables" (test6 @ShelleyEra False)
+    , testIO "Test6. Find a viable order of variables" (test6 False)
     , testIO "Test7. Compute a solution" (test7 False)
-    , testIO "Test 14 Catch unsolveable use of Sized" (test14 @AllegraEra)
+    , testIO "Test 14 Catch unsolveable use of Sized" test14
     , testPropMax 30 "Test 3. PState example" test3
     , testPropMax 30 "Test 8. Pstate constraints" test8
     , testPropMax 30 "Test 9. Test of summing" test9

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Preds/Repl.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Preds/TxOut.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE DataKinds #-}
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE RankNTypes #-}

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Rewrite.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE PartialTypeSignatures #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -211,18 +210,18 @@ removeEqual ((expr@Lit {} :=: Var v) : more) ans = removeEqual (map sub more) ((
     sub = substPred (singleSubst v expr)
 removeEqual (m : more) ans = removeEqual more (m : ans)
 
-removeTrivial :: forall era. (EraTest era, Reflect era) => [Pred era] -> [Pred era]
+removeTrivial :: (EraTest era, Reflect era) => [Pred era] -> [Pred era]
 removeTrivial = filter (not . trivial)
   where
     trivial p | null (varsOfPred mempty p) =
-      case runTyped $ runPred @era (Env mempty) p of
+      case runTyped $ runPred (Env mempty) p of
         Left {} -> False
         Right validx -> validx
     trivial (e1 :=: e2) = cteq e1 e2
     trivial _ = False
 
-rewrite :: forall era. (EraTest era, Reflect era) => [Pred era] -> [Pred era]
-rewrite cs = removeTrivial @era $ removeSameVar (removeEqual cs []) []
+rewrite :: (EraTest era, Reflect era) => [Pred era] -> [Pred era]
+rewrite cs = removeTrivial $ removeSameVar (removeEqual cs []) []
 
 -- =========================================================
 -- Expanding (Choose _ _ _) into several simpler [Pred era]
@@ -774,9 +773,9 @@ initialOrder info cs0 = do
 
 -- | Construct the DependGraph
 compile ::
-  forall era. (EraTest era, Reflect era) => OrderInfo -> [Pred era] -> Typed (DependGraph era)
+  (EraTest era, Reflect era) => OrderInfo -> [Pred era] -> Typed (DependGraph era)
 compile info cs = do
-  let simple = rewrite @era cs
+  let simple = rewrite cs
   orderedNames <- initialOrder info simple
   mkDependGraph (length orderedNames) [] HashSet.empty orderedNames [] (filter notBefore simple)
 

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Shrink.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
 
 module Test.Cardano.Ledger.Constrained.Shrink (

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Solver.hs

@@ -1003,14 +1003,8 @@ genOrFailList ::
   Gen (Either [String] (Subst era))
 genOrFailList loud = foldlM' (genOrFail loud)
 
--- TODO: revisit
 genDependGraph ::
   (EraTest era, Reflect era) => Bool -> DependGraph era -> Gen (Either [String] (Subst era))
--- genDependGraph loud Shelley (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
--- genDependGraph loud Allegra (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
--- genDependGraph loud Mary (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
--- genDependGraph loud Alonzo (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
--- genDependGraph loud Babbage (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
 genDependGraph loud (DependGraph pairs) = genOrFailList loud (Right emptySubst) pairs
 
 -- | Solve for one variable, and add its solution to the substitution

libs/cardano-ledger-test/src/Test/Cardano/Ledger/Constrained/Spec.hs

@@ -2,16 +2,12 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 -- | A 'Spec' is a first order data structure that denotes a random generator