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.

static :: forall da a. Patch a da => Array (Jet a) -> Jet (IArray a)

Construct an array whose elements can change but whose length is fixed, from an array of jets.

unpin :: forall r. { fx :: Nullable Number, fy :: Nullable Number | r } -> { fx :: Nullable Number, fy :: Nullable Number | r }

Unpin a node (clear fx/fy).

Allows the node to move freely under force simulation.

allowNoneOrAll :: forall a f. Foldable f => Array (EqPred a) -> Constraint (f a)

allowNoneOrOne :: forall a g. Foldable g => Array (EqPred a) -> Constraint (g a)

border :: forall r. Array (BorderOption ()) -> EndStyleOption (border :: Array (BorderOption ()) | r)

border :: forall r. Array (BorderOption ()) -> ListStyleOption (border :: Array (BorderOption ()) | r)

border :: forall r. Array (BorderOption ()) -> StyleOption (border :: Array (BorderOption ()) | r)

eliminateNothings :: forall a. Tree (Maybe a) -> Array (Tree a)

focus :: forall r. Array (EndStyleOption ()) -> ListStyleOption (focus :: Array (EndStyleOption ()) | r)

focus :: forall r. Array (EndStyleOption ()) -> StyleOption (focus :: Array (EndStyleOption ()) | r)

hover :: forall r. Array (EndStyleOption ()) -> ListStyleOption (hover :: Array (EndStyleOption ()) | r)

hover :: forall r. Array (EndStyleOption ()) -> StyleOption (hover :: Array (EndStyleOption ()) | r)

item :: forall r. Array (EndStyleOption ()) -> ListStyleOption (item :: Array (EndStyleOption ()) | r)

scrollbar :: forall r. Array (BorderOption ()) -> EndStyleOption (scrollbar :: Array (BorderOption ()) | r)

scrollbar :: forall r. Array (BorderOption ()) -> ListStyleOption (scrollbar :: Array (BorderOption ()) | r)

scrollbar :: forall r. Array (BorderOption ()) -> StyleOption (scrollbar :: Array (BorderOption ()) | r)

selected :: forall r. Array (EndStyleOption ()) -> ListStyleOption (selected :: Array (EndStyleOption ()) | r)

shade :: { black :: Color, hue :: Color, white :: Color } -> { black :: Color, grey1 :: Color, grey2 :: Color, hue :: Color, hueDarker :: Color, hueDarkest :: Color, hueDisabled :: Color, white :: Color }

readRefMaybe :: forall a. Ref (Nullable a) -> Effect (Maybe a)

unfoldM' :: forall a f m. Monad m => Applicative f => Monoid (f a) => m (Maybe a) -> m (f a)

The supplied Maybe expression will be repeatedly called until it returns Nothing. All Just values are collected into an Applicative monoidal structure.

unfoldM' :: forall m f a. MonadRec m => Applicative f => Monoid (f a) => m (Maybe a) -> m (f a)

The supplied Maybe expression will be repeatedly called until it returns Nothing. All values returned are collected into an Applicative Monoid.

readNullableRefM :: forall r m. MonadDelay m => Ref (Nullable r) -> Effect (Maybe r)

