Search results

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

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

map :: forall a b. Ord a => JsonCodec a -> JsonCodec b -> JsonCodec (Map a b)

A codec for Map values.

Encodes as an array of two-element key/value arrays in JSON.

map :: Selector

map :: forall t. Corecursive t EJsonF => Map t t -> t

map :: forall a e. (ReactElement -> a) -> ReactWrapper -> Eff (enzyme :: ENZYME | e) (Array a)

map :: forall a e. (ReactElement -> a) -> ShallowWrapper -> Eff (enzyme :: ENZYME | e) (Array a)

map :: forall p i. Node HTMLmap p i

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

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.

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

map :: forall r t. Lens' { map :: t | r } t

map :: forall a b m r. Monad m => (a -> b) -> Pipe a b m r

Apply a function to all values flowing downstream

map :: Array Props -> Array ReactElement -> ReactElement

map :: Array Props -> Array ReactElement -> ReactElement

map :: Free SpaceF Unit -> Free SpaceF Unit

map :: Free SpaceF Unit -> Free SpaceF Unit

map :: forall r i o a. (i -> o) -> Run (Transformer i o r) a

Adapts incoming values.

map :: WorldMap

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.

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.

map :: forall e. Markup e -> Markup e

map' :: forall t. Corecursive t EJsonF => StrMap t -> t

map' :: Array ReactElement -> ReactElement

map' :: Array ReactElement -> ReactElement

map2 :: forall a b c. (a -> b -> c) -> Signal a -> Signal b -> Signal c

map3 :: forall a b c d. (a -> b -> c -> d) -> Signal a -> Signal b -> Signal c -> Signal d

map4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e

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

map_ :: forall i. DSL MapI -> DSL (map :: I | i)

map_ :: forall p i. Array (HTML p i) -> HTML p i

map_ :: forall t. Corecursive t (SqlF EJsonF) => Ord t => Map t t -> t

map_ :: forall r w s a b. (a -> b) -> RWS r w s a -> RWS r w s b

mapAccum :: forall event a b c. IsEvent event => (a -> b -> Tuple b c) -> event a -> b -> event c

Map over an event with an accumulator.

For example, to keep the index of the current event:

mapAccum (\x i -> Tuple (i + 1) (Tuple x i)) 0`.

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.

mapAccumLWithIndex :: forall i a b s f. TraversableWithIndex i f => (i -> s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

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

Unlike scanlWithIndex, mapAccumLWithIndex allows the type of accumulator to differ from the element type of the final data structure.

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.

mapAccumRWithIndex :: forall i a b s f. TraversableWithIndex i f => (i -> s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

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

Unlike scanrWithIndex, imapAccumRWithIndex allows the type of accumulator to differ from the element type of the final data structure.

mapBound :: forall a b c f. Functor f => (b -> c) -> Scope b f a -> Scope c f a

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

A change for each possible key.

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!

mapCodec :: forall m a b c d. Bind m => (a -> m b) -> (b -> a) -> Codec m c d a a -> Codec m c d b b

mapComponentHTMLQuery :: forall f f'. (f ~> f') -> ComponentHTML f -> ComponentHTML f'

mapCont :: forall r a. (r -> r) -> Cont r a -> Cont r a

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.

Newtype helper for mapDispatchToProps