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