Search results

map :: forall f a b. 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. 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.

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 w i. Node HTMLmap w i

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

map :: forall f a b x y. IxFunctor f => (a -> b) -> f x y a -> f x y b

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.

map :: Selector

map :: forall a t. TypedArray a t => (t -> t) -> ArrayView a -> ArrayView a

Maps a new value over the typed array, creating a new ArrayBuffer and typed array as well.

map :: forall attrs attrs_. Union attrs attrs_ Props_map => Record attrs -> JSX

map :: forall attrsNoChildren attrsWithDuplicate attrs attrs_ jsx. Union attrs attrs_ Props_map => ToJSX jsx => Union (children :: Array JSX) attrsNoChildren attrsWithDuplicate => Nub (children :: Array JSX | attrsNoChildren) attrs => Record attrsNoChildren -> jsx -> JSX

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

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

map :: ElemName

Defines an image map

map :: forall html a. Html html => Array (Prop a) -> Array (html a) -> html a

Defines an image map

map :: forall html a. Html html => Array (Prop a) -> Array (Key /\ (html a)) -> html a

Defines an image map

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

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

map :: forall b a. Ord b => (a -> b) -> OSet a -> OSet 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. (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 f b a. ((a -> b) -> f a -> f b) -> (a -> b) -> NonEmpty f a -> NonEmpty f b

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

map :: forall c f v1 v0. HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (f v0) => ObjectOf c (f v1) => c v0 v1 -> c (f v0) (f v1)

map :: forall c f v1 v0. HasMap c f => ObjectOf c v0 => ObjectOf c v1 => c v0 v1 -> f v0 -> f v1

Maps a type constructor to a List'.

map :: forall f xs ys fproxy kproxy lproxy. Map f xs ys => fproxy f -> kproxy xs -> lproxy ys

map :: forall b a. NotJSPromise b => (a -> b) -> PromiseSpec a -> PromiseSpec b

map the value in a promise spec

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 :: forall lock payload. Event (Attribute Map_) -> Array (Domable lock payload) -> Domable lock payload

map :: forall p q a b. Dissect p q => (a -> b) -> p a -> p b

A tail-recursive map operation, implemented in terms of Dissect.

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

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

Map :: EJsonType

map :: forall db da b a. 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 b a. (a -> b) -> Jet (Atomic a) -> Jet (Atomic b)

Change an Atomic value using a regular function.

map :: forall db b da a k. 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.

map :: forall m. Array (Prop m) -> Component m -> Component m

Map :: forall k v. (Map String (Tuple k v)) -> Map k v

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 b a. Hashable b => (a -> b) -> MultiSet a -> MultiSet b

map :: forall f b a. IsoFunctor f => Iso a b -> f a -> f b

map :: forall r2 r1 r0 p l1 l0 g f. RMap p f g l0 r0 l1 r1 r2 => RowToList r0 l0 => RowToList r1 l1 => g r0 -> p (f r1) (f r2)

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

map :: forall a b. (Mapper a) -> Node a -> Node b

Map :: forall a. (Mapper a) -> QueryOperator a

map :: forall a. Mapper a -> Query a -> Query a

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

A codec for Map values.

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

map :: ClassName

map :: forall (props :: Row Type) (content :: Type). ReactChildren content => IsSubsetOf props (_data :: Object String, about :: String, acceptCharset :: String, accessKey :: String, allowFullScreen :: Boolean, allowTransparency :: Boolean, "aria-activedescendant" :: String, "aria-atomic" :: String, "aria-autocomplete" :: String, "aria-busy" :: String, "aria-checked" :: String, "aria-colcount" :: String, "aria-colindex" :: String, "aria-colspan" :: String, "aria-controls" :: String, "aria-current" :: String, "aria-describedby" :: String, "aria-details" :: String, "aria-disabled" :: String, "aria-dropeffect" :: String, "aria-errormessage" :: String, "aria-expanded" :: String, "aria-flowto" :: String, "aria-grabbed" :: String, "aria-haspopup" :: String, "aria-hidden" :: String, "aria-invalid" :: String, "aria-keyshortcuts" :: String, "aria-label" :: String, "aria-labelledby" :: String, "aria-level" :: String, "aria-live" :: String, "aria-modal" :: String, "aria-multiline" :: String, "aria-multiselectable" :: String, "aria-orientation" :: String, "aria-owns" :: String, "aria-placeholder" :: String, "aria-posinset" :: String, "aria-pressed" :: String, "aria-readonly" :: String, "aria-relevant" :: String, "aria-required" :: String, "aria-roledescription" :: String, "aria-rowcount" :: String, "aria-rowindex" :: String, "aria-rowspan" :: String, "aria-selected" :: String, "aria-setsize" :: String, "aria-sort" :: String, "aria-valuemax" :: String, "aria-valuemin" :: String, "aria-valuenow" :: String, "aria-valuetext" :: String, autoComplete :: Boolean, autoFocus :: Boolean, autoPlay :: Boolean, capture :: Boolean, cellPadding :: String, cellSpacing :: String, charSet :: String, classID :: String, className :: String, colSpan :: Int, contentEditable :: Boolean, contextMenu :: String, crossOrigin :: String, dangerouslySetInnerHTML :: { __html :: String }, datatype :: String, dateTime :: String, dir :: String, draggable :: Boolean, encType :: String, formAction :: String, formEncType :: String, formMethod :: String, formNoValidate :: Boolean, formTarget :: String, frameBorder :: String, hidden :: Boolean, hrefLang :: String, htmlFor :: String, httpEquiv :: String, icon :: String, id :: String, inlist :: String, inputMode :: String, is :: String, itemID :: String, itemProp :: String, itemRef :: String, itemScope :: Boolean, itemType :: String, key :: String, keyParams :: String, keyType :: String, lang :: String, marginHeight :: String, marginWidth :: String, maxLength :: Int, mediaGroup :: String, minLength :: Int, name :: String, noValidate :: Boolean, onBlur :: EffectFn1 SyntheticEvent Unit, onClick :: EffectFn1 SyntheticEvent Unit, onDoubleClick :: EffectFn1 SyntheticEvent Unit, onFocus :: EffectFn1 SyntheticEvent Unit, onKeyDown :: EffectFn1 KeyboardEvent Unit, onKeyPress :: EffectFn1 KeyboardEvent Unit, onKeyUp :: EffectFn1 KeyboardEvent Unit, onMouseDown :: EffectFn1 MouseEvent Unit, onMouseEnter :: EffectFn1 MouseEvent Unit, onMouseLeave :: EffectFn1 MouseEvent Unit, onMouseMove :: EffectFn1 MouseEvent Unit, onMouseOut :: EffectFn1 MouseEvent Unit, onMouseOver :: EffectFn1 MouseEvent Unit, onMouseUp :: EffectFn1 MouseEvent Unit, onScroll :: EffectFn1 SyntheticEvent Unit, onTouchCancel :: EffectFn1 TouchEvent Unit, onTouchEnd :: EffectFn1 TouchEvent Unit, onTouchMove :: EffectFn1 TouchEvent Unit, onTouchStart :: EffectFn1 TouchEvent Unit, prefix :: String, property :: String, radioGroup :: String, readOnly :: Boolean, ref :: Ref HTMLMapElement, resource :: String, role :: String, role :: String, rowSpan :: Int, scoped :: Boolean, seamless :: Boolean, security :: String, spellCheck :: Boolean, srcDoc :: ReactElement, srcLang :: String, srcSet :: String, style :: CSS, suppressContentEditableWarning :: Boolean, tabIndex :: Int, title :: String, typeof :: String, unselectable :: Boolean, useMap :: String, vocab :: String, wmode :: String) => ValidReactProps (Record props) => Record props -> content -> ReactElement

map :: forall (content :: Type). ReactChildren content => String -> content -> ReactElement

map :: JSX

map :: forall a b h. ToHtml a b h

map :: forall attrs attrs_. Union attrs attrs_ (MotionProps + Props_map) => ReactComponent (Record attrs)

map :: (Number -> Number) -> Mat2 -> Mat2

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Mat2d -> Mat2d

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Mat3 -> Mat3

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Mat4 -> Mat4

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Quat -> Quat

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Vec2 -> Vec2

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Vec3 -> Vec3

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: (Number -> Number) -> Vec4 -> Vec4

Map a function from Number to Number over it. Note: Since this is not a general container, it cannot be a Functor.

map :: forall b a. (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.

map :: forall a c e. Attrs -> DOM e c a -> DOM e c (ImpulseEl a)

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

map :: Icons

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

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

map :: (PackageJsonContent -> PackageJsonContent) -> PackageJson -> PackageJson

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

Map :: forall a b. (Map a b) -> Map a b

map :: P5 -> Number -> Number -> Number -> Number -> Number -> (Maybe Boolean) -> Number

p5js.org documentation

map :: StaticElement

Map :: forall a b. (Map a b) -> Map a b

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

map :: FFIComponent MapAttributes

The <map> HTML element is used with area elements to define an image map.

Example:

map { name: "planetmap" }
  [ area { shape: "rect", coords: "50,50,100,100", href: "location1.html", alt: "Location 1" }
  , area { shape: "circle", coords: "200,200,50", href: "location2.html", alt: "Location 2" }
  ]

Common attributes:

| Name | Type | Description | |-------------|---------|-------------| | name | String | Name of the image map |

map :: Free SpaceF Unit -> Free SpaceF Unit

map :: Free SpaceF Unit -> Free SpaceF Unit

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

map :: forall a b f. (a -> b) -> Codensity f a -> Codensity f b

map :: forall a b f g. (a -> b) -> Ran f g a -> Ran f g b

map :: forall nt r. Newtype nt (Variant (map :: Texture | r)) => Texture -> nt

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

Adapts incoming values.

map :: WorldMap

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

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

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

map :: forall a b. EffectFn2 (a -> b) (Node a) (Node b)

map :: forall i. Node HTMLmap i

map :: forall b a. 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

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

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 attrs attrs_. Union attrs attrs_ Props_map => ReactComponent (Record attrs)

map' :: forall jsx. ToJSX jsx => jsx -> JSX

map_ :: Array JSX -> JSX

map_ :: forall html a. Html html => Array (html a) -> html a

Defines an image map [No Attributes]

map_ :: forall html a. Html html => Array (Key /\ (html a)) -> html a

Defines an image map [No Attributes]

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

map' :: forall rw b a. (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.

map_ :: forall m i. Monad m => (CommandsT MapI m) ~> (CommandsT (map :: I | i) m)

map_ :: forall msg. Array (Attribute msg) -> Array (View msg) -> View msg

map' :: forall m. Component m -> Component m

map_ :: forall lock payload. Array (Domable lock payload) -> Domable lock payload

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

mapS :: forall b a s. (a -> b) -> State s a -> State s b

mapW :: forall b a w. (a -> b) -> Writer w a -> Writer w b

map' :: forall a h. ToHtml' a h

map' :: Element

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

map1 :: forall t f g. Functor1 t => (f ~> g) -> t f -> t g

map2 :: forall parentTypeLock a b c. (a -> b -> c) -> SelectionSet parentTypeLock a -> SelectionSet parentTypeLock b -> SelectionSet parentTypeLock c

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

map2 :: forall a b c. EffectFn3 (Fn2 a b c) (Node a) (Node b) (Node c)

map_ :: forall (props :: Row Type) (content :: Type). ReactChildren content => IsSubsetOf props (_data :: Object String, about :: String, acceptCharset :: String, accessKey :: String, allowFullScreen :: Boolean, allowTransparency :: Boolean, "aria-activedescendant" :: String, "aria-atomic" :: String, "aria-autocomplete" :: String, "aria-busy" :: String, "aria-checked" :: String, "aria-colcount" :: String, "aria-colindex" :: String, "aria-colspan" :: String, "aria-controls" :: String, "aria-current" :: String, "aria-describedby" :: String, "aria-details" :: String, "aria-disabled" :: String, "aria-dropeffect" :: String, "aria-errormessage" :: String, "aria-expanded" :: String, "aria-flowto" :: String, "aria-grabbed" :: String, "aria-haspopup" :: String, "aria-hidden" :: String, "aria-invalid" :: String, "aria-keyshortcuts" :: String, "aria-label" :: String, "aria-labelledby" :: String, "aria-level" :: String, "aria-live" :: String, "aria-modal" :: String, "aria-multiline" :: String, "aria-multiselectable" :: String, "aria-orientation" :: String, "aria-owns" :: String, "aria-placeholder" :: String, "aria-posinset" :: String, "aria-pressed" :: String, "aria-readonly" :: String, "aria-relevant" :: String, "aria-required" :: String, "aria-roledescription" :: String, "aria-rowcount" :: String, "aria-rowindex" :: String, "aria-rowspan" :: String, "aria-selected" :: String, "aria-setsize" :: String, "aria-sort" :: String, "aria-valuemax" :: String, "aria-valuemin" :: String, "aria-valuenow" :: String, "aria-valuetext" :: String, autoComplete :: Boolean, autoFocus :: Boolean, autoPlay :: Boolean, capture :: Boolean, cellPadding :: String, cellSpacing :: String, charSet :: String, classID :: String, className :: String, colSpan :: Int, contentEditable :: Boolean, contextMenu :: String, crossOrigin :: String, dangerouslySetInnerHTML :: { __html :: String }, datatype :: String, dateTime :: String, dir :: String, draggable :: Boolean, encType :: String, formAction :: String, formEncType :: String, formMethod :: String, formNoValidate :: Boolean, formTarget :: String, frameBorder :: String, hidden :: Boolean, hrefLang :: String, htmlFor :: String, httpEquiv :: String, icon :: String, id :: String, inlist :: String, inputMode :: String, is :: String, itemID :: String, itemProp :: String, itemRef :: String, itemScope :: Boolean, itemType :: String, key :: String, keyParams :: String, keyType :: String, lang :: String, marginHeight :: String, marginWidth :: String, maxLength :: Int, mediaGroup :: String, minLength :: Int, name :: String, noValidate :: Boolean, onBlur :: EffectFn1 SyntheticEvent Unit, onClick :: EffectFn1 SyntheticEvent Unit, onDoubleClick :: EffectFn1 SyntheticEvent Unit, onFocus :: EffectFn1 SyntheticEvent Unit, onKeyDown :: EffectFn1 KeyboardEvent Unit, onKeyPress :: EffectFn1 KeyboardEvent Unit, onKeyUp :: EffectFn1 KeyboardEvent Unit, onMouseDown :: EffectFn1 MouseEvent Unit, onMouseEnter :: EffectFn1 MouseEvent Unit, onMouseLeave :: EffectFn1 MouseEvent Unit, onMouseMove :: EffectFn1 MouseEvent Unit, onMouseOut :: EffectFn1 MouseEvent Unit, onMouseOver :: EffectFn1 MouseEvent Unit, onMouseUp :: EffectFn1 MouseEvent Unit, onScroll :: EffectFn1 SyntheticEvent Unit, onTouchCancel :: EffectFn1 TouchEvent Unit, onTouchEnd :: EffectFn1 TouchEvent Unit, onTouchMove :: EffectFn1 TouchEvent Unit, onTouchStart :: EffectFn1 TouchEvent Unit, prefix :: String, property :: String, radioGroup :: String, readOnly :: Boolean, ref :: Ref HTMLMapElement, resource :: String, role :: String, role :: String, rowSpan :: Int, scoped :: Boolean, seamless :: Boolean, security :: String, spellCheck :: Boolean, srcDoc :: ReactElement, srcLang :: String, srcSet :: String, style :: CSS, suppressContentEditableWarning :: Boolean, tabIndex :: Int, title :: String, typeof :: String, unselectable :: Boolean, useMap :: String, vocab :: String, wmode :: String) => ValidReactProps (Record props) => String -> Record props -> content -> ReactElement

map_ :: forall b h. ToHtml_ b h

map_ :: forall a c e. Attrs -> DOM e c a -> DOM e c a

map_ :: StaticElementWithoutProperties

map_ :: forall o i context channel. Array (SDOM channel context i o) -> SDOM channel context i o

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

mapE :: forall builder a b eff. MappableBuilder builder a b eff => builder -> (b -> a) -> GenericMappedEmitterBuilder a b eff

mapI :: forall v i' i. (i -> i') -> Result i v -> Result i' v

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

mapM_ :: forall a m r. Monad m => (a -> m Unit) -> Consumer_ a m r

Consume all values using a monadic function

mapIO :: forall aa ab ba bb m r. Monad m => (ab -> aa) -> (ba -> bb) -> AsyncPipe aa ba m r -> AsyncPipe ab bb m r

Modify request / response types

map__ :: forall lock payload. String -> Domable lock payload

mapTo :: forall f b a. 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.

mapTo :: forall b a. b -> Stream a -> Stream b

map'_ :: ElementWithoutProperties

mapOf :: forall a b c. Ord b => Parser a -> Parser b -> Parser c -> Parser (Map b c)

mapTo :: forall f b a. 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.

mapTo :: forall b a. b -> AsyncSubject a -> AsyncSubject b

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

mapTo :: forall b a. b -> BehaviorSubject a -> BehaviorSubject b

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

mapTo :: forall b a. b -> Observable a -> Observable b

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

mapTo :: forall b a. b -> ReplaySubject a -> ReplaySubject b

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

mapTo :: forall str b a. SodiumStream str => b -> str a -> Stream b

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

mapUI :: forall ui ui' props value result. (props -> value -> Maybe result -> ui -> ui') -> FormBuilder' ui props value result -> FormBuilder' ui' props value result

