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 a. ReactWrapper -> (ReactElement -> a) -> Array a
P purescript-enzyme M Enzyme.ReactWrapper
map :: forall a. ShallowWrapper -> (ReactElement -> a) -> Array a
P purescript-enzyme M Enzyme.ShallowWrapper
map :: forall p i. Node HTMLmap p i
P purescript-halogen M Halogen.HTML.Elements

A map object (http://leafletjs.com/reference-1.0.3.html#map-example)

P purescript-leaflet-tdammers M Leaflet.Map
map :: forall e. String -> LatLng -> Zoom -> Eff (leaflet :: LEAFLET | e) Map

map domID latLng zoom creates a new map object centered at latLng, at zoom level zoom, and attaches it to the DOM element with ID domID.

P purescript-leaflet-tdammers M Leaflet.Map

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
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 r i o a. (i -> o) -> Run (Transformer i o r) a

Adapts incoming values.

P purescript-run-streaming M Run.Streaming.Prelude
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 SqlSquared.Constructors
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
mapChars :: (String -> String) -> 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. This function uses Strings instead of Chars because PureScript Chars must be UTF-16 code units and hence cannot represent all Unicode code points.

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
mapDisplayName :: forall props. (String -> String) -> ReactClass props -> ReactClass props
P purescript-react-hocs M ReactHocs.DisplayName
P purescript-outwatch M OutWatch.Dom.EmitterBuilder
mapEffects :: forall a b st fx. (a -> b) -> EffModel st a fx -> EffModel st b fx

Map over the effects of an EffModel.

P purescript-pux M Pux
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
mapEvent :: forall a b. (a -> b) -> HTML a -> HTML b

Map HTML with event type a to HTML with event type b.

It's important that memoize is only used at a top-level declaration – not inside a view. This is because PureScript is eagerly evaluated like JavaScript. If memoize is used inside a view it will recreate the memoized function every time the view is called.

P purescript-pux M Pux.DOM.HTML
mapEventHandler :: forall a b. (a -> b) -> EventHandler (DOMEvent -> a) -> EventHandler (DOMEvent -> b)

Map event handler that returns event type a to event handler that returns event type b.

P purescript-pux M Pux.DOM.Events
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
P purescript-echarts M ECharts.Types.Phantom
mapMaybe :: forall a b. (a -> Maybe b) -> Array a -> Array b

Apply a function to each element in an array, keeping only the results which contain a value, creating a new array.

P purescript-arrays M Data.Array
mapMaybe :: forall a b. (a -> Maybe b) -> Event a -> Event b

Filter out any Nothing events.

P purescript-behaviors M FRP.Event
mapMaybe :: forall a b. (a -> Maybe b) -> List a -> List b

Apply a function to each element in a list, keeping only the results which contain a value.

Running time: O(n)

P purescript-lists M Data.List
mapMaybe :: forall a b. (a -> Maybe b) -> List a -> List b

Apply a function to each element in a list, keeping only the results which contain a value.

Running time: O(n)

P purescript-lists M Data.List.Lazy
mapMaybe :: forall f a b. Functor f => (a -> Maybe b) -> ListT f a -> ListT f b

Apply a function to the elements of a list, keeping only those return values which contain a result.

P purescript-transformers M Control.Monad.List.Trans
mapMaybeT :: forall m1 m2 a b. (m1 (Maybe a) -> m2 (Maybe b)) -> MaybeT m1 a -> MaybeT m2 b

Change the result type of a MaybeT monad action.

P purescript-transformers M Control.Monad.Maybe.Trans