Hoogle Search

Within LTS Haskell 24.22 (ghc-9.10.3)

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

Exact lookup

1. (?&.) :: 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
   

2. (<&&>) :: Selective f => f Bool -> f Bool -> f Bool

   rebase	Rebase.Prelude

   A lifted version of lazy Boolean AND.

3. (<&>) :: Functor f => f a -> (a -> b) -> f b

   rebase	Rebase.Prelude

   Flipped version of <$>.

   (<&>) = flip fmap
   

   Examples

   Apply (+1) to a list, a Just and a Right:

   >>> Just 2 <&> (+1)
   Just 3
   

   >>> [1,2,3] <&> (+1)
   [2,3,4]
   

   >>> Right 3 <&> (+1)
   Right 4
   

4. (<&>) :: Functor f => f a -> (a -> b) -> f b

   turtle	Turtle

   Flipped version of <$>.

   (<&>) = flip fmap
   

   Examples

   Apply (+1) to a list, a Just and a Right:

   >>> Just 2 <&> (+1)
   Just 3
   

   >>> [1,2,3] <&> (+1)
   [2,3,4]
   

   >>> Right 3 <&> (+1)
   Right 4
   

5. (.&&.) :: Monad m => m ExitCode -> m ExitCode -> m ExitCode

   turtle	Turtle.Prelude

   Analogous to && in Bash Runs the second command only if the first one returns ExitSuccess

6. (<&>) :: Functor f => f a -> (a -> b) -> f b

   base-prelude	BasePrelude

   Flipped version of <$>.

   (<&>) = flip fmap
   

   Examples

   Apply (+1) to a list, a Just and a Right:

   >>> Just 2 <&> (+1)
   Just 3
   

   >>> [1,2,3] <&> (+1)
   [2,3,4]
   

   >>> Right 3 <&> (+1)
   Right 4
   

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

   base-prelude	BasePrelude.Operators

   Bitwise "and"

8. (<&>) :: Functor f => f a -> (a -> b) -> f b

   base-prelude	BasePrelude.Operators

   Flipped version of <$>.

   (<&>) = flip fmap
   

   Examples

   Apply (+1) to a list, a Just and a Right:

   >>> Just 2 <&> (+1)
   Just 3
   

   >>> [1,2,3] <&> (+1)
   [2,3,4]
   

   >>> Right 3 <&> (+1)
   Right 4
   

9. (<&>) :: Functor f => f a -> (a -> b) -> f b

   hledger	Hledger.Cli.Script

   Flipped version of <$>.

   (<&>) = flip fmap
   

   Examples

   Apply (+1) to a list, a Just and a Right:

   >>> Just 2 <&> (+1)
   Just 3
   

   >>> [1,2,3] <&> (+1)
   [2,3,4]
   

   >>> Right 3 <&> (+1)
   Right 4
   

10. (:&:) :: forall t (ts1 :: [Type]) . !t -> !HVect ts1 -> HVect (t ': ts1)

    hvect	Data.HVect

    No documentation available.

Page 35 of many | Previous | Next