== -package:hedgehog -package:quaalude -package:diagrams-lib

A type family to compute Boolean equality.

Compare two streams point-wise for equality. The output stream contains the value True at a point in time if both argument streams contain the same value at that point in time.

An infix alias for Equals.

Equality constraint, used as e.g. (x == 3) => _

Like ==, but prints a counterexample when it fails.

Implication for properties: The resulting property holds if the first argument is False (in which case the test case is discarded), or if the given property holds. Note that using implication carelessly can severely skew test case distribution: consider using cover to make sure that your test data is still good quality.

Check for equality.

Examples

selectSPJ :: MonadIO m => ReaderT SqlBackend m [Entity User]
selectSPJ = selectList [UserName ==. "SPJ" ] []

The above query when applied on dataset-1, will produce this:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+

vertical concatenation

The ==> operator can be used to express a restricting condition under which a property should hold. It corresponds to implication in the classical logic. Note that ==> resets the quantification context for its operands to the default (universal).

The ==> operator can be used to express a restricting condition under which a property should hold. It corresponds to implication in the classical logic. Note that ==> resets the quantification context for its operands to the default (universal).

Convenience helper. Uses pure to lift a into f a.

An exact equality comparison. For real IEEE types, two values are equivalent in the following cases:

• both values are +0;
• both values are -0;
• both values are nonzero and equal to each other (according to ==);
• both values are NaN with the same payload and sign.

For complex IEEE types, two values are equivalent if their real and imaginary parts are equivalent.

This operator produces the SQL operator =, which is used to compare values for equality. Example:

query :: UserId -> SqlPersistT IO [Entity User]
query userId = select $ do
user <- from $ table @User
where_ (user ^. UserId ==. val userId)
pure user

This would generate the following SQL:

SELECT user.*
FROM user
WHERE user.id = ?

Declare two functions to be equal, but ignoring type lambdas, type arguments, type casts and hpc ticks (see EqualTo). Note that -fhpc can prevent some optimizations; build without for more reliable analysis.