Update fourmolu.yaml

Co-authored-by: Alexey Kuleshevich <[email protected]>

Author: MaximilianAlgehed

examples/Constrained/Examples/Fold.hs

@@ -25,10 +25,10 @@ oddSpec = explainSpec ["odd via (y+y+1)"] $
       (\eval -> pure (div (eval oddx - 1) 2))
       (\ [var|y|] -> [assert $ oddx ==. y + y + 1])
 
-evenSpec
-  :: forall n
-   . (NumLike n, Integral n)
-  => Specification n
+evenSpec ::
+  forall n.
+  (NumLike n, Integral n) =>
+  Specification n
 evenSpec = explainSpec ["even via (x+x)"] $
   constrained $ \ [var|evenx|] ->
     exists
@@ -130,14 +130,14 @@ pickProp = do
     No msgs -> pure $ counterexample ("predicate " ++ nam ++ "\n" ++ unlines msgs) False
 
 -- | Build properties about calls to 'genListWithSize'
-testFoldSpec
-  :: forall a
-   . Foldy a
-  => Specification Integer
-  -> Specification a
-  -> Specification a
-  -> Outcome
-  -> Gen Property
+testFoldSpec ::
+  forall a.
+  Foldy a =>
+  Specification Integer ->
+  Specification a ->
+  Specification a ->
+  Outcome ->
+  Gen Property
 testFoldSpec size elemSpec total outcome = do
   ans <- genFromGenT $ inspect $ genSizedList size elemSpec total
   let callString = parensList ["GenListWithSize", show size, fst (predSpecPair elemSpec), show total]
@@ -153,29 +153,29 @@ testFoldSpec size elemSpec total outcome = do
     (GenError xs, Succeed) -> pure $ counterexample (succeeds xs) False
 
 -- | Generate a property from a call to 'pickAll'. We can test for success or failure using 'outcome'
-sumProp
-  :: (Integral t, Random t, HasSpec t)
-  => t
-  -> t
-  -> Specification t
-  -> t
-  -> Int
-  -> Outcome
-  -> Gen Property
+sumProp ::
+  (Integral t, Random t, HasSpec t) =>
+  t ->
+  t ->
+  Specification t ->
+  t ->
+  Int ->
+  Outcome ->
+  Gen Property
 sumProp smallest largest spec total count outcome = sumProp2 smallest largest (predSpecPair spec) total count outcome
 
 -- | Like SumProp, but instead of using a (Specification fn n) for the element predicate
 --   It uses an explicit pair of a (String, n -> Bool). This means we can test things
 --   using any Haskell function.
-sumProp2
-  :: (Show t, Integral t, Random t)
-  => t
-  -> t
-  -> (String, t -> Bool)
-  -> t
-  -> Int
-  -> Outcome
-  -> Gen Property
+sumProp2 ::
+  (Show t, Integral t, Random t) =>
+  t ->
+  t ->
+  (String, t -> Bool) ->
+  t ->
+  Int ->
+  Outcome ->
+  Gen Property
 sumProp2 smallest largest spec total count outcome = do
   (_, ans) <- pickAll smallest largest spec total count (Cost 0)
   let callString = parensList ["pickAll", show smallest, (fst spec), show total, show count]

examples/Constrained/Examples/ManualExamples.hs

@@ -241,12 +241,12 @@ ex19 :: Specification (Maybe Bool)
 ex19 = constrained $ \mb -> onCon @"Just" mb (\x -> x ==. lit False)
 
 data Dimensions where
-  Dimensions
-    :: { length :: Int
-       , width :: Int
-       , depth :: Int
-       }
-    -> Dimensions
+  Dimensions ::
+    { length :: Int
+    , width :: Int
+    , depth :: Int
+    } ->
+    Dimensions
   deriving (Ord, Eq, Show, Generic)
 
 instance HasSimpleRep Dimensions

examples/Constrained/Examples/MapMember.hs

