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-ordered-collections M Data.Map.Internal
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-ordered-collections M Data.Set
map :: forall a b. Ord b => (a -> b) -> NonEmptySet a -> NonEmptySet 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-ordered-collections M Data.Set.NonEmpty

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 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 :: 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 :: 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 attrs attrs_. Union attrs attrs_ (SharedProps Props_map) => {  | attrs } -> JSX
P purescript-react-basic M React.Basic.DOM.Generated
map :: forall a b f. ((a -> b) -> f a -> f b) -> (a -> b) -> NonEmpty f a -> NonEmpty f b
P purescript-probability M Data.NonEmpty.Extras
map :: forall a b p. Ord b => Semiring p => (a -> b) -> Dist p a -> Dist p b
P purescript-probability M Math.Probability
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
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.

P purescript-incremental-functions M Data.Incremental.Array
map :: forall a b. (a -> b) -> Jet (Atomic a) -> Jet (Atomic b)

Change an Atomic value using a regular function.

P purescript-incremental-functions M Data.Incremental.Eq
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.

P purescript-incremental-functions M Data.Incremental.Map

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 f. IsoFunctor f => Iso a b -> f a -> f b
P purescript-partial-isomorphisms M Control.Isomorphism.Partial
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. Hashable b => (a -> b) -> HashSet a -> HashSet b

Construct a new set by applying a function to each element of an input set.

If distinct inputs map to the same output, this changes the cardinality of the set, therefore hash set is not a Functor. Also, the order in which elements appear in the new set is entirely dependent on the hash function for type b.

P purescript-unordered-collections M Data.HashSet
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) -> GunChainCtx -> GunChainCtx

Map iterates over each property and item on a node, passing it down the chain, transforming the data with the given function. It also subscribes to every item as well and listens for newly inserted items.

P purescript-gun M Gun
map :: forall a b. (a -> b) -> List a -> List b
P purescript-lists-fast M Data.List.Fast
map :: Icons
P purescript-materialize M Materialize.Icons.Data
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 :: forall msg. Array (Attribute msg) -> Array (Html msg) -> Html msg
P purescript-oak M Oak.Html
map :: P5 -> Number -> Number -> Number -> Number -> Number -> (Maybe Boolean) -> Number

p5js.org documentation

P purescript-p5 M P5.Math.Calculation
map :: StaticElement
P purescript-panda M Panda.HTML.Elements
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 eff st. Array (Props eff st) -> Array (Component eff st) -> Component eff st
P purescript-refract M Refract.DOM
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 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
P purescript-sdom M SDOM.Elements
map :: forall a b. (a -> b) -> SortedArray a -> Array b

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

P purescript-sorted-arrays M Data.SortedArray
map :: forall i. Node HTMLmap i
P purescript-spork M Spork.Html.Elements
P purescript-typelevel-eval M Type.Eval.Functor
map :: forall a b. Ord b => (a -> b) -> List a -> Either (Set b) (List b)
P purescript-unique-lists M Data.List.Unique
map_ :: forall r a b. (a -> b) -> ST r a -> ST r b
P purescript-st M Control.Monad.ST.Internal

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
map_ :: Array JSX -> JSX
P purescript-react-basic M React.Basic.DOM.Generated
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 rw. (a -> b) -> Signal (read :: READ | rw) a -> Effect (Signal (read :: READ, write :: WRITE) b)

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

P purescript-zeta M Signal.Compat
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
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
map' :: Element
P purescript-panda M Panda.HTML.Elements
map' :: forall eff st. Array (Component eff st) -> Component eff st
P purescript-refract M Refract.DOM
map_ :: StaticElementWithoutProperties
P purescript-panda M Panda.HTML.Elements
map_ :: forall channel context i o. Array (SDOM channel context i o) -> SDOM channel context i o
P purescript-sdom M SDOM.Elements
map_ :: forall t. Corecursive t (SqlF EJsonF) => Ord t => Map t t -> t
P purescript-sql-squared M SqlSquared.Constructors
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
P purescript-record-fold M Data.Record.Fold
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
mapTo :: forall a b f. Functor f => b -> ObservableT f a -> ObservableT f b

Emits the given constant value on the output Observable every time the source Observable emits a value. marble diagram

P purescript-rxps M RxJS.Observable
mapTo :: forall a b. b -> Stream a -> Stream b
P purescript-xstream M Control.XStream
map'_ :: ElementWithoutProperties
P purescript-panda M Panda.HTML.Elements
P purescript-nemo M Nemo.Types
mapTo :: forall a b f. Functor f => b -> ObservableT f a -> ObservableT f b

Emits the given constant value on the output Observable every time the source Observable emits a value. marble diagram

P purescript-rx-observable M RxJS.Observable
mapTo :: forall a b. b -> AsyncSubject a -> AsyncSubject b

Emits the given constant value on the output AsyncSubject every time the source AsyncSubject emits a value.

P purescript-rxjs M RxJS.AsyncSubject
mapTo :: forall a b. b -> BehaviorSubject a -> BehaviorSubject b

Emits the given constant value on the output BehaviorSubject every time the source BehaviorSubject emits a value.

P purescript-rxjs M RxJS.BehaviorSubject
mapTo :: forall a b. b -> Observable a -> Observable b

Emits the given constant value on the output Observable every time the source Observable emits a value. marble diagram

P purescript-rxjs M RxJS.Observable
mapTo :: forall a b. b -> ReplaySubject a -> ReplaySubject b

Emits the given constant value on the output ReplaySubject every time the source ReplaySubject emits a value.

P purescript-rxjs M RxJS.ReplaySubject
mapTo :: forall a b str. SodiumStream str => b -> str a -> Stream b

Transform the stream's event values into the specified constant value. b is a constant value.

P purescript-sodium M SodiumFRP.Stream
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
mapRWS :: forall r w1 w2 s a1 a2. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2

Change the types of the result and accumulator in a RWS action

P purescript-transformers M Control.Monad.RWS
mapAff :: forall a b. (a -> Aff b) -> Effect (Signal a -> Signal (Maybe b))

Apply an async effectful function to signal values and signal the results.

P purescript-signal M Signal.Aff
mapped :: forall f a b. Functor f => Setter (f a) (f b) a b
P purescript-lens M Optic.Setter
mapEnv :: forall a b e. (a -> b) -> Env e a -> Env e b
P purescript-transformerless M Control.Comonad.Transformerless.Env
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
mapRWS :: forall r w1 w2 s a1 a2. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2
P purescript-transformerless M Control.Monad.Transformerless.RWS
mapPos :: forall a b. (a -> b) -> Field (Positive a) -> Field (Positive b)
P purescript-mathbox M Mathbox.Field
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
mapRWST :: forall r w1 w2 s m1 m2 a1 a2. (m1 (RWSResult s a1 w1) -> m2 (RWSResult s a2 w2)) -> RWST r w1 s m1 a1 -> RWST r w2 s m2 a2

Change the result and accumulator types in a RWST monad action.

P purescript-transformers M Control.Monad.RWS.Trans
mapping :: forall s t a b f g. Functor f => Functor g => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
P purescript-profunctor-lenses M Data.Lens.Iso
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
mapKeys :: forall j k v. Ord j => Ord k => (k -> j) -> Map k v -> Map j v
P purescript-probability M Data.Map.Extras