fmt

Author: MaximilianAlgehed

libs/constrained-generators/src/Constrained/API.hs

@@ -188,8 +188,8 @@ import Constrained.Generation
 import Constrained.Generic
 import Constrained.NumOrd
 import Constrained.Properties
-import Constrained.Spec.Map
 import Constrained.Spec.List
+import Constrained.Spec.Map
 import Constrained.Spec.Set
 import Constrained.Spec.SumProd
 import Constrained.Spec.Tree

libs/constrained-generators/src/Constrained/AbstractSyntax.hs

@@ -15,20 +15,20 @@
 {-# LANGUAGE UndecidableInstances #-}
 
 -- | This module contains the abstract syntax of terms, predicates, and specifications
-module Constrained.AbstractSyntax
-  ( TermD (..)
-  , runTermE
-  , runTerm
-  , fastInequality
-  , PredD (..)
-  , SpecificationD (..)
-  , BinderD (..)
-  , Weighted (..)
-  , mapWeighted
-  , traverseWeighted
-  , AppRequiresD
-  , Syntax(..)
-  ) where
+module Constrained.AbstractSyntax (
+  TermD (..),
+  runTermE,
+  runTerm,
+  fastInequality,
+  PredD (..),
+  SpecificationD (..),
+  BinderD (..),
+  Weighted (..),
+  mapWeighted,
+  traverseWeighted,
+  AppRequiresD,
+  Syntax (..),
+) where
 
 import Constrained.Core
 import Constrained.DependencyInjection
@@ -52,10 +52,11 @@ import Test.QuickCheck
 ------------------------------------------------------------------------
 
 -- | First-order terms, application, literals, variables.
---
+
 -- $depsExplanation
 -- See `Constrained.DependencyInjection` to better understand @deps@ - it's a
 -- pointer to postpone having to define `HasSpec` and friends here.
+
 data TermD deps a where
   App ::
     AppRequiresD deps t dom rng =>
@@ -171,8 +172,6 @@ instance Show a => Show (TermD deps a) where
 -- in to handle things like sum types and the specific problems you get into
 -- when generating from constraints (mostly to do with choosing the order in
 -- which to generate things).
---
--- $depsExplanation
 data PredD deps where
   ElemPred ::
     (HasSpecD deps a, Show a) =>
@@ -265,8 +264,6 @@ data PredD deps where
   Explain :: NE.NonEmpty String -> PredD deps -> PredD deps
 
 -- | Binders, a `Var` is bound in a `Pred`, never anywhere else
---
--- $depsExplanation
 data BinderD deps a where
   (:->) ::
     (HasSpecD deps a, Show a) =>
@@ -346,8 +343,6 @@ instance Pretty (BinderD deps a) where
 ------------------------------------------------------------------------
 
 -- | A @`Specification` a@ denotes a set of @a@s
---
--- $depsExplanation
 data SpecificationD deps a where
   -- | Explain a Specification
   ExplainSpec :: [String] -> SpecificationD deps a -> SpecificationD deps a

libs/constrained-generators/src/Constrained/Core.hs

@@ -18,6 +18,7 @@ module Constrained.Core (
   eqVar,
   Rename (..),
   freshen,
+
   -- * Random cruft
   Value (..),
   unValue,

libs/constrained-generators/src/Constrained/PrettyUtils.hs

@@ -9,22 +9,23 @@
 {-# LANGUAGE TypeApplications #-}
 
 -- | Utility functions for writing pretty-printers
-
 module Constrained.PrettyUtils (
   -- * Precedence
-  WithPrec(..),
+  WithPrec (..),
   parensIf,
   prettyPrec,
+
   -- * Lists
   ppList,
   ppListC,
+
   -- * General helpers
   prettyType,
   vsep',
   (/>),
   showType,
   short,
-  ) where
+) where
 
 import Constrained.List
 import Data.String (fromString)

libs/constrained-generators/src/Constrained/Spec/List.hs

@@ -1,44 +1,43 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE UndecidableSuperClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE GADTs #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE KindSignatures #-}
-{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableSuperClasses #-}
 {-# LANGUAGE ViewPatterns #-}
-{-# LANGUAGE ExistentialQuantification #-}
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE OverloadedStrings #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
-module Constrained.Spec.List
-  ( ListSpec(..)
-  , ListW(..)
-  , ElemW(..)
-  , pattern Elem
-  , append_
-  , singletonList_
-  , elem_
-  , sum_
-  , foldMap_
-  , Foldy(..)
-  , FoldSpec(..)
-  , preMapFoldSpec
-  , toPredsFoldSpec
-  , adds
-  , conformsToFoldSpec
-  , combineFoldSpec
-  ) where
+module Constrained.Spec.List (
+  ListSpec (..),
+  ListW (..),
+  ElemW (..),
+  pattern Elem,
+  append_,
+  singletonList_,
+  elem_,
+  sum_,
+  foldMap_,
+  Foldy (..),
+  FoldSpec (..),
+  preMapFoldSpec,
+  toPredsFoldSpec,
+  adds,
+  conformsToFoldSpec,
+  combineFoldSpec,
+) where
 
-import Constrained.TheKnot
 import Constrained.AbstractSyntax
 import Constrained.Base
 import Constrained.Conformance
@@ -54,6 +53,7 @@ import Constrained.SumList
 -- TODO: some strange things here, why is SolverStage in here?!
 -- Because it is mutually recursive with something else in here.
 import Constrained.Syntax
+import Constrained.TheKnot
 import Control.Applicative
 import Control.Monad
 import Data.Foldable
@@ -135,7 +135,6 @@ guardListSpec msg l@(ListSpec _hint must size elemS _fold)
         )
   | otherwise = (typeSpec l)
 
-
 data ElemW :: [Type] -> Type -> Type where
   ElemW :: HasSpec a => ElemW '[a, [a]] Bool
 
@@ -265,7 +264,6 @@ instance Forallable [a] a where
   fromForAllSpec es = typeSpec (ListSpec Nothing [] mempty es NoFold)
   forAllToList = id
 
-
 instance Logic ListW where
   propagateTypeSpec (FoldMapW f) (Unary HOLE) ts cant =
     typeSpec (ListSpec Nothing [] TrueSpec TrueSpec $ FoldSpec f (TypeSpec ts cant))
@@ -341,7 +339,6 @@ instance Logic ListW where
       unsafeExists $ \x' ->
         Assert (x ==. appFun (foldMapFn g) x') <> toPreds x' ts
 
-
 data ListW (args :: [Type]) (res :: Type) where
   FoldMapW :: forall a b. (Foldy b, HasSpec a) => Fun '[a] b -> ListW '[[a]] b
   SingletonListW :: HasSpec a => ListW '[a] [a]
@@ -624,4 +621,3 @@ instance Sized [a] where
     Just zs -> typeSpec (ListSpec Nothing mempty (MemberSpec zs) TrueSpec NoFold)
   sizeOfTypeSpec (ListSpec _ _ _ ErrorSpec {} _) = equalSpec 0
   sizeOfTypeSpec (ListSpec _ must sizespec _ _) = sizespec <> geqSpec (sizeOf must)
-

libs/constrained-generators/src/Constrained/Spec/Map.hs

@@ -15,16 +15,15 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 -- | `HasSpec` instance for `Map` and functions for working with `Map`s
-
-module Constrained.Spec.Map
-  ( MapSpec (..)
-  , defaultMapSpec
-  , MapW (..)
-  , lookup_
-  , mapMember_
-  , dom_
-  , rng_
-  ) where
+module Constrained.Spec.Map (
+  MapSpec (..),
+  defaultMapSpec,
+  MapW (..),
+  lookup_,
+  mapMember_,
+  dom_,
+  rng_,
+) where
 
 import Constrained.AbstractSyntax
 import Constrained.Base

libs/constrained-generators/src/Constrained/Spec/Set.hs

@@ -15,16 +15,16 @@
 
 -- | `HasSpec` instance for `Set`s and functions for writing
 -- constraints about sets
-module Constrained.Spec.Set
-  ( SetSpec(..)
-  , SetW(..)
-  , singleton_
-  , subset_
-  , member_
-  , union_
-  , disjoint_
-  , fromList_
-  ) where
+module Constrained.Spec.Set (
+  SetSpec (..),
+  SetW (..),
+  singleton_,
+  subset_,
+  member_,
+  union_,
+  disjoint_,
+  fromList_,
+) where
 
 import Constrained.AbstractSyntax
 import Constrained.Base
@@ -36,11 +36,10 @@ import Constrained.Generation
 import Constrained.List
 import Constrained.NumOrd
 import Constrained.PrettyUtils
-import Constrained.SumList
 import Constrained.Spec.List
+import Constrained.SumList
 import Constrained.Syntax
 import Constrained.TheKnot
-
 import Data.Foldable
 import Data.Kind
 import Data.List ((\\))
@@ -55,9 +54,14 @@ import Test.QuickCheck (shrinkList, shuffle)
 ------------------------------------------------------------------------
 
 -- | `TypeSpec` for `Set`
-data SetSpec a = SetSpec (Set a) -- ^ Required elements
-                         (Specification a) -- ^ Specification for elements
-                         (Specification Integer) -- ^ Specification for size
+data SetSpec a
+  = SetSpec
+      -- | Required elements
+      (Set a)
+      -- | Specification for elements
+      (Specification a)
+      -- | Specification for size
+      (Specification Integer)
 
 instance Ord a => Sized (Set.Set a) where
   sizeOf = toInteger . Set.size

libs/constrained-generators/src/Constrained/Spec/SumProd.hs

@@ -99,6 +99,7 @@ import Constrained.List (
   listShape,
   mapListC,
  )
+import Constrained.Spec.List
 import Constrained.Syntax (
   exists,
   forAll,
@@ -107,7 +108,6 @@ import Constrained.Syntax (
   reify,
  )
 import Constrained.TheKnot
-import Constrained.Spec.List
 import Constrained.TypeErrors
 import Data.Typeable (Typeable)
 import GHC.Generics