Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. (.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property

    checkers Test.QuickCheck.Checkers

    Nondeterministic choice: p1 .&. p2 picks randomly one of p1 and p2 to test. If you test the property 100 times it makes 100 random choices.

  2. (.&.) :: (Enum a, Bits w) => T w a -> T w a -> T w a

    enumset Data.EnumBitSet

    No documentation available.

  3. (-&&-) :: Expr -> Expr -> Expr

    express Data.Express.Fixtures

    The function && lifted over the Expr type. 

    > pp -&&- qq
p && q :: Bool

    > false -&&- true
False && True :: Bool

    > evalBool $ false -&&- true
False

  4. (.&.) :: Bits a => a -> a -> a

    foundation Foundation.Bits

    Bitwise "and"

  5. (:&&) :: Prop -> Prop -> Prop

    ghc-typelits-presburger GHC.TypeLits.Presburger.Types

    No documentation available.

  6. (.&&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property

    massiv-test Test.Massiv.Utils

    Conjunction: p1 .&&. p2 passes if both p1 and p2 pass.

  7. (<&>) :: RecordFromSql q a -> RecordFromSql q b -> RecordFromSql q (a, b)

    persistable-record Database.Record.FromSql

    Derivation rule of RecordFromSql parser function object for Haskell tuple (,) type.

  8. (<&>) :: PersistableRecordWidth a -> PersistableRecordWidth b -> PersistableRecordWidth (a, b)

    persistable-record Database.Record.Persistable

    Derivation rule of PersistableRecordWidth for tuple (,) type.

  9. (<&>) :: RecordToSql q a -> RecordToSql q b -> RecordToSql q (a, b)

    persistable-record Database.Record.ToSql

    Derivation rule of RecordToSql printer function object for Haskell tuple (,) type.

  10. (?&.) :: EntityField record Value -> [Text] -> Filter record

    persistent-postgresql Database.Persist.Postgresql.JSON

    This operator takes a column and a list of strings to test whether ALL of the elements of the list are top level fields in an object. 

    column ?&. list
    N.B. An empty list will match anything. Also, this operator might have some unexpected interactions with non-object values. Please reference the examples.

    Objects

    {"a":null}                 ?& ["a"]         == True
{"a":null}                 ?& ["a","a"]     == True
{"test":false,"a":500}     ?& ["a"]         == True
{"test":false,"a":500}     ?& ["a","b"]     == False
{}                         ?& ["{}"]        == False
{"b":{"a":[]}}             ?& ["a"]         == False
{"b":{"a":[]},"c":false}   ?& ["a","c"]     == False
{"a":1,"b":2,"c":3,"d":4}  ?& ["b","d"]     == True
{}                         ?& []            == True
{"b":{"a":[]},"test":null} ?& []            == True

    Arrays

    This operator will match an array if all of the elements of the list are matching string elements of the array. 
    ["a"]                   ?& ["a"]         == True
["a"]                   ?& ["a","a"]     == True
[["a"]]                 ?& ["a"]         == False
["a","b","c"]           ?& ["a","b","d"] == False
[9,"false","1",null]    ?& ["1","false"] == True
[]                      ?& ["a","b"]     == False
[{"a":true}]            ?& ["a"]         == False
["a","b","c","d"]       ?& ["b","c","d"] == True
[null,4,{"test":false}] ?& []            == True
[]                      ?& []            == True

    Other values

    This operator functions much like an equivalence operator on strings only. If a string matches with all elements of the given list, the comparison matches. 
    "a"   ?& ["a"]     == True
"1"   ?& ["a","1"] == False
"b"   ?& ["b","b"] == True
"ab"  ?& ["a","b"] == False
1     ?& ["1"]     == False
null  ?& ["null"]  == False
true  ?& ["true"]  == False
31337 ?& []        == True
true  ?& []        == True
null  ?& []        == True

Page 34 of many | Previous | Next