Search results

map :: (Octet -> Octet) -> ByteString -> ByteString

Θ(n) Transform the bytes in the byte string.

P purescript-bytestrings M Data.ByteString
map :: Selector
P purescript-css M CSS.Elements
map :: forall t. Corecursive t EJsonF => Map t t -> t
P purescript-ejson M Data.Json.Extended
P purescript-ejson M Data.Json.Extended.Signature.Core
P purescript-ejson M Data.Json.Extended.Type
map :: forall p i. Node HTMLmap p i
P purescript-halogen M Halogen.HTML.Elements

Map k v represents maps from keys of type k to values of type v.

P purescript-maps M Data.Map
map :: forall r t. Lens' { map :: t | r } t
P purescript-mathbox M Mathbox.Lenses
map :: forall a b. (a -> b) -> Array a -> Array b

Create a new Array by applying a function to the elements of another Array.

P purescript-preface M Array
P purescript-prelude M Data.Functor
map :: Array Props -> Array ReactElement -> ReactElement
P purescript-react M React.DOM
map :: Array Props -> Array ReactElement -> ReactElement
P purescript-react M React.DOM.Dynamic
map :: forall a b. (a -> b) -> Seq a -> Seq b

O(n). Apply a function to every element within a sequence. Note that this function is performed lazily — the actual call is almost instantaneous, regardless of the length of the sequence, because the function is not applied to all elements immediately. The eventual running time (assuming all elements are later requested) is O(n), though.

P purescript-sequences M Data.Sequence
map :: forall a b. Ord b => (a -> b) -> Set a -> Set b

Maps over the values in a set.

This operation is not structure-preserving for sets, so is not a valid Functor. An example case: mapping const x over a set with n > 0 elements will result in a set with one element.

P purescript-sets M Data.Set
map :: forall e. Markup e -> Markup e
P purescript-smolder M Text.Smolder.HTML
map' :: forall t. Corecursive t EJsonF => StrMap t -> t
P purescript-ejson M Data.Json.Extended
map' :: Array ReactElement -> ReactElement
P purescript-react M React.DOM
map' :: Array ReactElement -> ReactElement
P purescript-react M React.DOM.Dynamic
map2 :: forall a b c. (a -> b -> c) -> Signal a -> Signal b -> Signal c
P purescript-signal M Signal
map3 :: forall a b c d. (a -> b -> c -> d) -> Signal a -> Signal b -> Signal c -> Signal d
P purescript-signal M Signal
map4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e
P purescript-signal M Signal
map5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f
P purescript-signal M Signal
map_ :: forall i. DSL MapI -> DSL (map :: I | i)
P purescript-echarts M ECharts.Commands
map_ :: forall p i. Array (HTML p i) -> HTML p i
P purescript-halogen M Halogen.HTML.Elements
map_ :: forall t. (Corecursive t (SqlF EJsonF), Ord t) => Map t t -> t
P purescript-sqlsquare M SqlSquare.Constructors
map_ :: forall r w s a b. (a -> b) -> RWS r w s a -> RWS r w s b
P purescript-transformerless M Control.Monad.Transformerless.RWS
mapAccumL :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

Fold a data structure from the left, keeping all intermediate results instead of only the final result.

Unlike scanl, mapAccumL allows the type of accumulator to differ from the element type of the final data structure.

P purescript-foldable-traversable M Data.Traversable
mapAccumR :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

Fold a data structure from the right, keeping all intermediate results instead of only the final result.

Unlike scanr, mapAccumR allows the type of accumulator to differ from the element type of the final data structure.

P purescript-foldable-traversable M Data.Traversable
mapAttribute :: forall a b. (a -> b) -> Prop a -> Prop b
P purescript-rnx M RNX.Components
mapBound :: forall a b c f. Functor f => (b -> c) -> Scope b f a -> Scope c f a
P purescript-bound M Bound

A change for a single key is an addition, removal, or update.

P purescript-incremental M Data.Incremental.Map

A change for each possible key.

P purescript-incremental M Data.Incremental.Map
P purescript-incremental M Data.Incremental.Map
mapChars :: (Char -> Char) -> String -> String

Return the string obtained by applying the mapping function to each character (i.e. Unicode code point) of the input string. Note that this is probably not what you want as Unicode code points are not necessarily the same as user-perceived characters (grapheme clusters). Only use this function if you know what you are doing.

Example:

-- Mapping over what appears to be six characters...
mapChars (const 'x') "Åström" == "xxxxxxxx" -- See? Don't use this!
P purescript-stringutils M Data.String.Utils
mapContT :: forall r m a. (m r -> m r) -> ContT r m a -> ContT r m a

Modify the underlying action in a ContT monad action.

P purescript-transformers M Control.Monad.Cont.Trans
P purescript-outwatch M EmitterBuilder
mapEF :: forall f a b. Functor f => (a ==> b) -> ((f a) ==> (f b))

Like map, but you provide an EqFunc, and you get an EqFunc back, which has been lifted to operate over the Functor f.

times2 :: Int ==> Int
times2 = eqFunc2 (*) ~ 2

mapEF times2 ~ [1, 2, 3] == [2, 4, 6]

mapEF times2 == mapEF times2 :: Array Int ==> Array Int
P purescript-equatable-functions M Data.Function.Equatable
mapEffects :: forall s a b e. (a -> b) -> EffModel s a e -> EffModel s b e

Map over the effectful actions of an EffModel.

P purescript-rnx M RNX
mapElem :: forall f a. Functor f => f a -> f (Elem a)
P purescript-sequences M Data.Sequence.Internal
mapEnv :: forall e a b. (a -> b) -> Env e a -> Env e b

Change the data type in an Env computation.

P purescript-transformers M Control.Comonad.Env
mapEnvT :: forall e m1 m2 a b. (m1 a -> m2 b) -> CoEnvT e m1 a -> CoEnvT e m2 b
P purescript-matryoshka M Matryoshka.Pattern.CoEnvT
mapEnvT :: forall e w1 w2 a b. (w1 a -> w2 b) -> EnvT e w1 a -> EnvT e w2 b

Change the underlying comonad and data type in an EnvT context.

P purescript-transformers M Control.Comonad.Env.Trans
mapExcept :: forall e e' a b. (Either e a -> Either e' b) -> Except e a -> Except e' b

Transform the unwrapped computation using the given function.

P purescript-transformers M Control.Monad.Except
mapExceptT :: forall e e' m n a b. (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

Transform the unwrapped computation using the given function.

P purescript-transformers M Control.Monad.Except.Trans
mapFlipped :: forall f a b. Functor f => f a -> (a -> b) -> f b

mapFlipped is map with its arguments reversed. For example:

[1, 2, 3] <#> \n -> n * n
P purescript-prelude M Data.Functor
mapGetElem :: forall f a. Functor f => f (Elem a) -> f a
P purescript-sequences M Data.Sequence.Internal
P purescript-echarts M ECharts.Types.Phantom
mapIsotype :: forall i a b. Isotype i -> (a -> b) -> i a -> i b

Functor.map for an Isotype

P purescript-isotypes M Data.Isotype.Instance
mapLeft :: forall r a b. (a -> b) -> Either a r -> Either b r

Change values constructed using Left by applying a function.

P purescript-preface M Either
mapmap :: forall f g a b. (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
P purescript-sequences M Data.Sequence.Internal