Hoogle Search

Within LTS Haskell 24.15 (ghc-9.10.3)

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

Exact lookup

1. map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b

   fixed-vector	Data.Vector.Fixed

   Map over vector

2. map :: forall (n :: PeanoNum) a b . ArityPeano n => (a -> b) -> ContVec n a -> ContVec n b

   fixed-vector	Data.Vector.Fixed.Cont

   Map over vector. Synonym for fmap

3. map :: Ord b => (a -> b) -> Heap a -> Heap b

   heaps	Data.Heap

   O(n). Map a function over the heap, returning a new heap ordered appropriately for its fresh contents

   >>> map negate (fromList [3,1,2])
   fromList [-3,-1,-2]
   

4. map :: (a -> b) -> [a] -> [b]

   mixed-types-num	Numeric.MixedTypes.PreludeHiding

   map f xs is the list obtained by applying f to each element of xs, i.e.,

   map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
   map f [x1, x2, ...] == [f x1, f x2, ...]
   

   this means that map id == id

   Examples

   >>> map (+1) [1, 2, 3]
   [2,3,4]
   

   >>> map id [1, 2, 3]
   [1,2,3]
   

   >>> map (\n -> 3 * n + 1) [1, 2, 3]
   [4,7,10]
   

5. map :: MonoidNull v2 => (v1 -> v2) -> MonoidMap k v1 -> MonoidMap k v2

   monoidmap	Data.MonoidMap

   Applies a function to all non-null values of a MonoidMap. Satisfies the following properties for all functions f:

   (get k m == mempty) ==> (get k (map f m) == mempty     )
   (get k m /= mempty) ==> (get k (map f m) == f (get k m))
   

   Conditional properties

   If applying function f to mempty produces mempty, then the following additional properties hold:

   (f mempty == mempty)
   ==>
   (∀ k. get k (map f m) == f (get k m))
   

   (f mempty == mempty)
   ==>
   (∀ g. map (f . g) m == map f (map g m))
   

6. map :: (a -> b) -> NonEmptyVector a -> NonEmptyVector b

   nonempty-vector	Data.Vector.NonEmpty

   O(n) Map a function over a non-empty vector.

   >>> map (+1) $ unsafeFromList [1..3]
   [2,3,4]
   

7. map :: (Shape sh, Source r a) => (a -> b) -> Array r sh a -> Array D sh b

   repa	Data.Array.Repa

   Apply a worker function to each element of an array, yielding a new array with the same extent.

8. map :: (Shape sh, Source r a) => (a -> b) -> Array r sh a -> Array D sh b

   repa	Data.Array.Repa.Operators.Mapping

   Apply a worker function to each element of an array, yielding a new array with the same extent.

9. map :: Ord b => (a -> b) -> SortedList a -> SortedList b

   sorted-list	Data.SortedList

   Map a function over all the elements of a sorted list. Note that map will hang if the argument is an infinite list. Even though SortedList can't be made an instance of Functor, map does hold the Functor laws (for finite lists). We can't however write an instance because of the Ord instance requirement on the type of the elements of the result list. Therefore, while SortedList is not a functor type in general, it is when restricted to elements of orderable types (for finite lists). The complexity range goes from O(n) (if the function is monotonically increasing) to O(n²) (if the function is monotonically decreasing). These are the best and worst case scenarios. We provide an alternative (mapDec) where monotonically decreasing functions are the best case scenario.

10. map :: Primitive amp => (y0 -> y1) -> T rate amp (T y0) -> T rate amp (T y1)

    synthesizer-dimensional	Synthesizer.Dimensional.Amplitude.Displacement

    No documentation available.

Page 21 of many | Previous | Next