Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

Exact lookup

1. (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()

   diagrams-lib	Diagrams.Prelude

   Modify the target(s) of a Lens', Iso, Setter or Traversal by taking their logical && with a value.

   >>> execState (do _1 &&= True; _2 &&= False; _3 &&= True; _4 &&= False) (True,True,False,False)
   (True,False,False,False)
   

   (&&=) :: MonadState s m => Setter' s Bool    -> Bool -> m ()
   (&&=) :: MonadState s m => Iso' s Bool       -> Bool -> m ()
   (&&=) :: MonadState s m => Lens' s Bool      -> Bool -> m ()
   (&&=) :: MonadState s m => Traversal' s Bool -> Bool -> m ()
   

2. (&&~) :: ASetter s t Bool Bool -> Bool -> s -> t

   diagrams-lib	Diagrams.Prelude

   Logically && the target(s) of a Bool-valued Lens or Setter.

   >>> both &&~ True $ (False, True)
   (False,True)
   

   >>> both &&~ False $ (False, True)
   (False,False)
   

   (&&~) :: Setter' s Bool    -> Bool -> s -> s
   (&&~) :: Iso' s Bool       -> Bool -> s -> s
   (&&~) :: Lens' s Bool      -> Bool -> s -> s
   (&&~) :: Traversal' s Bool -> Bool -> s -> s
   

3. (&~) :: s -> State s a -> s

   diagrams-lib	Diagrams.Prelude

   This can be used to chain lens operations using op= syntax rather than op~ syntax for simple non-type-changing cases.

   >>> (10,20) & _1 .~ 30 & _2 .~ 40
   (30,40)
   

   >>> (10,20) &~ do _1 .= 30; _2 .= 40
   (30,40)
   

   This does not support type-changing assignment, e.g.

   >>> (10,20) & _1 .~ "hello"
   ("hello",20)
   

4. (&&) :: Bool -> Bool -> Bool

   Cabal-syntax	Distribution.Compat.Prelude

   No documentation available.

5. (&===) :: (Block blockA, Block blockB, C heightA, C heightB, C width, Eq width, Storable a) => blockA (heightA, width) a -> blockB (heightB, width) a -> BlockMatrix (heightA ::+ heightB) width a

   comfort-array	Data.Array.Comfort.Storable.Dim2

   No documentation available.

6. (&|||) :: (Block blockA, Block blockB, C height, Eq height, C widthA, C widthB, Storable a) => blockA (height, widthA) a -> blockB (height, widthB) a -> BlockMatrix height (widthA ::+ widthB) a

   comfort-array	Data.Array.Comfort.Storable.Dim2

   No documentation available.

7. (&&&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool

   leancheck	Test.LeanCheck.Utils.Operators

   And (&&) operator over one-argument properties. Allows building conjuntions between one-argument properties:

   > holds 100 $ id === (+0) &&& id === (id . id)
   True
   

8. (&&&&) :: (a -> b -> Bool) -> (a -> b -> Bool) -> a -> b -> Bool

   leancheck	Test.LeanCheck.Utils.Operators

   And (&&) operator over two-argument properties. Allows building conjuntions between two-argument properties:

   > holds 100 $ (+) ==== flip (+) &&&& (+) ==== (*)
   False
   

9. (&&&&&) :: (a -> b -> c -> Bool) -> (a -> b -> c -> Bool) -> a -> b -> c -> Bool

   leancheck	Test.LeanCheck.Utils.Operators

   And operator over three-argument properties.

10. (&&^) :: Monad m => m Bool -> m Bool -> m Bool

    relude	Relude.Bool.Guard

    Monadic version of (&&) operator. It is lazy by the second argument (similar to (||)), meaning that if the first argument is False, the function will return False without evaluating the second argument.

    >>> Just False &&^ Just True
    Just False
    
    >>> Just True &&^ Just True
    Just True
    
    >>> Just True &&^ Nothing
    Nothing
    
    >>> Just False &&^ Nothing
    Just False
    
    >>> Just False &&^ error "Shouldn't be evaluated"
    Just False
    

Page 9 of many | Previous | Next