Various perf improvements

src/Expect.elm

@@ -103,6 +103,7 @@ Another example is comparing values that are on either side of zero. `0.0001` is
 -}
 
 import Dict exposing (Dict)
+import Fuzz.Internal
 import Set exposing (Set)
 import Test.Distribution
 import Test.Expectation
@@ -392,10 +393,12 @@ ok result =
             pass
 
         Err _ ->
-            { description = "Expect.ok"
-            , reason = Comparison "Ok _" (Internal.toString result)
-            }
-                |> Test.Expectation.fail
+            Test.Expectation.Fail
+                { given = Nothing
+                , distributionReport = Fuzz.Internal.noDistribution
+                , description = "Expect.ok"
+                , reason = Comparison "Ok _" (Internal.toString result)
+                }
 
 
 {-| Passes if the
@@ -433,10 +436,12 @@ err : Result a b -> Expectation
 err result =
     case result of
         Ok _ ->
-            { description = "Expect.err"
-            , reason = Comparison "Err _" (Internal.toString result)
-            }
-                |> Test.Expectation.fail
+            Test.Expectation.Fail
+                { given = Nothing
+                , distributionReport = Fuzz.Internal.noDistribution
+                , description = "Expect.err"
+                , reason = Comparison "Err _" (Internal.toString result)
+                }
 
         Err _ ->
             pass
@@ -475,10 +480,12 @@ equalLists expected actual =
         pass
 
     else
-        { description = "Expect.equalLists"
-        , reason = ListDiff (List.map Internal.toString expected) (List.map Internal.toString actual)
-        }
-            |> Test.Expectation.fail
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , description = "Expect.equalLists"
+            , reason = ListDiff (List.map Internal.toString expected) (List.map Internal.toString actual)
+            }
 
 
 {-| Passes if the arguments are equal dicts.
@@ -595,7 +602,7 @@ equalSets expected actual =
 -}
 pass : Expectation
 pass =
-    Test.Expectation.Pass { distributionReport = Test.Distribution.NoDistribution }
+    Test.Expectation.Pass (Test.Distribution.NoDistribution ())
 
 
 {-| Fails with the given message.
@@ -617,7 +624,12 @@ pass =
 -}
 fail : String -> Expectation
 fail str =
-    Test.Expectation.fail { description = str, reason = Custom }
+    Test.Expectation.Fail
+        { given = Nothing
+        , distributionReport = Fuzz.Internal.noDistribution
+        , description = str
+        , reason = Custom
+        }
 
 
 {-| If the given expectation fails, replace its failure message with a custom one.
@@ -671,8 +683,10 @@ which argument is which:
 all : List (subject -> Expectation) -> subject -> Expectation
 all list query =
     if List.isEmpty list then
-        Test.Expectation.fail
-            { reason = Invalid EmptyList
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , reason = Invalid EmptyList
             , description = "Expect.all was given an empty list. You must make at least one expectation to have a valid test!"
             }
 
@@ -701,16 +715,18 @@ allHelp list query =
 
 reportCollectionFailure : String -> a -> b -> List c -> List d -> Expectation
 reportCollectionFailure comparison expected actual missingKeys extraKeys =
-    { description = comparison
-    , reason =
-        { expected = Internal.toString expected
-        , actual = Internal.toString actual
-        , extra = List.map Internal.toString extraKeys
-        , missing = List.map Internal.toString missingKeys
+    Test.Expectation.Fail
+        { given = Nothing
+        , distributionReport = Fuzz.Internal.noDistribution
+        , description = comparison
+        , reason =
+            { expected = Internal.toString expected
+            , actual = Internal.toString actual
+            , extra = List.map Internal.toString extraKeys
+            , missing = List.map Internal.toString missingKeys
+            }
+                |> CollectionDiff
         }
-            |> CollectionDiff
-    }
-        |> Test.Expectation.fail
 
 
 {-| String arg is label, e.g. "Expect.equal".
@@ -731,16 +747,13 @@ equateWith reason comparison b a =
 
         usesFloats =
             isFloat (Internal.toString a) || isFloat (Internal.toString b)
-
-        floatError =
-            if String.contains reason "not" then
-                "Do not use Expect.notEqual with floats. Use Expect.notWithin instead."
-
-            else
-                "Do not use Expect.equal with floats. Use Expect.within instead."
     in
     if usesFloats then
-        fail floatError
+        if String.contains reason "not" then
+            fail "Do not use Expect.notEqual with floats. Use Expect.notWithin instead."
+
+        else
+            fail "Do not use Expect.equal with floats. Use Expect.within instead."
 
     else
         testWith Equality reason comparison b a
@@ -757,10 +770,12 @@ testWith makeReason label runTest expected actual =
         pass
 
     else
-        { description = label
-        , reason = makeReason (Internal.toString expected) (Internal.toString actual)
-        }
-            |> Test.Expectation.fail
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , description = label
+            , reason = makeReason (Internal.toString expected) (Internal.toString actual)
+            }
 
 
 
@@ -796,26 +811,38 @@ relative tolerance =
 nonNegativeToleranceError : FloatingPointTolerance -> String -> Expectation -> Expectation
 nonNegativeToleranceError tolerance name result =
     if absolute tolerance < 0 && relative tolerance < 0 then
-        Test.Expectation.fail { description = "Expect." ++ name ++ " was given negative absolute and relative tolerances", reason = Custom }
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , description = "Expect." ++ name ++ " was given negative absolute and relative tolerances"
+            , reason = Custom
+            }
 
     else if absolute tolerance < 0 then
-        Test.Expectation.fail { description = "Expect." ++ name ++ " was given a negative absolute tolerance", reason = Custom }
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , description = "Expect." ++ name ++ " was given a negative absolute tolerance"
+            , reason = Custom
+            }
 
     else if relative tolerance < 0 then