Change the UI type of a form based on the props, the current value and the validated result.

mapEnv :: forall e a b. (a -> b) -> Env e a -> Env e b

Change the data type in an Env computation.

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

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.

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

mapSum :: forall mp ri ro. MapSum mp ri ro => mp -> Record ri -> Record ro

mapAll :: forall a b f. Traversable f => (a -> Maybe b) -> f a -> Maybe (f b)

Map an array conditionally, only return the array when all elements were mapped. Note that this function is an alias for traverse. This is specific behavior for the implementation of <*> for Applicative Maybe.

Hint: mapAny can be found in Data.Foldable.Extra

mapAll (\x -> if x == 2 then Just 99 else Nothing) [1,2,3] == Nothing
mapAll (\x -> Just (x * 2)) [1,2,3] == Just [2,4,6]

mapAny :: forall a f. Traversable1 f => (a -> Maybe a) -> f a -> Maybe (f a)

Map an array conditionally, only return the array when at least one element was mapped. Elements that are not mapped will keep the old value.

Hint: mapAll can be found in Data.Semigroup.Traversable.Extra

mapAny (\_ -> Nothing) (Data.Array.NonEmpty.cons' 1 [2, 3]) == Nothing
mapAny (\x -> if x == 2 then Just 99 else Nothing) (Data.Array.NonEmpty.cons' 1 [2, 3]) == Data.Array.NonEmpty.fromArray [1,99,3]

Not that in the second example the Just is implicit.

mapEnv :: forall e b a. (a -> b) -> Env e a -> Env e b

mapErr :: forall e m a. MonadError e m => (e -> e) -> m a -> m a

mapRWS :: forall a2 a1 s w2 w1 r. (RWSResult s a1 w1 -> RWSResult s a2 w2) -> RWS r w1 s a1 -> RWS r w2 s a2

mapVal :: (String -> String) -> Val -> Val

mapGen :: forall a b. (Tuple a GenState -> Tuple b GenState) -> Gen a -> Gen b

Change the type of the result in a Gen action

MapInl :: MapInl

MapInr :: MapInr

mapped :: GPUBufferMapState

MapPin :: Icon

mapPos :: forall b a. (a -> b) -> Field (Positive a) -> Field (Positive b)

mapUI_ :: forall ui ui' props value result. (ui -> ui') -> FormBuilder' ui props value result -> FormBuilder' ui' props value result

Change the UI type of a form.

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

Transform the result of a continuation-passing function.

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.

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.

Low-level iteration state for a Map. Must be consumed using an appropriate stepper.

mapSpec :: forall m m' g i a. Functor m' => (m ~> m') -> SpecT g i m a -> SpecT g i m' a

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)

mapping :: forall f a b. Mapping f a b => f -> a -> b

mapEnvT :: forall e m1 m2 a b. (m1 a -> m2 b) -> CoEnvT e m1 a -> CoEnvT e m2 b

mapElem :: forall f a. Functor f => f a -> f (Elem a)

mapKeys :: forall v k j. Ord j => Ord k => (k -> j) -> Map k v -> Map j v

mapProp :: forall sym ri ro. MapProp sym ri ro => Proxy sym -> Record ri -> Record ro

mapRows :: forall rowId columnId cell1 cell2. Hashable columnId => Hashable rowId => Hashable cell1 => (HashMap columnId cell1 -> HashMap columnId cell2) -> Table rowId columnId cell1 -> Either (HashSet (MissingCell rowId columnId)) (Table rowId columnId cell2)

The mapping function should preserve the length of the list. If it doesn't, you'll end up

mapRWSE :: forall r w1 w2 s e a b. ((s /\ (Either e a) /\ w1) -> (s /\ (Either e b) /\ w2)) -> RWSE r w1 s e a -> RWSE r w2 s e b

Modifies the result and accumulator types of a RWSE.

mapView :: forall a v1 v2. (v1 -> v2) -> Widget v1 a -> Widget v2 a

mapWire :: forall m s a. Alt m => MonadEffect m => MonadAff m => Plus m => Lens' s a -> Wire m s -> Wire m a

Map a Lens over a Wire

mapAttr :: forall m a b e. Functor m => Attr e a b => a -> m b -> m (Attribute e)

A version of attr that maps a value to an attribute or listener. More commonly used in its alias <:=>.

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

mapProp :: forall sym ri ro. MapProp sym ri ro => Proxy sym -> Record ri -> Record ro

mapProp :: forall sym ri ro. MapProp sym ri ro => Proxy sym -> Record ri -> Record ro

mapEach :: forall a. EnzymeM SingleNode a -> EnzymeM ManyNodes (Array a)

Basically, a DSL-friendly equivalent of map: for each element in the current Wrapper performs the given action and returns all results of that action as an array.

Example:

allNames <- findAll ".t--foo" >> mapEach text
allValues <- findAll ".t--foo" >> mapEach (prop "value")

mapEach :: forall m a. Testable m => m a -> Array Element -> m (Array a)

Runs the given computation multiple times, in the context of each of the given Elements, and returns their results as an array.

values <- findAll "input" >> mapEach (prop P.value)

mapGenT :: forall m1 m2 a b. (m1 (Tuple a GenState) -> m2 (Tuple b GenState)) -> GenT m1 a -> GenT m2 b

Change the type of the result in a GenT action

mapImpl :: forall a. ReactComponent (Record a)

mapLeft :: forall l r l2. (l -> l2) -> Either l r -> Either l2 r

mapNode :: forall b a. (List a -> List b) -> Node a -> Node b

mapping :: Cast Mapping

mapping :: forall f a b. Mapping f a b => f -> a -> b

Mapping :: (Map String Attribute) -> Attribute

mapRead :: GPUBufferUsage

mapTest :: forall bracket test test' m. Functor m => (test -> test') -> (MoteT bracket test m) ~> (MoteT bracket test' m)

mapTree :: forall b a. (Tree a -> Tree b) -> Gen a -> Gen b

Map over the 'Tree' inside a 'Gen'.

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.

parseEmail :: String -> Maybe Email
parseEmail = ...

mapMaybe parseEmail ["a.com", "hello@example.com", "--"]
   = [Email {user: "hello", domain: "example.com"}]

mapMaybe :: forall a b. (a -> Maybe b) -> NonEmptyArray a -> Array b

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)

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)

