Search results

useCleaner :: forall m. MonadHooks m => Effect Unit -> m Unit

Add a cleaner

onCleanup :: forall m. MonadCleanup m => Effect Unit -> m Unit

Add a cleanup action.

useCleaner :: forall m. MonadHooks m => Effect Unit -> m Unit

Add a cleaner

liftEffect :: forall m a. MonadEffect m => Effect a -> m a

pull :: forall a m. MonadEffect m => Effect a -> m a

read :: forall g a. RWLockGuard g => g a -> Aff a

quickCheck :: forall p. Testable p => p -> Aff Unit

Runs a Testable with a random seed and 100 inputs.

awaitFinished :: forall s a. Write s a => s -> Aff Unit

awaitReadableOrClosed :: forall s a. Read s a => s -> Aff Unit

awaitWritableOrClosed :: forall s a. Write s a => s -> Aff Unit

abort :: forall tx. IDBTransaction tx => tx -> Aff Unit

Aborts the transaction. All pending requests will fail with a "AbortError" DOMException and all changes made to the database will be reverted.

cancel :: forall a. Parent a => a -> Aff Unit

clear :: forall store. IDBObjectStore store => store -> Aff Unit

Deletes all records in store.

close :: forall db. IDBDatabase db => db -> Aff Unit

Closes the connection once all running transactions have finished.

closePort :: forall a. LateNode a => a -> Aff Unit

delay :: forall d. Duration d => d -> Aff Unit

delete :: forall cursor. IDBCursor cursor => cursor -> Aff Unit

Delete the record pointed at by the cursor with a new value.

key :: forall cursor. IDBConcreteCursor cursor => cursor -> Aff Key

Returns the key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.

primaryKey :: forall cursor. IDBConcreteCursor cursor => cursor -> Aff Key

Returns the effective key of the cursor. Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.

release :: forall g a. RWLockGuard g => g a -> Aff Unit

pure :: forall f a. Applicative f => a -> f a

forever :: forall m a b. MonadRec m => m a -> m b

forever runs an action indefinitely, using the MonadRec instance to ensure constant stack usage.

For example:

main = forever $ trace "Hello, World!"

singleton :: forall f a. Unfoldable1 f => a -> f a

Contain a single value. For example:

singleton "foo" == (NEL.singleton "foo" :: NEL.NonEmptyList String)

proof :: forall a b p. TypeEquals a b => p a -> p b

elements :: forall m f a. MonadGen m => Foldable1 f => f a -> m a

Creates a generator that outputs a value chosen from a selection with uniform probability.

unsafePerformEffect :: forall a. Effect a -> a

Run an effectful computation.

Note: use of this function can result in arbitrary side-effects.

downFrom :: forall a u. Enum a => Unfoldable u => a -> u a

Produces all predecessors of an Enum value, excluding the start value.

downFromIncluding :: forall a u. Enum a => Unfoldable1 u => a -> u a

Produces all predecessors of an Enum value, including the start value.

downFromIncluding top will return all values in an Enum, in reverse order.

upFrom :: forall a u. Enum a => Unfoldable u => a -> u a

Produces all successors of an Enum value, excluding the start value.

upFromIncluding :: forall a u. Enum a => Unfoldable1 u => a -> u a

Produces all successors of an Enum value, including the start value.

upFromIncluding bottom will return all values in an Enum.

coerce :: forall f a b. Contravariant f => Functor f => f a -> f b

throwError :: forall e m a. MonadThrow e m => e -> m a

inj :: forall f g a. Inject f g => f a -> g a

join :: forall f m a. MonadFork f m => f a -> m a

uninterruptible :: forall e f m a. MonadBracket e f m => m a -> m a

cleared :: forall f a b. Filterable f => f a -> f b

Filter out all values.

aread :: forall s r m. Refer s r => MonadEffect m => r -> m s

fread :: forall m r s. MonadEffect m => Refer s r => r -> m s

spyM :: forall m a. Warn (Text "Debug function usage") => Monad m => m a -> m a

liftBase :: forall b m a. MonadBase b m => b a -> m a

folded :: forall event a. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

length :: forall sproxy proxy a b. Length a b => sproxy a -> proxy b

parseInt :: forall sproxy proxy sym a. ParseInt sym a => sproxy sym -> proxy a

parse Int a Value-Level

parseInt (Proxy  :: _ "-1337") ~> N1337
parseInt (SProxy :: _ "-1337") ~> N1337
    -- N1137 would be type alias for Neg (Succ^1337 Z)

parseNat :: forall sproxy proxy sym a. ParseNat sym a => sproxy sym -> proxy a

value-level parse of number

parseNat (Proxy  "10") ~> D10
parseNat (SProxy "10") ~> D10

lambek :: forall t f. Recursive t f => Corecursive t f => t -> f t

project :: forall t f. Recursive t f => t -> f t

folded :: forall a event. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

init :: forall xs ys lproxy. Init xs ys => lproxy xs -> lproxy ys

length :: forall xs r lproxy iproxy. Length xs r => lproxy xs -> iproxy r

localEffect :: forall a. Effect a -> a

sequenceProduct :: forall specI specO f. SequenceProduct specI specO f => specI -> f specO

sort :: forall f a. Functor f => Foldable f => Unfoldable f => Ord a => f a -> f a

Sort any structure (which has Foldable, Unfoldable, and Functor instances) by converting to an OrdSeq and back again. I am fairly sure this is usually O(n*log(n)), although of course this depends on the Unfoldable and Foldable instances.

