Search results

map :: forall a b f. Functor f => (a -> b) -> f a -> f b
P purescript-prelude M Data.Functor

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

P purescript-maps M Data.Map
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 a b m r. Monad m => (a -> b) -> Pipe a b m r

Apply a function to all values flowing downstream

P purescript-pipes M Pipes.Prelude
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 e. Markup e -> Markup e
P purescript-smolder M Text.Smolder.HTML
map :: forall p i. Node HTMLmap p i
P purescript-halogen M Halogen.HTML.Elements
map :: Selector
P purescript-css M CSS.Elements
map :: (Octet -> Octet) -> ByteString -> ByteString

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

P purescript-bytestrings M Data.ByteString
map :: forall a e. (ReactElement -> a) -> ReactWrapper -> Eff (enzyme :: ENZYME | e) (Array a)
P purescript-enzyme M Enzyme.ReactWrapper
map :: forall a e. (ReactElement -> a) -> ShallowWrapper -> Eff (enzyme :: ENZYME | e) (Array a)
P purescript-enzyme M Enzyme.ShallowWrapper
map :: forall t. Corecursive t EJsonF => Map t t -> t
P purescript-ejson M Data.Json.Extended
Map :: forall a. (EJsonMap a) -> EJsonF a
P purescript-ejson M Data.Json.Extended.Signature.Core
Map :: EJsonType
P purescript-ejson M Data.Json.Extended.Type

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

P purescript-codec-argonaut M Data.Codec.Argonaut.Common
map :: forall a b. (a -> b) -> List a -> List b
P purescript-lists-fast M Data.List.Fast
map :: forall r t. Lens' { map :: t | r } t
P purescript-mathbox M Mathbox.Lenses
map :: forall b c a. HasMap a => (b -> c) -> a b -> a c
P purescript-neon M Neon.Class.HasMap
map :: Free SpaceF Unit -> Free SpaceF Unit
P purescript-react-spaces M React.Spaces.DOM
map :: Free SpaceF Unit -> Free SpaceF Unit
P purescript-react-spaces M React.Spaces.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 :: WorldMap
P purescript-screeps-classy M Screeps.Game
map :: forall i. Node HTMLmap i
P purescript-spork M Spork.Html.Elements

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

P purescript-pipes M Pipes.Prelude
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 p i. Array (HTML p i) -> HTML p i
P purescript-halogen M Halogen.HTML.Elements
mapR :: forall t f u g. Recursive t f => Corecursive u g => (f t -> g u) -> t -> u
P purescript-matryoshka M Matryoshka.Util
map_ :: forall i m. Monad m => (CommandsT MapI m) ~> (CommandsT (map :: I | i) m)
P purescript-echarts M ECharts.Commands
P purescript-echarts M ECharts.Types.Phantom
map' :: forall t. Corecursive t EJsonF => StrMap t -> t
P purescript-ejson M Data.Json.Extended
map' :: forall a b eff. (a -> b) -> Signal (ref :: REF | eff) a -> Eff (ref :: REF | eff) (Signal (ref :: REF | eff) b)

Creates a new signal, relaying the next incoming values from the old to the new, after transformation.

P purescript-zeta M Signal
map_ :: forall t. Corecursive t (SqlF EJsonF) => Ord t => Map t t -> t
P purescript-sql-squared M SqlSquared.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
mapE :: forall eff b a builder. MappableBuilder builder a b eff => builder -> (b -> a) -> GenericMappedEmitterBuilder a b eff
P purescript-outwatch M OutWatch.Dom.EmitterBuilder
mapI :: forall i i' v. (i -> i') -> Result i v -> Result i' v
P purescript-jaws M Data.Validation.Jaws.Product
mapM :: forall m a b. Monad m => (a -> m b) -> StreamT m a -> StreamT m b
P purescript-monadic-streams M Data.Stream
mapP :: forall s a b. (a -> b) -> Parser s a -> Parser s b

A map that doesn't require passing the typeclass dictionary for Functor.

P purescript-simple-parser M Text.Parsing.Simple
mapS :: forall s a b. (a -> b) -> State s a -> State s b
P purescript-transformerless M Control.Monad.Transformerless.State
mapW :: forall w a b. (a -> b) -> Writer w a -> Writer w b
P purescript-transformerless M Control.Monad.Transformerless.Writer
mapM_ :: forall a m r. Monad m => (a -> m Unit) -> Consumer_ a m r

Consume all values using a monadic function

P purescript-pipes M Pipes.Prelude