Search results

sequence :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

sequence1 :: forall t b f. Traversable1 t => Apply f => t (f b) -> f (t b)

sequence1Default :: forall t a m. Traversable1 t => Apply m => t (m a) -> m (t a)

A default implementation of sequence1 using traverse1.

sequenceDefault :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

A default implementation of sequence using traverse.

distribute :: forall f a g. Distributive f => Functor g => g (f a) -> f (g a)

distributeDefault :: forall a f g. Distributive f => Functor g => g (f a) -> f (g a)

A default implementation of distribute, based on collect.

parSequence :: forall a t m f. Parallel f m => Applicative f => Traversable t => t (m a) -> m (t a)

sequence :: forall m p q a. Dissect p q => MonadRec m => p (m a) -> m (p a)

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

sequence :: forall c b a. HasApply b => HasMap b => HasTraverse a => HasPure b => a (b c) -> b (a c)

Sequences actions and collects the results.

sequence [Just 1, Just 2] -- Just [1, 2]

inParallel :: forall f m a. Parallel f m => Applicative f => Array (m a) -> m (Array a)

Run multiple computations in parallel, and collect all results To only take the fastest result, use race

useHooks :: forall m a. MonadHooks m => Signal (m a) -> m (Signal a)

Unwrap a Signal

dynamic :: forall m a. MonadReplace m => MonadFRP m => Dynamic (m a) -> m (Dynamic a)

useHooks :: forall m a. MonadHooks m => Signal (m a) -> m (Signal a)

Unwrap a Signal

weakDynamic :: forall m a. MonadReplace m => MonadFRP m => WeakDynamic (m a) -> m (WeakDynamic a)

all :: forall a g f. Deferred => Foldable f => Unfoldable g => f (Promise a) -> Promise (g a)

Run all promises in the given Foldable, returning a new promise which either resolves to a collection of all the given promises' results, or rejects with the first promise to reject.

pivotAxes :: forall f a. Applicative f => Monoid (f a) => Foldable f => f (Vector3 a) -> { x :: f a, y :: f a, z :: f a }

all :: forall a. Array (LazyPromise a) -> LazyPromise (Array a)

all :: forall a. Array (LazyPromise a) -> LazyPromise (Array a)

unwrap :: forall a. Signal (Effect a) -> Effect (Signal a)

Takes a signal of effects of a, and produces an effect which returns a signal which will take each effect produced by the input signal, run it, and yield its returned value.

countQueuingStrategy :: forall a. { highWaterMark :: Int } -> Effect (QueuingStrategy a)

new :: forall chunk. { highWaterMark :: Int, size :: chunk -> Int } -> Effect (QueuingStrategy chunk)

useEffect :: forall m a. MonadHooks m => Signal (Effect a) -> m (Signal a)

Unwrap effective Signal

all :: forall a. NotJSPromise a => Array (PromiseSpec a) -> PromiseSpec (Array a)

Process all promise specs in an array

mkAdapter :: forall nodeRow. { nodesRef :: Ref (Array (MinimalNode nodeRow)), reheatFn :: Effect Unit, reinitForcesFn :: Effect Unit } -> EngineAdapter (MinimalNode nodeRow)

Create an EngineAdapter from D3 kernel components.

This bridges the generic core engine with D3-specific functionality. The adapter provides position capture/update and rule application.

zip :: forall a. Array (Observable a) -> Observable (Array a)

Waits for each ObservableImpl to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner ObservableImpl completes.

all :: forall v. Array (Promise v) -> Promise (Array v)

Documentation: Promise.all()

allSettled :: forall v. Array (Promise v) -> Promise (Array v)

Documentation: Promise.allSettled()

any :: forall v. Array (Promise v) -> Promise (Array v)

Documentation: Promise.any()

combineLatestAll :: forall a. List (Observable a) -> Observable (List a)

cons :: forall a. Ord a => { head :: a, tail :: List a } -> Maybe (List a)

performEvent :: forall m a. MonadFRP m => Event (Aff a) -> m (Event a)

Run asynchronous action when an Event occurs. The returned Event will fire when such an action completes.

Note: the results may arrive in a different order than the requests.

pivotNonEmptyAxes :: forall a. NonEmptyArray (Vector3 a) -> { x :: NonEmptyArray a, y :: NonEmptyArray a, z :: NonEmptyArray a }

runRule :: forall m. MonadEffect m => MonadThrow Error m => { assertViolationMessage :: String -> m Unit, module :: String, rule :: Rule } -> m (Array String)

runRule' :: forall m. MonadEffect m => MonadThrow Error m => { module :: String, rule :: Rule } -> m (Violations ())

runWhine :: forall m. MonadEffect m => { configFile :: FilePath, env :: Env, factories :: RuleFactories, globs :: Maybe (NonEmptyArray NonEmptyString) } -> m (Violations (WithRule + WithMuted + WithFile + ()))

The main entry point into the linter. It takes some basic parameters and runs the whole thing: reads the config, parses it, instantiates the rules, globs the input files, parses them, and runs the rules through every file.

sequenceShrinkList :: forall a. List (Tree a) -> Tree (List a)

Turn a list of trees in to a tree of lists, opting to shrink both the list itself and the elements in the list during traversal.

sequenceShrinkOne :: forall a. List (Tree a) -> Tree (List a)

Turn a list of trees in to a tree of lists, opting to shrink only the elements of the list (i.e. the size of the list will always be the same).

useEffect :: forall m a. MonadHooks m => Signal (Effect a) -> m (Signal a)

Unwrap effective Signal

zip :: forall a. Array (Observable a) -> Observable (Array a)

Waits for each ObservableImpl to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner ObservableImpl completes.

zip :: forall a. Array (AsyncSubject a) -> AsyncSubject (Array a)

Waits for each AsyncSubject to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner AsyncSubject completes.

zip :: forall a. Array (BehaviorSubject a) -> BehaviorSubject (Array a)

Waits for each BehaviorSubject to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner BehaviorSubject completes.

zip :: forall a. Array (Observable a) -> Observable (Array a)

Waits for each Observable to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner observable completes.

zip :: forall a. Array (ReplaySubject a) -> ReplaySubject (Array a)

Waits for each ReplaySubject to emit a value. Once this occurs, all values with the corresponding index will be emitted. This will continue until at least one inner ReplaySubject completes.

byteLengthQueuingStrategy :: { highWaterMark :: Int } -> Effect (QueuingStrategy Uint8Array)

layoutADT :: { constructors :: Array { args :: Array RenderType, name :: String }, keyword :: Maybe String, name :: String, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a data type with constructor branches.

layoutClassDef :: { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String, superclasses :: Array SuperclassInfo, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a type class definition.

layoutSignature :: { ast :: RenderType, className :: Maybe String, name :: String, sig :: String, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a value/type-synonym signature.

pinAtCurrent :: forall r. { fx :: Nullable Number, fy :: Nullable Number, x :: Number, y :: Number | r } -> { fx :: Nullable Number, fy :: Nullable Number, x :: Number, y :: Number | r }

Pin a node at its current position.

Sets fx = x, fy = y so the node won't move during simulation.

Type signature uses row polymorphism - works with any node type that has the required fields.

runFutureEffect :: forall a. Future (Effect a) -> Now (Future a)

Takes a future effect and returns a now-computation that runs the effect once the future occurs and delivers the result in a future.

runStreamEffect :: forall a. Stream (Effect a) -> Now (Stream a)

Takes a stream of effects and returns a now-computation that runs the effect in each occurrence and delivers the result in a stream.