Search results

map :: forall a b f. Functor f => (a -> b) -> f a -> f b

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

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 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 :: forall e. Markup e -> Markup e

map :: forall p i. Node HTMLmap p i

map :: Selector

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

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

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 a b f. ((a -> b) -> f a -> f b) -> (a -> b) -> NonEmpty f a -> NonEmpty f b

map :: forall a b p. Ord b => Semiring p => (a -> b) -> Dist p a -> Dist p b

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

Map :: forall a. (EJsonMap a) -> EJsonF a

Map :: EJsonType

map :: forall a b da db. Patch a da => Patch b db => (Jet a -> Jet b) -> Jet (IArray a) -> Jet (IArray b)

Modify each array element by applying the specified function.

map :: forall a b. (a -> b) -> Jet (Atomic a) -> Jet (Atomic b)

Change an Atomic value using a regular function.

map :: forall k a da b db. Ord k => Patch a da => Patch b db => (Jet a -> Jet b) -> Jet (IMap k a) -> Jet (IMap k b)

Update every key by applying a function.

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 :: 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 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 :: El

map :: forall a b. (a -> b) -> List a -> List b

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

map :: forall b c a. HasMap a => (b -> c) -> a b -> a c

map :: forall msg. Array (Attribute msg) -> Array (Html msg) -> Html msg

map :: StaticElement

map :: forall attrs attrs_. Union attrs attrs_ (SharedProps Props_map) => {  | attrs } -> JSX

map :: Free SpaceF Unit -> Free SpaceF Unit

map :: Free SpaceF Unit -> Free SpaceF Unit

map :: forall eff st. Array (Props eff st) -> Array (Component eff st) -> Component eff st

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

Adapts incoming values.

map :: WorldMap

map :: forall channel context i o. Array (Attr context i) -> Array (Handler context (Either channel (i -> o))) -> Array (SDOM channel context i o) -> SDOM channel context i o

map :: forall a b. (a -> b) -> SortedArray a -> Array b

Functor-like convenience function, equivalent to unwrapping and applying the Array map.

map :: forall i. Node HTMLmap i

map :: forall a b. Ord b => (a -> b) -> List a -> Either (Set b) (List b)

Purely functional maps implemented in PureScript

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

Apply a monadic function to all values flowing downstream

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 p i. Array (HTML p i) -> HTML p i

mapR :: forall t f u g. Recursive t f => Corecursive u g => (f t -> g u) -> t -> u