pure :: forall v f c. HasPure c f => ObjectOf c v => v -> f v

restoreAfter :: forall m a. MonadCanvasAction m => m a -> m a

Runs save, then the provided action, then restore

bottom1_ :: forall f a. Bottom1_ f => a -> f a

bottom2 :: forall f a b. Bottom2 f a => a -> f b

top1_ :: forall f a. Top1_ f => a -> f a

act :: forall m b a. Mother m => a -> m b

allOff :: forall m t. Bind m => MonadEffect m => EventTargetOp t => t -> m t

Removes all event handler functions from an event target. The target is returned.

allOffM :: forall m t. Bind m => MonadEffect m => EventTargetOp t => m t -> m t

Removes all event handler functions from an event target. The target is returned.

change :: forall t m. EventTargetOp t => MonadEffect m => t -> m t

Triggers the change event handlers tied to the event target. The target is returned.

changeM :: forall m t. Bind m => EventTargetOp t => MonadEffect m => m t -> m t

Triggers the change event handlers tied to the event target. The target is returned.

collapse :: forall m n. MonadEffect m => HTMLElementOp n => n -> m n

collapseM :: forall m n. MonadEffect m => HTMLElementOp n => m n -> m n

conceal :: forall m n. MonadEffect m => HTMLElementOp n => n -> m n

concealM :: forall m n. MonadEffect m => HTMLElementOp n => m n -> m n

detach :: forall c m. MonadEffect m => NodeOp c => c -> m c

Detatches a node from its parent node and returns the detached node. Descendant nodes and event listeners are not affected. The detatched node is returned.

detachM :: forall c m. MonadEffect m => NodeOp c => m c -> m c

Detatches a node from its parent node and returns the detached node. Descendant nodes and event listeners are not affected. The detatched node is returned.

disable :: forall el m. HTMLAbleOp el => MonadEffect m => el -> m el

disableM :: forall m el. HTMLAbleOp el => MonadEffect m => m el -> m el

drain :: forall a s n n1. ToString n1 s => IsSymbol s => Analytic (a n) => Analytic (a n1) => Add n1 1 n => a n -> a n1

Decrement the dimension of a point/vector by removing its last coordinate.

dsingleton :: forall cnt a. Diff cnt => a -> cnt a

empty :: forall m p. MonadEffect m => NodeOp p => p -> m p

Calls remove on the all of the node's children. The emptied node is returned.

emptyM :: forall m p. MonadEffect m => NodeOp p => m p -> m p

Calls remove on the all of the node's children. The emptied node is returned.

enable :: forall el m. HTMLAbleOp el => MonadEffect m => el -> m el

enableM :: forall m el. HTMLAbleOp el => MonadEffect m => m el -> m el

forever :: forall b a m. Monad m => m a -> m b

hide :: forall m n. MonadEffect m => HTMLElementOp n => n -> m n

hideM :: forall m n. MonadEffect m => HTMLElementOp n => m n -> m n

immerse :: forall a n n1. Analytic (a n) => Analytic (a n1) => Add n 1 n1 => a n -> a n1

Increments the dimension of a point/vector by adding a zero coordinate after the other coordinates.

lookAhead :: forall m a. LookAheadParsing m => m a -> m a

mockFun :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => params -> m fun

negated :: forall f a. Functor f => Ring a => f a -> f a

Negate a vector

negated (V2 1.0 (-2.0)) = V2 (-1.0) 2.0

once :: forall a m. MonadLogic m => m a -> m a

pure :: forall d a. Syntax d => Eq a => a -> d a

pure :: forall f a. Unital Function Unit Unit f => Functor f => a -> f a

pure :: forall a b. HasPure a => b -> a b

pure :: forall f a. Applicative f => a -> f a

query :: forall m q r. MonadSession m => AsQuery q => FromRows r => q -> m r

Executes a query and unmarshals the result into r

read :: forall box val m. Read box val => MonadDelay m => box -> m val

Read the current value. Will never cause a refresh.

remove :: forall c m. MonadEffect m => NodeOp c => c -> m c

Calls detach on the node and its descendants, and in addition removes all event listeners from the detached node and descendants. The event listners are removed provided that they were added using Web.Event.Class.EventTargetOp.on or derivation thereof such as Web.Event.Class.EventTargetOp.change or Web.Event.Class.EventTargetOp.ready. The removed node is returned.

removeM :: forall c m. MonadEffect m => NodeOp c => m c -> m c

Calls detach on the node and its descendants, and in addition removes all event listeners from the detached node and descendants. The event listners are removed provided that they were added using Web.Event.Class.EventTargetOp.on or derivation thereof such as Web.Event.Class.EventTargetOp.change or Web.Event.Class.EventTargetOp.ready. The removed node is returned.

repeat :: forall a u. Unfoldable1 u => a -> u a

Create an infinite Unfoldable1 by repeating a single element.

reveal :: forall m n. MonadEffect m => HTMLElementOp n => n -> m n

revealM :: forall m n. MonadEffect m => HTMLElementOp n => m n -> m n

show :: forall m n. MonadEffect m => HTMLElementOp n => n -> m n

showM :: forall m n. MonadEffect m => HTMLElementOp n => m n -> m n

siteClock :: forall s m i c. Site s m i c => s -> m c

siteId :: forall s m i c. Site s m i c => s -> m i

throw :: forall (t10 :: Type -> Type) (t11 :: Type) (a12 :: Type). MonadThrow Error t10 => Show a12 => a12 -> t10 t11