-        Test.Expectation.fail { description = "Expect." ++ name ++ " was given a negative relative tolerance", reason = Custom }
+        Test.Expectation.Fail
+            { given = Nothing
+            , distributionReport = Fuzz.Internal.noDistribution
+            , description = "Expect." ++ name ++ " was given a negative relative tolerance"
+            , reason = Custom
+            }
 
     else
         result
 
 
 withinCompare : FloatingPointTolerance -> Float -> Float -> Bool
 withinCompare tolerance a b =
-    let
-        withinAbsoluteTolerance =
-            a - absolute tolerance <= b && b <= a + absolute tolerance
-
-        withinRelativeTolerance =
-            (a - abs (a * relative tolerance) <= b && b <= a + abs (a * relative tolerance))
-                || (b - abs (b * relative tolerance) <= a && a <= b + abs (b * relative tolerance))
-    in
-    (a == b) || withinAbsoluteTolerance || withinRelativeTolerance
+    (a == b)
+        -- within absolute tolerance
+        || (a - absolute tolerance <= b && b <= a + absolute tolerance)
+        -- within relative tolerance
+        || (a - abs (a * relative tolerance) <= b && b <= a + abs (a * relative tolerance))
+        || (b - abs (b * relative tolerance) <= a && a <= b + abs (b * relative tolerance))

src/Fuzz.elm

@@ -75,7 +75,6 @@ can usually find the simplest input that reproduces a bug.
 
 import Array exposing (Array)
 import Bitwise
-import Char
 import Dict exposing (Dict)
 import Fuzz.Float
 import Fuzz.Internal exposing (Fuzzer(..))
@@ -1145,15 +1144,14 @@ frequencyHelp functionName fuzzers =
                 intFrequency (List.map (Tuple.mapFirst round) nonzeroFuzzers)
 
             else