transpose :: forall a. Array (Array a) -> Array (Array a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose 
  [ [1, 2, 3]
  , [4, 5, 6]
  ] == 
  [ [1, 4]
  , [2, 5]
  , [3, 6]
  ]

If some of the rows are shorter than the following rows, their elements are skipped:

transpose 
  [ [10, 11]
  , [20]
  , [30, 31, 32]
  ] == 
  [ [10, 20, 30]
  , [11, 31]
  , [32]
  ]

transpose :: forall a. NonEmptyArray (NonEmptyArray a) -> NonEmptyArray (NonEmptyArray a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose 
  (NonEmptyArray [ NonEmptyArray [1, 2, 3]
                 , NonEmptyArray [4, 5, 6]
                 ]) == 
  (NonEmptyArray [ NonEmptyArray [1, 4]
                 , NonEmptyArray [2, 5]
                 , NonEmptyArray [3, 6]
                 ])

If some of the rows are shorter than the following rows, their elements are skipped:

transpose 
  (NonEmptyArray [ NonEmptyArray [10, 11]
                 , NonEmptyArray [20]
                 , NonEmptyArray [30, 31, 32]
                 ]) == 
  (NomEmptyArray [ NonEmptyArray [10, 20, 30]
                 , NonEmptyArray [11, 31]
                 , NonEmptyArray [32]
                 ])

transpose :: forall a. List (List a) -> List (List a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose ((1:2:3:Nil) : (4:5:6:Nil) : Nil) ==
  ((1:4:Nil) : (2:5:Nil) : (3:6:Nil) : Nil)

If some of the rows are shorter than the following rows, their elements are skipped:

transpose ((10:11:Nil) : (20:Nil) : Nil : (30:31:32:Nil) : Nil) ==
  ((10:20:30:Nil) : (11:31:Nil) : (32:Nil) : Nil)

transpose :: forall a. List (List a) -> List (List a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose ((1:2:3:nil) : (4:5:6:nil) : nil) ==
  ((1:4:nil) : (2:5:nil) : (3:6:nil) : nil)

If some of the rows are shorter than the following rows, their elements are skipped:

transpose ((10:11:nil) : (20:nil) : nil : (30:31:32:nil) : nil) ==
  ((10:20:30:nil) : (11:31:nil) : (32:nil) : nil)

unfoldM :: forall m a. Monad m => m (Maybe a) -> m (Array a)

The supplied Maybe expression will be repeatedly called until it returns Nothing. All values returned are collected into an Array.

unfoldM :: forall m a. MonadRec m => m (Maybe a) -> m (Array a)

The supplied Maybe expression will be repeatedly called until it returns Nothing. All values returned are collected into an array.

swap :: forall @m @n a. Swap m n a => Polynomial (Polynomial a) -> Polynomial (Polynomial a)

xchng :: forall a. Eq a => Semiring a => Polynomial (Polynomial a) -> Polynomial (Polynomial a)

headA :: forall repr a. DataDSL repr => repr (Array a) -> repr (Maybe a)

Get first element

getBounds :: forall a. Array (Array a) -> { maxX :: Int, maxY :: Int }

solve :: Board (Maybe Int) -> Array (Board Int)

The solve function literally solves a Sudoku question board, returns an array of complete solutions.

transpose :: forall a. Array (Array a) -> Array (Array a)

transpose :: forall a. Array (Array a) -> Array (Array a)

mergeMany :: forall f a. Functor f => Foldable f => f (Signal a) -> Maybe (Signal a)

Merge all signals inside a Foldable, returning a Maybe which will either contain the resulting signal, or Nothing if the Foldable was empty.

shift :: forall a. Stream (Stream a) -> Now (Stream a)

Takes a stream of a stream and returns a stream that emits from the last stream.

shiftFrom :: forall a. Stream (Stream a) -> Behavior (Stream a)

Takes a stream of a stream and returns a stream that emits from the last stream.

switchC :: forall cel a. SodiumCell cel => cel (Cell a) -> Effect (Cell a)

race :: forall a. Array (Promise a) -> Effect (Promise a)

race :: forall a. Array (Promise a) -> Effect (Promise a)

addLayers :: forall node. Ord node => Array (TaskNode node) -> Array (LayeredNode node)

Add layer information to task nodes

fromArray :: forall a. Array (Array a) -> Maybe (Matrix a)

Constructs a Matrix from an Array of Arrays. Returns Nothing if the dimensions don't line up.

> fromMaybe empty (fromArray [[1,2,3], [4,5,6]])
1, 2, 3
4, 5, 6

> fromArray [[1,2,3], [4,5]]
Nothing

layoutTree :: forall a. Tree (WithDef a) -> Tree (WithDefRect a)

fromSendable :: forall a. SendWrapper (SharedMap a) -> Effect (SharedMap a)

Unwrap on the worker side. Reconstructs Int32Array views from the shared buffer.

fromSendable :: forall a. SendWrapper (SharedState a) -> Effect (SharedState a)

Unwrap on the worker side. Reconstructs Int32Array views from the shared buffer.

maximum :: forall c. Array (Money c) -> Maybe (Money c)

Find the maximum of an array of money amounts.

minimum :: forall c. Array (Money c) -> Maybe (Money c)

Find the minimum of an array of money amounts.

unwrapResponse :: forall a. Aff (ClientResponse a) -> Aff (ResponseContent a)

length :: forall da a. Patch a da => Jet (IArray a) -> Jet (Atomic Int)

Compute the length of the array incrementally.

text :: forall eff. Jet (Atomic String) -> Jet (View eff)

Create a text node wrapped in a <span> element.

withered :: forall t m x. Witherable t => Applicative m => t (m (Maybe x)) -> m (t x)

Filter out all the Nothing values - with effects in m.

memo :: forall props. Effect (ReactComponent props) -> Effect (ReactComponent props)

Prevents a component from re-rendering if its new props are referentially equal to its old props (not value-based equality -- this is due to the underlying React implementation). Prefer memo' for more PureScript-friendldy behavior.

negateA :: forall repr. DataDSL repr => repr (Array Number) -> repr (Array Number)

Negate all values in array

Spreadsheet equivalent: =MAP(range, x => -x)

jsonify :: forall k. EncodeJson k => Options (IteratorOptions k) -> Options (IteratorOptions k)

sort :: forall a. List (Stamped a) -> List (Stamped a)

Sort a list of Stamped records ascending chronologically.

separate :: forall f l r. Compactable f => f (Either l r) -> { left :: f l, right :: f r }

separateDefault :: forall f l r. Functor f => Compactable f => f (Either l r) -> { left :: f l, right :: f r }

partition :: forall c b f. Rebuildable f => f (Either b c) -> { left :: f b, right :: f c }

flatten :: forall a f. Functor f => Foldable f => Signal (f a) -> a -> Signal a

Turns a signal of collections of items into a signal of each item inside each collection, in order.

arrayToTree :: forall d. { getId :: d -> NodeID, getParentId :: d -> Maybe NodeID, nodes :: Array d } -> Either String (Tree d)

Build a Tree from an array of nodes with parent pointers

This function constructs a tree from a flat array where each node knows its parent ID. Useful for loading hierarchical data from databases or JSON where parent-child relationships are encoded as references.

Example:

let nodes = [
  {id: "1", parentId: Nothing, name: "Root"},
  {id: "2", parentId: Just "1", name: "Child 1"},
  {id: "3", parentId: Just "1", name: "Child 2"}
]
let tree = arrayToTree {
  nodes: nodes,
  getId: _.id,
  getParentId: _.parentId
}

Returns Left with error message if:

• No root node found (node with Nothing parent)
• Multiple root nodes found
• Circular references detected

genVeitherFrequncy :: forall a errorRows otherGenRows rowList. RowToList (_ :: Tuple Number (Gen a) | otherGenRows) rowList => GenVariantFrequency (_ :: Tuple Number (Gen a) | otherGenRows) Number rowList (_ :: a | errorRows) => { _ :: Tuple Number (Gen a) | otherGenRows } -> Gen (Veither errorRows a)

Generate Veither with user-specified probability given a record whose generators' labels correspond to the Veither's labels

-- Note: type annotations are needed! Otherwise, you'll get compiler errors.
quickCheckGen do
  v <- genVeitherFrequency
     -- first approach: annotate inline
     { "_": genHappyPath :: Gen Int
     , x: genXValues :: Gen (Maybe String)
     , y: pure "foo" :: Gen String
     }
  -- rest of test...

quickCheckGen do
  let
    -- second approach: use a let with annotations before usage
    r :: { "_" :: Gen Int, x :: Gen (Maybe String), y :: Gen String }
    r = { "_": genHappyPath, x: genXValues, y: pure "foo" }
  v <- genVeitherFrequency r
  -- rest of test...

genVeitherUniform :: forall a errorRows otherGenRows rowList. RowToList (_ :: Gen a | otherGenRows) rowList => GenVariantUniform (_ :: Gen a | otherGenRows) rowList (_ :: a | errorRows) => { _ :: Gen a | otherGenRows } -> Gen (Veither errorRows a)

Generate Veither with uniform probability given a record whose generators' labels correspond to the Veither's labels

-- Note: type annotations are needed! Otherwise, you'll get compiler errors.
quickCheckGen do
  v <- genVeitherUniform
     -- first approach: annotate inline
     { "_": genHappyPath :: Gen Int
     , x: genXValues :: Gen (Maybe String)
     , y: pure "foo" :: Gen String
     }
  -- rest of test...

quickCheckGen do
  let
    -- second approach: use a let with annotations before usage
    r :: { "_" :: Gen Int, x :: Gen (Maybe String), y :: Gen String }
    r = { "_": genHappyPath, x: genXValues, y: pure "foo" }
  v <- genVeitherUniform r
  -- rest of test...

customControl :: forall value. { fromStr :: String -> Maybe value, render :: value -> (value -> Effect Unit) -> JSX, toStr :: value -> String } -> value -> CustomControl value

fetchQuery :: forall @output. Flatten output output => { queryFn :: Aff output, queryKey :: QueryKey } -> QueryClient -> Aff output

fromGenericContent :: forall r f. Monad f => { fileContent :: f String, throw :: forall a. String -> f a | r } -> f (Map Char EnrichedPos)

Reads configuration from generic content.

gcast1 :: forall s t a c. Typeable (s a) => Typeable (t a) => c (s a) -> Maybe (c (t a))

logDefault :: forall m a. MonadEffect m => Loggable a => { level :: LogSeverity, severity :: LogSeverity } -> a -> m Unit

makeNetwork_ :: forall l n _e _v d. IsDiagram d => LayoutNetwork l n _e _v => Variant (diagram :: d, group :: Group_, parts :: Iterator_ Part_) -> l -> Effect n

parseDirectionX :: forall r f. Applicative f => { throw :: forall a. String -> f a | r } -> String -> f DirectionX

parseDirectionY :: forall r f. Applicative f => { throw :: forall a. String -> f a | r } -> String -> f DirectionY

parseInt :: forall r f. Applicative f => { throw :: forall a. String -> f a | r } -> String -> f Int

parseOriginX :: forall r f. Applicative f => { throw :: forall a. String -> f a | r } -> String -> f OriginX

parseOriginY :: forall r f. Applicative f => { throw :: forall a. String -> f a | r } -> String -> f OriginY

playAnimation :: forall a. Sprite a => { ignoreIfPlaying :: Boolean, key :: String } -> a -> Effect a

sendDiagnostics :: forall m. MonadAff m => { diagnostics :: Array Diagnostic, uri :: String } -> Connection -> m Unit

SetDimensions :: forall a. { height :: Int, width :: Int } -> a -> EChartsQuery a

size :: forall l d. GraphLayout l => { height :: Number, width :: Number | d } -> l -> D3Eff l

flattenArray :: forall a. Signal (Array a) -> a -> Signal a

Turns a signal of arrays of items into a signal of each item inside each array, in order.

Like flatten, but faster.

setOrientation :: { x :: Number, y :: Number, z :: Number } -> PannerNode -> Effect Unit

setPosition :: { x :: Number, y :: Number, z :: Number } -> AudioListener -> Effect Unit

setPosition :: { x :: Number, y :: Number, z :: Number } -> PannerNode -> Effect Unit

createConsumer :: forall opts opts_. Union opts opts_ ConsumerOptionsImpl => { groupId :: ConsumerGroupId | opts } -> Kafka -> Effect Consumer

createTopics :: { topics :: Array TopicConfig } -> Admin -> Aff Boolean

deleteTopics :: { topics :: Array TopicName } -> Admin -> Aff Unit

guardBranch :: forall e f expr. ToNonEmptyArray f => ToWhere expr e => f (PatternGuard e) -> expr -> GuardedBranch e

Constructs a guarded branch in a value binding or case expressions. This can be used anwhere that takes a ToGuarded constraint.

exampleDecl =
  declValue "countDown" [ binderVar "n" ]
    [ guardBranch [ guardExpr (exprOp (exprIdent "n") [ binaryOp ">" (exprInt 0) ]) ]
        ( exprApp (exprIdent "countDown")
            [ exprOp (exprIdent "n") [ binaryOp "-" (exprInt 1) ] ]
        )
    , guardBranch [ guardExpr (exprIdent "otherwise") ]
        (exprIdent "n")
    ]

subscribe :: forall opts opts_. Union opts opts_ SubscribeOptionsImpl => { topic :: TopicName | opts } -> Consumer -> Aff Unit

addPoint :: { x :: Number, y :: Number } -> PhaserCurveSpline -> Effect PhaserCurveSpline

calculateFacesAt :: { x :: Int, y :: Int } -> PhaserTileMap -> Effect PhaserTileMap

cancelQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

canShowContextMenu_ :: forall graphObject diagram. IsGraphObject graphObject => IsDiagram diagram => Variant (diagram :: diagram, graphObject :: graphObject) -> CommandHandler_ -> Effect Boolean

checkGoldenWithDiff :: { actual :: String, diffDir :: String, goldenDir :: String, testName :: String } -> Aff (Either String Unit)

chmod :: { dest :: String, mode :: String } -> SftpClientRef -> EffectFnAff Unit

createTable :: forall opts opts_. Union opts opts_ CreateTableOptionsImpl => { attributeDefinitions :: Array AttributeDefinition, keySchema :: Array KeySchemaElement, tableName :: TableName | opts } -> DynamoDB -> Aff Foreign

debug :: forall w. Wrapper w => { ignoreProps :: Boolean, verbose :: Boolean } -> w -> Effect String

Returns an HTML-like string of the wrapper for debugging purposes. Useful to print out to the console when tests are not passing when you expect them to.

defaultRenderForest :: { forceTopLabels :: Boolean } -> Forest -> Array JSX

doLayout_ :: forall l d. IsLayout l => Variant (diagram :: d, group :: Group_, parts :: Iterator_ Part_) -> l -> Effect Unit

fastGet :: { local :: String, remote :: String } -> SftpClientRef -> EffectFnAff Unit

fastPut :: { local :: String, remote :: String } -> SftpClientRef -> EffectFnAff Unit

getSession :: { headers :: WebHeaders } -> Api -> Aff SessionWithUser

highlightCollection_ :: forall d p. IsDiagram d => IsPart p => Variant (array :: Array Part_, iterator :: Iterator_ Part_) -> d -> Effect Unit

invalidateQueries :: { queryKey :: QueryKey } -> QueryClient -> Effect Unit

QueryClient methods

isFetching :: { queryKey :: QueryKey } -> QueryClient -> Effect Int

isMutating :: { queryKey :: QueryKey } -> QueryClient -> Effect Int

mkdir :: { path :: String, recursive :: Boolean } -> SftpClientRef -> EffectFnAff Unit

mutedRanges :: { lines :: Array String } -> Map RuleId (Array MutedRange)

Given lines of a code file, finds ranges and/or lines marked with #disable/#enable directives, and returns those ranges grouped by rule.

For example:

-- #disable SomeRule
foo -- #disable AnotherRule
bar
-- #enable SomeRule
baz
qux -- #disable SomeRule

Would return:

{
  SomeRule: [MutedRange 0 3, MutedLine 5],
  AnotherRule: [MutedLine 1]
}

prefetchQuery :: forall @output. Flatten output output => { queryFn :: Aff output, queryKey :: QueryKey } -> QueryClient -> Aff Unit

refetchQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

removeQueries :: { queryKey :: QueryKey } -> QueryClient -> Effect Unit

rename :: { from :: String, to :: String } -> SftpClientRef -> EffectFnAff Unit

requestAddr :: { ipv4 :: String -> Int -> SocketAddress, ipv6 :: String -> Int -> SocketAddress } -> IncomingMessage -> Effect SocketAddress

resetQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

rmdir :: { path :: String, recursive :: Boolean } -> SftpClientRef -> EffectFnAff Unit

scrollTo :: { x :: Int, y :: Int } -> Scrollable -> Effect Unit

scrollTo' :: { animated :: Boolean, x :: Int, y :: Int } -> Scrollable -> Effect Unit

selectCollection_ :: forall d p. IsDiagram d => IsPart p => Variant (array :: Array Part_, iterator :: Iterator_ Part_) -> d -> Effect Unit

sendOtpToEmail :: { email :: UserEmail } -> Client -> Aff AuthResponse

sendOtpToPhone :: { phone :: UserPhone } -> Client -> Aff AuthResponse

sendSms :: { message :: String, msgType :: MessageType, to :: String } -> SmsApi -> Aff Unit

Requests simple sms send.

setSession :: { access_token :: AccessToken, refresh_token :: RefreshToken } -> Client -> Aff AuthResponse

showContextMenu_ :: forall graphObject diagram. IsGraphObject graphObject => IsDiagram diagram => Variant (diagram :: diagram, graphObject :: graphObject) -> CommandHandler_ -> Effect Unit

signInEmail :: { email :: Email, password :: Password } -> Api -> Aff SignInResult

signInSocial :: forall opts opts_. Union opts opts_ SignInSocialOptionsImpl => { provider :: ProviderId | opts } -> Api -> Aff SignInSocialResult

signInWithEmail :: { email :: UserEmail, password :: UserPassword } -> Client -> Aff AuthResponse

signInWithIdToken :: { provider :: OAuthProvider, token :: IdToken } -> Client -> Aff AuthResponse

signInWithPhone :: { password :: UserPassword, phone :: UserPhone } -> Client -> Aff AuthResponse

signUpEmail :: { email :: Email, name :: UserName, password :: Password } -> Api -> Aff SignUpResult

signUpWithEmail :: { email :: UserEmail, password :: UserPassword } -> Client -> Aff AuthResponse

signUpWithPhone :: { password :: UserPassword, phone :: UserPhone } -> Client -> Aff AuthResponse

startServer :: { distDir :: String } -> Int -> Aff Unit

toPlainDate :: { year :: Int } -> PlainMonthDay -> Effect PlainDate

Converts to PlainDate by supplying a year.

exampleToPlainDate :: Effect Unit
exampleToPlainDate = do
  locale <- JS.Intl.Locale.new_ "en-US"
  birthday <- PlainMonthDay.fromString "12-15"
  birthdayIn2030 <- PlainMonthDay.toPlainDate { year: 2030 } birthday
  formatter <- JS.Intl.DateTimeFormat.new [ locale ] { dateStyle: "long" }
  Console.log ("Birthday in 2030: " <> JS.Intl.DateTimeFormat.format formatter birthdayIn2030)

Birthday in 2030: December 15, 2030

toPlainDate :: { day :: Int } -> PlainYearMonth -> Effect PlainDate

Converts to PlainDate by supplying a day.

exampleToPlainDate :: Effect Unit
exampleToPlainDate = do
  locale <- JS.Intl.Locale.new_ "en-US"
  yearMonth <- PlainYearMonth.fromString "2024-01"
  firstDay <- PlainYearMonth.toPlainDate { day: 1 } yearMonth
  formatter <- JS.Intl.DateTimeFormat.new [ locale ] { dateStyle: "long" }
  Console.log (JS.Intl.DateTimeFormat.format formatter firstDay)

January 1, 2024

verifyEmailOtp :: { email :: UserEmail, token :: OTPToken, type :: OTPType } -> Client -> Aff AuthResponse

verifyPhoneOtp :: { phone :: UserPhone, token :: OTPToken, type :: OTPType } -> Client -> Aff AuthResponse

with :: { day :: Int, month :: Int } -> PlainMonthDay -> Maybe PlainMonthDay

Create a modified copy with the given month and day. Returns Nothing if the result would be invalid.

with :: { month :: Int, year :: Int } -> PlainYearMonth -> Maybe PlainYearMonth

Create a modified copy with the given year and month. Returns Nothing if the result would be invalid.

hoistLiftApp :: forall f g a. f (g a) -> f (App g a)

hoistLowerApp :: forall f g a. f (App g a) -> f (g a)

useAff :: forall m a. MonadHooks m => Signal (Aff a) -> m (Signal (Maybe a))

Unwrap Aff Signal. If the order of the results is reversed, it is ignored.

asyncRequest :: forall m a. MonadEffect m => MonadFRP m => Dynamic (Aff a) -> m (Dynamic (RequestState a))

Like asyncRequestMaybe, but without the Nothing case.

latestJust :: forall m a. MonadFRP m => Dynamic (Maybe a) -> m (Dynamic (Maybe a))

Returns a Dynamic that holds the latest Just value of the input Dynamic after execution of this function. If the input currently has value Nothing, the resulting Dynamic will have the value Nothing until the input changes to a Just.

The resulting Dynamic changes when the input changes to a value that is a Just, and doesn't change when the input changes to Nothing.

Query :: forall a. (List (SqlDeclF a)) -> a -> SqlQueryF a

useAff :: forall m a. MonadHooks m => Signal (Aff a) -> m (Signal (Maybe a))

Unwrap Aff Signal. If the order of the results is reversed, it is ignored.

transpose' :: forall a. NonEmptyArray (Array a) -> Maybe (NonEmptyArray (Array a))

transpose' is identical to transpose other than that the inner arrays are each a standard Array and not a NonEmptyArray. However, the result is wrapped in a Maybe to cater for the case where the inner Array is empty and must return Nothing.

factor :: forall a. Eq a => Ord a => EuclideanRing a => IntLiftable a => Divisible a => Leadable a => Polynomial (Ratio a) -> Array (Polynomial (Ratio a))

At least one non-constant polynomial factor if the univariate input, with rational coefficients, is not irreductible, empty array if it is.

inParallel :: Array (Flow Unit) -> Flow (Array (Control Unit))

extractDatasetOverlays :: forall r. Array (Record (DatasetCommonRow r)) -> Maybe (Array Foreign)

Extract dataset overlays for every dataset in the config. Covers the same categories as extractDatasetOverlay: gradient/pattern colors, scriptable color functions, and image point styles. Returns Nothing if no dataset has any non-JSON values, signalling the overlay merge can be skipped entirely.

injectElement :: forall e. Attr e Self (Element -> Effect Unit) => (Element -> Effect Unit) -> Event (Attribute e)

Sets a listener that injects a primitive DOM element into a closed scope immediately after element creation. Importantly, this does not happen on the same tick as the element creation but rather during the next DOM tick. This is to guarantee that element creation happens before trying to use the element. In practice this delay will be on the order of microseconds but it can veer into milliseconds if the UI thread is particularly busy.

injectElementT :: forall e te. Attr e SelfT (te -> Effect Unit) => (te -> Effect Unit) -> Event (Attribute e)

A typesafe version of injectElement that uses SelfT instead of Self.

integratePositions :: forall r. Array (Record r) -> Number -> Effect Unit

Integrate positions: apply velocity decay and update positions

integratePositions :: forall r. Array (Record r) -> Number -> Effect Unit

Integrate positions: apply velocity decay and update positions Call this once per tick after all forces have been applied

keyDown_ :: forall eleemnt. (KeyboardEvent -> Effect Unit) -> Event (Attribute eleemnt)

Sets a keydown listener for an element using a constant listener.

keyPress_ :: forall eleemnt. (KeyboardEvent -> Effect Unit) -> Event (Attribute eleemnt)

Sets a keypress listener for an element using a constant listener.

keyUp_ :: forall eleemnt. (KeyboardEvent -> Effect Unit) -> Event (Attribute eleemnt)

Sets a keyup listener for an element using a constant listener.

textInput_ :: forall e. (String -> Effect Unit) -> Event (Attribute e)

Sets a text-based input listener for an element using a constant listener.

appendNodes :: forall m p f. Foldable f => MonadEffect m => NodeOp p => f (m Node) -> p -> m p

Extracts child nodes from a Foldable of continuations and appends them to a parent node. Returns the given parent node.

stores :: forall m. MonadEffect m => Object (Maybe String) -> Version -> m Version

Specify the database schema (object stores and indexes) for a certain version.

Documentation: dexie.org/docs/Version/Version.stores()

stores_ :: forall m. MonadEffect m => Object (Maybe String) -> Version -> m Unit

Version of stores without a return value.

concat :: forall h. Array (STBuffer h) -> ST h (STBuffer h)

buildGraph :: forall node. Ord node => Array (TaskNode node) -> Graph node (TaskNode node)

Build a Data.Graph from task nodes Graph k v = Graph (Map k (Tuple v (List k)))

Image :: forall a. (List (Inline a)) -> String -> Inline a

Link :: forall a. (List (Inline a)) -> LinkTarget -> Inline a

checkbox_ :: (Boolean -> Effect Unit) -> Event (Attribute Input_)

Sets a checkbox listener for an element using a constant listener.

numeric_ :: (Number -> Effect Unit) -> Event (Attribute Input_)

Sets a numeric input listener for an element using a constant listener.

slider_ :: (Number -> Effect Unit) -> Event (Attribute Input_)

Sets a slider listener for an element using a constant listener.

processSmartQualifiedNameClass :: SmartQualifiedName (ProperName ProperNameType_ClassName) -> App (QualifiedName (ProperName ProperNameType_ClassName))

processSmartQualifiedNameKind :: SmartQualifiedName (ProperName ProperNameType_TypeConstructor) -> App (QualifiedName (ProperName ProperNameType_TypeConstructor))

processSmartQualifiedNameOp :: SmartQualifiedName (OpName OpNameType_ValueOpName) -> App (QualifiedName (OpName OpNameType_ValueOpName))

processSmartQualifiedNameType :: SmartQualifiedName (ProperName ProperNameType_TypeConstructor) -> App (QualifiedName (ProperName ProperNameType_TypeConstructor))

processSmartQualifiedNameTypeOp :: SmartQualifiedName (OpName OpNameType_TypeOpName) -> App (QualifiedName (OpName OpNameType_TypeOpName))

oneOf :: forall f g a. Foldable f => Plus g => f (g a) -> g a

Combines a collection of elements using the Alt operation.

oneOf :: forall m f a. MonadGen m => Foldable1 f => f (m a) -> m a

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

parOneOf :: forall a t m f. Parallel f m => Alternative f => Foldable t => Functor t => t (m a) -> m a

Race a collection in parallel.

unwrapCofree :: forall f w a. ComonadCofree f w => w a -> f (w a)

wrapFree :: forall f m a. MonadFree f m => f (m a) -> m a

normalizeEncodingFlat' :: forall symTag rowVarEnc rowVar. IsVariantEncodedFlat symTag rowVarEnc rowVar => Proxy (VariantEncodedFlat symTag rowVarEnc) -> Proxy (Variant rowVar)

choice :: forall a g f. Foldable f => Alt g => Plus g => f (g a) -> g a

oneOf :: forall a m f. Foldable f => Alternative m => f (m a) -> m a

onRouteChangeStart :: (String -> Effect Unit) -> Effect (Effect Unit)

routeChangeComplete :: (String -> Effect Unit) -> Effect (Effect Unit)

sumV :: forall f g a. Foldable f => Additive g => Semiring a => f (g a) -> g a

Sum a collection of vectors

all :: forall a. Array (Promise a) -> Effect (Promise (Array a))

race :: forall f m a. Parallel f m => Alternative f => Array (m a) -> m a

Run multiple computations in parallel, and return the fastest To collect all results, use inParallel instead

all :: forall a. Array (Promise a) -> Effect (Promise (Array a))

restoreM :: forall base m stM a. MonadBaseControl base m stM => base (stM a) -> m a

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

Defines a hyperlink [No Attributes]

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

Creates a hyperlink element [No Attributes]

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

Defines an abbreviation [No Attributes]

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

Defines contact information for the author/owner of a document [No Attributes]

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

Defines an alternative representation of a glyph in a font [No Attributes]

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

Defines a set of glyph substitutions for an altGlyph element [No Attributes]

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

Defines a substitution for a specific glyph in an altGlyphDef element [No Attributes]

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

Defines self-contained content, like blog posts or news articles [No Attributes]

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

Defines content aside from the content it is placed in [No Attributes]

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

Defines sound content, like music or other audio streams [No Attributes]

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

Defines bold text [No Attributes]

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

Defines text directionality for its children [No Attributes]

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

Defines text directionality [No Attributes]

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

Defines a section that is quoted from another source [No Attributes]

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

Defines the document's body [No Attributes]