@@ -10,12 +10,12 @@ import Test.QuickCheck hiding (forAll)
 -- ===============================================
 -- Three Strategies that work
 
-mapMemberA
-  :: (Ord k, IsNormalType k, IsNormalType v, HasSpec k, HasSpec v)
-  => Map k v
-  -> Term k
-  -> Term v
-  -> Pred
+mapMemberA ::
+  (Ord k, IsNormalType k, IsNormalType v, HasSpec k, HasSpec v) =>
+  Map k v ->
+  Term k ->
+  Term v ->
+  Pred
 mapMemberA m key val =
   And
     [ assert $ member_ key (dom_ (lit m))
@@ -27,24 +27,24 @@ mapMemberA m key val =
         (branch $ \x -> assert $ val ==. x)
     ]
 
-mapMemberB
-  :: (Ord k, IsNormalType v, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k)
-  => Map k v
-  -> Term k
-  -> Term v
-  -> Pred
+mapMemberB ::
+  (Ord k, IsNormalType v, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k) =>
+  Map k v ->
+  Term k ->
+  Term v ->
+  Pred
 mapMemberB m key val =
   And
     [ assert $ member_ key (dom_ (lit m))
     , assert $ just_ val ==. lookup_ key (lit m)
     ]
 
-mapMemberC
-  :: (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType v, IsNormalType k)
-  => Map k v
-  -> Term k
-  -> Term v
-  -> Pred
+mapMemberC ::
+  (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType v, IsNormalType k) =>
+  Map k v ->
+  Term k ->
+  Term v ->
+  Pred
 mapMemberC m key val =
   And
     [ assert $ member_ key (dom_ (lit m))
@@ -54,12 +54,12 @@ mapMemberC m key val =
 -- ===============================================
 -- Two Strategies that don't work
 
-mapMemberBad1
-  :: (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k)
-  => Term [(k, v)]
-  -> Term k
-  -> Term v
-  -> Pred
+mapMemberBad1 ::
+  (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k) =>
+  Term [(k, v)] ->
+  Term k ->
+  Term v ->
+  Pred
 mapMemberBad1 m key val =
   And
     [ dependsOn key m
@@ -68,12 +68,12 @@ mapMemberBad1 m key val =
     , assert $ elem_ (pair_ key val) m
     ]
 
-mapMemberBad2
-  :: (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k)
-  => Map k v
-  -> Term k
-  -> Term v
-  -> Pred
+mapMemberBad2 ::
+  (Ord k, HasSpec k, HasSpec v, IsNormalType v, IsNormalType k) =>
+  Map k v ->
+  Term k ->
+  Term v ->
+  Pred
 mapMemberBad2 m key val =
   satisfies
     (pair_ key val)

examples/Constrained/Examples/Set.hs

@@ -86,8 +86,8 @@ maybeSpec = constrained $ \ms ->
       (branch $ \_ -> False)
       (branch $ \y -> 0 <=. y)
 
-eitherSetSpec
-  :: Specification (Set (Either Int Int), Set (Either Int Int), Set (Either Int Int))
+eitherSetSpec ::
+  Specification (Set (Either Int Int), Set (Either Int Int), Set (Either Int Int))
 eitherSetSpec = constrained' $ \es as bs ->
   [ assert $ es ==. (as <> bs)
   , forAll as $ \a ->

fourmolu.yaml

@@ -1,5 +1,5 @@
 indentation: 2
-function-arrows: leading
+function-arrows: trailing
 comma-style: leading
 import-export-style: diff-friendly
 indent-wheres: true

src/Constrained/API.hs

@@ -211,10 +211,10 @@ length_ = sizeOf_
 infixr 2 ||.
 
 -- | Another name for `or_`
-(||.)
-  :: Term Bool
-  -> Term Bool
-  -> Term Bool
+(||.) ::
+  Term Bool ->
+  Term Bool ->
+  Term Bool
 (||.) = or_
 
 infixr 5 ++.