-                let
-                    weightSum : Float
-                    weightSum =
-                        List.foldl (\( w, _ ) acc -> w + acc) 0 nonzeroFuzzers
-                in
                 percentage
                     |> andThen
                         (\p ->
                             let
+                                weightSum : Float
+                                weightSum =
+                                    List.foldl (\( w, _ ) acc -> w + acc) 0 nonzeroFuzzers
+
                                 f : Float
                                 f =
                                     p * weightSum
@@ -1204,11 +1202,12 @@ intFrequency fuzzers =
                 rollDice (weightSum - 1) (intFrequencyGenerator n (List.map Tuple.first rest))
                     |> andThen
                         (\i ->
-                            fuzzers
-                                |> List.drop i
-                                |> List.head
-                                |> Maybe.map Tuple.second
-                                |> Maybe.withDefault (invalid "elm-test bug: intFrequency index out of range")
+                            case List.getAt i fuzzers of
+                                Just ( _, fuzzer ) ->
+                                    fuzzer
+
+                                Nothing ->
+                                    invalid "elm-test bug: intFrequency index out of range"
                         )
 
             [] ->
@@ -1621,7 +1620,7 @@ rollDice maxValue diceGenerator =
                             else
                                 Generated
                                     { value = hardcodedChoice
-                                    , prng = Hardcoded { h | unusedPart = restOfChoices }
+                                    , prng = Hardcoded { wholeRun = h.wholeRun, unusedPart = restOfChoices }
                                     }
 
 
@@ -1640,7 +1639,7 @@ forcedChoice n =
                     Random r ->
                         Generated
                             { value = n
-                            , prng = Random { r | run = RandomRun.append n r.run }
+                            , prng = Random { run = RandomRun.append n r.run, seed = r.seed }
                             }
 
                     Hardcoded h ->
@@ -1662,19 +1661,15 @@ forcedChoice n =
                                 else
                                     Generated
                                         { value = n
-                                        , prng = Hardcoded { h | unusedPart = restOfChoices }
+                                        , prng = Hardcoded { wholeRun = h.wholeRun, unusedPart = restOfChoices }
                                         }
 
 
 {-| We could golf this to ((/=) 0) but this is perhaps more readable.
 -}
 intToBool : Int -> Bool
 intToBool n =
-    if n == 0 then
-        False
-
-    else
-        True
+    n /= 0
 
 
 weightedBoolGenerator : Float -> Random.Generator Int
@@ -1795,46 +1790,49 @@ labelExamples n labels fuzzer =
                                                         Nothing
                                                 )
                                 in
-                                if List.isEmpty categories then
+                                if List.isEmpty categories || Dict.member categories acc then
                                     acc
 
                                 else
-                                    acc
-                                        |> Dict.update categories
-                                            (\maybeExample ->
-                                                case maybeExample of
-                                                    Nothing ->
-                                                        Just item
-
-                                                    Just original ->
-                                                        Just original
-                                            )
+                                    Dict.insert categories item acc
                             )
                             Dict.empty
 
-                combinations : List ( List String, a )
+                combinations : List ( List String, Maybe a )
                 combinations =
-                    foundExamples
-                        |> Dict.filter (\k _ -> List.length k > 1)
-                        |> Dict.toList
+                    Dict.foldr
+                        (\label example l ->
+                            if List.hasMultipleItems label then
+                                ( label, Just example ) :: l
+
+                            else
+                                l
+                        )
+                        []
+                        foundExamples
             in
             List.filterMap
                 (\( label, _ ) ->
-                    case Dict.get [ label ] foundExamples of
+                    let
+                        thisLabel : List String
+                        thisLabel =
+                            [ label ]
+                    in
+                    case Dict.get thisLabel foundExamples of
                         Nothing ->
                             if Dict.any (\k _ -> List.member label k) foundExamples then
-                                -- don't show this example: all its occurences were included in combination with some other label
+                                -- don't show this example: all its occurrences were included in combination with some other label
                                 Nothing
 
                             else
                                 -- show that we didn't find it (in any combination nor alone)
-                                Just ( [ label ], Nothing )
+                                Just ( thisLabel, Nothing )
 
-                        Just example ->
-                            Just ( [ label ], Just example )
+                        (Just _) as justExample ->
+                            Just ( thisLabel, justExample )
                 )
                 labels
-                ++ List.map (\( label, example ) -> ( label, Just example )) combinations
+                ++ combinations
 
         Rejected _ ->
             []

src/Fuzz/Internal.elm

@@ -1,11 +1,12 @@
-module Fuzz.Internal exposing (Fuzzer(..), generate)
+module Fuzz.Internal exposing (Fuzzer(..), generate, noDistribution)
 
 {-| This module is here just to hide the `generate` function from the end users
 of the library.
 -}
 
 import GenResult exposing (GenResult)
 import PRNG exposing (PRNG)
+import Test.Distribution exposing (DistributionReport)
 
 
 type Fuzzer a
@@ -15,3 +16,8 @@ type Fuzzer a
 generate : PRNG -> Fuzzer a -> GenResult a
 generate prng (Fuzzer fuzzer) =
     fuzzer prng
+
+
+noDistribution : DistributionReport
+noDistribution =
+    Test.Distribution.NoDistribution ()