mapMaybe :: forall a b. (a -> Maybe b) -> NonEmptyList a -> List b

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.

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.

mapState :: forall s a b. (Tuple a s -> Tuple b s) -> State s a -> State s b

Change the type of the result in a State action

mapMaybe :: forall k a b. Ord k => (a -> Maybe b) -> Map k a -> Map k b

Applies a function to each value in a map, discarding entries where the function returns Nothing.

mapMaybe :: forall a b. Ord b => (a -> Maybe b) -> Set a -> Set b

Applies a function to each value in a set, discarding entries where the function returns Nothing.

mapMaybe :: forall a b. Ord b => (a -> Maybe b) -> NonEmptySet a -> Set b

Applies a function to each value in a set, discarding entries where the function returns Nothing.

mapThunk :: forall f g i j. (f i -> g j) -> Thunk f i -> Thunk g j

mapEvent :: forall r l. (l -> r) -> (Free (MarkupM l)) ~> (Free (MarkupM r))

Change the event type of a markup sequence.

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!

mapMaybe :: forall k v w. (v -> Maybe w) -> HashMap k v -> HashMap k w

Apply a function to all values in a hash map, discard the Nothing results, and keep the value of the Just results.

mapMaybe :: forall a b. Hashable b => (a -> Maybe b) -> HashSet a -> HashSet b

Map a function over a set, keeping only the Just values.

mapAccum :: forall event a b c. IsEvent event => (a -> b -> Tuple a c) -> a -> event 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`.

mapEvent :: forall b a. (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.

mapMaybe :: forall html msg1 msg2. MapMaybe html => (msg1 -> Maybe msg2) -> html msg1 -> html msg2

mapState :: forall ev b a. (a -> b) -> EffModel a ev -> EffModel b ev

Map over the state of an EffModel.

mapAccum :: forall c b a event. 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`.

mapMaybe :: forall b a. (a -> Maybe b) -> OSet a -> OSet b