Search results

snoc :: forall a. Array a -> a -> Array a

Append an element to the end of an array, creating a new array.

snoc [1, 2, 3] 4 = [1, 2, 3, 4]

genericWriteForeignUntaggedProductRep :: forall rep. WriteGenericUntaggedProduct rep => Array Foreign -> rep -> Array Foreign

_serialize :: forall a. ABIData a => Array EncodedValue -> a -> Array EncodedValue

clampToWindow :: Array IndexedTuple -> Int -> Array IndexedTuple

getTransactionsForWeekDay :: Array TransactionRec -> Weekday -> Array TransactionRec

transactionsForMerchant :: (Array TransactionRec) -> String -> Array TransactionRec

difference :: forall a. Eq a => Array a -> Array a -> Array a

Delete the first occurrence of each element in the second array from the first array, creating a new array.

difference [2, 1] [2, 3] = [1]

Running time: O(n*m), where n is the length of the first array, and m is the length of the second.

intersect :: forall a. Eq a => Array a -> Array a -> Array a

Calculate the intersection of two arrays, creating a new array. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

intersect [1, 1, 2] [2, 2, 1] = [1, 1, 2]

union :: forall a. Eq a => Array a -> Array a -> Array a

Calculate the union of two arrays. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

Running time: O(n^2)

union [1, 2, 1, 1] [3, 3, 3, 4] = [1, 2, 1, 1, 3, 4]

concat' :: forall buf m. MutableBuffer buf m => Array buf -> Int -> m buf

Concatenates a list of buffers, combining them into a new buffer of the specified length.

difference :: forall a. Eq a => Array a -> Array a -> Array a

Like difference in Data.Array but removes all of the elements from the first array which have a match in the second array.

difference [2, 1, 2] [2, 3] == [1,2] -- Data.Array
difference [2, 1, 2] [2, 3] == [1]   -- Data.Array.Extra.All

difference :: forall a. Eq a => Array a -> Array a -> Array a

Re-export of difference from Data.Array

difference [2, 1] [2, 3] = [1]

unsafeConsArray :: forall a. Array a -> Array a -> Array a

unsafeSnocArray :: forall a. Array a -> Array a -> Array a

_idiomArray :: Array String -> Array String -> Array String

_orderToWordArray :: Array String -> Array String -> Array String

anyOf :: forall v me. MonadEffect me => IndexedValue v => Array v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.anyOf()

idiomArray :: Array String -> Array IdiomOptions -> Array String

Use this over the underscore version

merge :: Array Int -> Array Int -> Array Int

noneOf :: forall v me. MonadEffect me => IndexedValue v => Array v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.noneOf()

orderToWordArray :: Array String -> Array OrderOptions -> Array String

Use this over the underscore version

selector'' :: Array Predicate -> Path Selector -> Array String

play :: Array Int -> Array Int -> Array Cycle

Deduces the disjoint cycles between a base and one of its permutations

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToCollatorOptions (Record CollatorOptions) (Record provided) (Record CollatorOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToDateTimeFormatOptions (Record DateTimeFormatOptions) (Record provided) (Record DateTimeFormatOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. Defaults (Record DisplayNamesOptions'Optional) (Record provided) (Record DisplayNamesOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToDurationFormatOptions (Record DurationFormatOptions) (Record provided) (Record DurationFormatOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToListFormatOptions (Record ListFormatOptions) (Record provided) (Record ListFormatOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToNumberFormatOptions (Record NumberFormatOptions) (Record provided) (Record NumberFormatOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToPluralRulesOptions (Record PluralRulesOptions) (Record provided) (Record PluralRulesOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToRelativeTimeFormatOptions (Record RelativeTimeFormatOptions) (Record provided) (Record RelativeTimeFormatOptions) => Array Locale -> Record provided -> Array String

supportedLocalesOf :: forall provided. ConvertOptionsWithDefaults ToSegmenterOptions (Record SegmenterOptions) (Record provided) (Record SegmenterOptions) => Array Locale -> Record provided -> Array String

anyOfIgnoreCase :: forall me. MonadEffect me => Array String -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.anyOfIgnoreCase()

getPricingForWeekdays :: Array Weekday -> Array TransactionRec -> Array Number

startsWithAnyOf :: forall me. MonadEffect me => Array String -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.startsWithAnyOf()

startsWithAnyOfIgnoreCase :: forall me. MonadEffect me => Array String -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.startsWithAnyOfIgnoreCase()

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

Array literal

flipScalarMul :: forall k f. VectorField f k => f k -> k -> f k

downTo :: forall a. HasFromInt a => HasLess a => HasToInt a => a -> a -> Array a

Creates an array that ranges from the given upper bound down to the lower bound.

3 :downTo 1 -- [3, 2, 1]
1 :downTo 1 -- [1]
1 :downTo 3 -- []

range :: forall a. Range a => a -> a -> Array a

scalarDiv :: forall f a. Functor f => EuclideanRing a => f a -> a -> f a

Right scalar division

V2 6.0 9.0 ^/ 3.0 = V2 2.0 3.0

scalarR :: forall f a. Functor f => Semiring a => f a -> a -> f a

Right scalar multiplication

V2 1.0 2.0 ^* 3.0 = V2 3.0 6.0

snoc :: forall f a. Container f => f a -> a -> f a

upTo :: forall a. HasFromInt a => HasGreater a => HasToInt a => a -> a -> Array a

Creates an array that ranges from the given lower bound down to the upper bound.

1 :upTo 3 -- [1, 2, 3]
1 :upTo 1 -- [1]
3 :upTo 1 -- []

voidLeft :: forall f a b. Functor f => f a -> b -> f b

A version of voidRight with its arguments flipped.

functorDecorateFlipped :: forall b a f. Functor f => Decorate b a => f a -> b -> f b

unsafeIndex :: forall a. Partial => Array a -> Int -> a

Find the element of an array at the specified index.

unsafePartial $ unsafeIndex ["a", "b", "c"] 1 = "b"

Using unsafeIndex with an out-of-range index will not immediately raise a runtime error. Instead, the result will be undefined. Most attempts to subsequently use the result will cause a runtime error, of course, but this is not guaranteed, and is dependent on the backend; some programs will continue to run as if nothing is wrong. For example, in the JavaScript backend, the expression unsafePartial (unsafeIndex [true] 1) has type Boolean; since this expression evaluates to undefined, attempting to use it in an if statement will cause the else branch to be taken.

shouldContain :: forall m f a. MonadThrow Error m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

shouldNotContain :: forall m f a. MonadThrow Error m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

shouldNotReturn :: forall m t. MonadThrow Error m => Eq t => Show t => m t -> t -> m Unit

Asserts that m t does not return t

shouldReturn :: forall m t. MonadThrow Error m => Eq t => Show t => m t -> t -> m Unit

Asserts that m t returns t

scaleU :: forall repr u. UnitArith repr => repr u -> Number -> repr u

Scale a unit value by a unitless factor

scaleUnitOp :: forall repr u. UnitArith repr => repr u -> Number -> repr u

Scale a unit value: (px 10.0) *~ 2.0

addAllFirst :: forall a f. Foldable f => f a -> Array a -> Array a

addAllLast :: forall a f. Foldable f => f a -> Array a -> Array a

rsingleton :: forall f g s v r. RSingleton f g s => Cons s v () r => Lacks s () => g s -> v -> f r

singleton :: forall v s r g f. Cons s v () r => Lacks s () => RSingleton f g s => g s -> v -> f r

unsafeForeignFunction :: forall a. Array String -> String -> a

unsafeForeignFunction :: forall a. Array String -> String -> a

unsafeForeignProcedure :: forall a. Array String -> String -> a

unsafeForeignProcedure :: forall a. Array String -> String -> a

addClasses :: forall m n f. MonadEffect m => ElementOp n => Foldable f => f String -> n -> m n

chain :: forall m a. Testable m => m a -> Element -> m a

A flipped version of within'. In its operator form $$ this function can be used similarly to function application, for example:

button <- find "button"
click $$ button

encodeRepArgs :: forall prodSpec r. EncodeRepArgs prodSpec r => prodSpec -> r -> Array Json

fill :: forall a. a -> Int -> Array a

finalCons :: forall rightParameter leftParameter. leftParameter -> rightParameter -> Array QueryParameter

getAttrs :: forall d @a. Array String -> d -> a

getUnsafe :: forall d @t. Array String -> d -> t

meets :: forall a b. Intersectable a b => a -> b -> Array Point

meets :: forall a b. Intersectable a b => a -> b -> Array Point

nth :: forall a. Array a -> Int -> a

putErrorsInPaths :: forall a b. PutErrorsInPaths a b => Array GqlError -> a -> b

rmCss :: forall m n f. MonadEffect m => HTMLElementOp n => Foldable f => f String -> n -> m n

setAttrs :: forall e f m. Foldable f => ElementOp e => MonadEffect m => f (String /\ String) -> e -> m e

Sets the attributes of an element. Existing attributes of the same names are overwritten. New names create new attributes. The element is returned.

setCss :: forall m n f. MonadEffect m => HTMLElementOp n => Foldable f => f (String /\ String) -> n -> m n

shouldContain :: forall m f a. MonadEffect m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

shouldEqualM :: forall m a. MonadThrow Error m => Eq a => Show a => m a -> a -> m Unit

shouldNotContain :: forall m f a. MonadEffect m => Show a => Eq a => Show (f a) => Foldable f => f a -> a -> m Unit

shouldNotEqualM :: forall m a. MonadThrow Error m => Eq a => Show a => m a -> a -> m Unit

toOutputChannelCount :: forall numberOfOutputs outputChannelCount. ValidateOutputChannelCount numberOfOutputs outputChannelCount => numberOfOutputs -> outputChannelCount -> Array Int

unsafeIndex :: forall a. Array a -> Int -> a

The element at index i, unchecked (no bounds test — out of range traps). On wasm: the ArrayIndex intrinsic (array.get; the element is already an eqref, no box).

withErrorMessage :: forall m a. Parsing m => m a -> String -> m a

addLit :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

addLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

dividedByN :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

Divide by a literal number

divLit :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

divLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

minusN :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

Subtract a literal number

mulLit :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

mulLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

plusN :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

Add a literal number: _xplusN50.0

subLit :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

subLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

timesN :: forall repr. NumExpr repr => repr Number -> Number -> repr Number

Multiply by a literal number: _indextimesN40.0

pipeInto :: forall m. MonadAff m => m String -> String -> m String

getNodesByIds :: forall node link. Array NodeID -> GraphModel node link -> Array node

Get multiple nodes by their IDs Returns only the nodes that exist (filters out missing IDs)

applyRules :: forall node. Array (NodeRule node) -> Array node -> Array node

Apply rules to an array of nodes (first matching rule wins).

For each node, finds the first rule whose selector matches, then applies that rule's transform. If no rule matches, the node is returned unchanged.

This is CSS-like cascade semantics - rule order matters.

applyRules :: forall node. Array (NodeRule node) -> Array node -> Array node

Apply rules to nodes (first matching rule wins) - creates new array

styleAttr :: forall f. Foldable f => f (String /\ String) -> Array (String /\ String) -> Array (String /\ String)

toGraphQLArgumentImplementationRecord :: forall list row proxy. ToGraphQLArgumentImplementationRecord list row => proxy list -> Record row -> Array Argument

expectM :: forall m. MonadEffect m => m Boolean -> String -> m Unit

classAttr :: forall f. Foldable f => f String -> Array (String /\ String) -> Array (String /\ String)

textField :: forall m f. MonadEffect m => Foldable f => f (String /\ String) -> String -> m HTMLInputElement

Create a plain ol' input field of type text with a default value.

many :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

Attempt a computation multiple times, returning as many successful results as possible (possibly zero).

The Lazy constraint is used to generate the result lazily, to ensure termination.

some :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

Attempt a computation multiple times, requiring at least one success.

The Lazy constraint is used to generate the result lazily, to ensure termination.

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

Returns a contiguous sequence of elements from the first value to the second value (inclusive).

enumFromTo 0 3 = [0, 1, 2, 3]
enumFromTo 'c' 'a' = ['c', 'b', 'a']

The example shows Array return values, but the result can be any type with an Unfoldable1 instance.

advance :: forall p c m. Position p c m => c -> p -> m p

many :: forall a f. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

refillSource :: forall s d c m. Source s d c m => d -> s -> m s

setVal :: forall el v m. HTMLValueContainerOp el v => MonadEffect m => v -> el -> m el

some :: forall a f. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

convertOption :: forall field from to sproxy. ConvertOption field from to => sproxy field -> from -> to

index :: forall f a b. Representable f a => f b -> (a -> b)

invokeAction :: forall m res args ctrl act. RemoteAction act ctrl args res => MonadReader Visualforce m => MonadAff m => MonadError RemoteActionError m => IsSymbol ctrl => Encode args => Decode res => act -> args -> m res

Function that invoke the action defined by referring to contraints which holds details about the correct controller to invoke. Example:

data PCMRequests = ..

data CreatePCMRequests = CreatePCMRequests

instance remoteActionCreatePCMs :: RemoteAction CreatePCMRequests "PCMMassController.createRecords" PCMRequests Unit

createPCMRequest :: Visualforce -> PCMRequests -> Aff (Either RemoteActionError Unit)
createPCMRequest vf rec =  runReaderT (runExceptT $ invokeAction CreatePCMRequests rec) vf

applyFirst :: forall a b f. Apply f => f a -> f b -> f a

Combine two effectful actions, keeping only the result of the first.

alt :: forall f a. Alt f => f a -> f a -> f a

cons :: forall a. a -> Array a -> Array a

Attaches an element to the front of an array, creating a new array.

cons 1 [2, 3, 4] = [1, 2, 3, 4]

Note, the running time of this function is O(n).

delete :: forall a. Eq a => a -> Array a -> Array a

Delete the first element of an array which is equal to the specified value, creating a new array.

delete 7 [1, 7, 3, 7] = [1, 3, 7]
delete 7 [1, 2, 3] = [1, 2, 3]

Running time: O(n)

delete :: forall a. Eq a => a -> NonEmptyArray a -> Array a

insert :: forall a. Ord a => a -> Array a -> Array a

Insert an element into a sorted array.

insert 10 [1, 2, 20, 21] = [1, 2, 10, 20, 21]

intersperse :: forall a. a -> Array a -> Array a

Inserts the given element in between each element in the array. The array must have two or more elements for this operation to take effect.

intersperse " " [ "a", "b" ] == [ "a", " ", "b" ]
intersperse 0 [ 1, 2, 3, 4, 5 ] == [ 1, 0, 2, 0, 3, 0, 4, 0, 5 ]

If the array has less than two elements, the input array is returned.

intersperse " " [] == []
intersperse " " ["a"] == ["a"]

choose :: forall m a. MonadGen m => m a -> m a -> m a

Creates a generator that outputs a value chosen from one of two existing existing generators with even probability.

shouldEqual :: forall m t. MonadThrow Error m => Show t => Eq t => t -> t -> m Unit

shouldNotEqual :: forall m t. MonadThrow Error m => Show t => Eq t => t -> t -> m Unit

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

orFail :: forall m a. Monad m => m a -> Maybe a -> m a

awrite :: forall s r m. Refer s r => MonadEffect m => s -> r -> m Unit

fwrite :: forall m r s. MonadEffect m => Refer s r => r -> s -> m Unit

sampleOnRight_ :: forall event a b. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

addU :: forall repr u. UnitArith repr => repr u -> repr u -> repr u

Add two values with the same unit

addUnitOp :: forall repr u. UnitArith repr => repr u -> repr u -> repr u

subU :: forall repr u. UnitArith repr => repr u -> repr u -> repr u

Subtract two values with the same unit

subUnitOp :: forall repr u. UnitArith repr => repr u -> repr u -> repr u

addFirst :: forall a. a -> Array a -> Array a

addLast :: forall a. a -> Array a -> Array a

sampleOn_ :: forall b a event. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

unshift :: forall a b. a -> Array b -> Array b

applyFirst :: forall v1 v0 f c. HasApply c f => HasConst c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v0) => f v0 -> f v1 -> f v0

applyFirstMatch :: forall node. Array (NodeRule node) -> node -> node

Apply the first matching rule to a single node.

Returns the node unchanged if no rule matches.

diffCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

diffStackCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

leading :: forall a. OverLeadingComments a => Array (Comment LineFeed) -> a -> a

Attaches leading comments to a CST node.

max1 :: forall f a. Ord1 f => f a -> f a -> f a

min1 :: forall f a. Ord1 f => f a -> f a -> f a

onIntegrityError :: forall m a. MonadError PGError m => m a -> m a -> m a

onlyDifferentCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

add :: forall f a. Additive f => Semiring a => f a -> f a -> f a

Vector addition

alt :: forall f a. Alternative f => f a -> f a -> f a

appendChild :: forall m p c. MonadEffect m => NodeOp c => NodeOp p => c -> p -> m Unit

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.

applyFirst :: forall a d. Syntax d => d a -> d Unit -> d a

This variant of <*> ignores its right result. In contrast to its counterpart derived from the Apply class, the ignored parts have type d Unit rather than d b because otherwise information relevant for pretty-printing would be lost.

compareDocumentPositionBits :: forall m n1 n2. MonadEffect m => NodeOp n1 => NodeOp n2 => n1 -> n2 -> m Int

cons :: forall a. a -> SortedArray a -> Array a

Convenience function for adding an item at the beginning of the sorted array. The result is a plain Array. Use insert if you need the result to also be a SortedArray.

contains :: forall m p c. MonadEffect m => NodeOp c => NodeOp p => c -> p -> m Boolean

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

diff :: forall p d a. Affine p d => Ring a => p a -> p a -> d a

The vector from the first point to the second.

diffCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

diffStackCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

fromFoldableL :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldl.

fromFoldableL [] [1,2,3,4]  == [4,3,2,1]
fromFoldableL [0] [1,2,3,4] == [4,3,2,1,0]

fromFoldableR :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldr.

fromFoldableR [] [1,2,3,4]  == [1,2,3,4]
fromFoldableR [5] [1,2,3,4] == [1,2,3,4,5]

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

isEqualNode :: forall m n1 n2. MonadEffect m => NodeOp n1 => NodeOp n2 => n1 -> n2 -> m Boolean

meets :: forall a b. Intersectable a b => a -> b -> Array (Point 2)

moveBy :: forall p d a. Affine p d => Semiring a => p a -> d a -> p a

Add a vector to a point.

moveByNeg :: forall p d a. Affine p d => Ring a => p a -> d a -> p a

Subtract a vector from a point.

onlyDifferentCompare :: forall m t. MonadEffect m => MonadThrow Error m => Diffable t => t -> t -> m Unit

removeChild :: forall m p c. MonadEffect m => NodeOp c => NodeOp p => c -> p -> m Unit

removeFromArray :: forall a. HasUuid a => a -> Array a -> Array a

shouldEqual :: forall m t. MonadEffect m => Show t => Eq t => t -> t -> m Unit

shouldNotEqual :: forall m t. MonadEffect m => Show t => Eq t => t -> t -> m Unit

sub :: forall f a. Additive f => Ring a => f a -> f a -> f a

Vector subtraction

unsafeCons :: forall a. a -> Array a -> Array a

unsafeSnoc :: forall a. a -> Array a -> Array a

yup :: forall m a. MonadNope m => m a -> m a -> m a

applySecond :: forall a b f. Apply f => f a -> f b -> f b

Combine two effectful actions, keeping only the result of the second.

noteM :: forall err m a. MonadThrow err m => m err -> Maybe a -> m a

mulNat :: forall proxy a b c. ProductNat a b c => proxy a -> proxy b -> proxy c

plus :: forall proxy a b c. SumInt a b c => proxy a -> proxy b -> proxy c

plusNat :: forall proxy a b c. SumNat a b c => proxy a -> proxy b -> proxy c

powNat :: forall proxy a b c. ExponentiationNat a b c => proxy a -> proxy b -> proxy c

> powNat d2 d3
8 -- : NProxy D8

a raised to the power of b a^b = c

prod :: forall proxy a b c. ProductInt a b c => proxy a -> proxy b -> proxy c

sampleOnLeft_ :: forall event a b. IsEvent event => event a -> event b -> event b

concat :: forall xs ys zs lproxy. Concat xs ys zs => lproxy xs -> lproxy ys -> lproxy zs

delete :: forall store m session. SessionStore store m session => store -> SessionID -> m Unit

drop :: forall n xs ys lproxy iproxy. Drop n xs ys => iproxy n -> lproxy xs -> lproxy ys

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

take :: forall n xs ys lproxy iproxy. Take n xs ys => iproxy n -> lproxy xs -> lproxy ys

zip :: forall x y z lproxy. Zip x y z => lproxy x -> lproxy y -> lproxy z

applySecond :: forall v1 v0 f c. HasApply c f => HasConst c => HasIdentity c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v1) => ObjectOf c (c v0 (c v1 v1)) => ObjectOf c (c (c v1 v1) (c v0 (c v1 v1))) => f v0 -> f v1 -> f v1

drawImage :: forall m p. MonadCanvasAction m => ToPos Number p => p -> CanvasImageSource -> m Unit

drawImageScale :: forall m r. MonadCanvasAction m => ToRegion Number r => r -> CanvasImageSource -> m Unit

Draw an image, scaled to fit the provided region

putImageData :: forall m p. MonadCanvasAction m => ToPos Number p => p -> ImageData -> m Unit

Render image data on the canvas. The first argument (p) is the point on the canvas to place the topleft of the data.

strokeWith :: forall m r. MonadCanvasAction m => CanvasStyle r => r -> Path2D -> m Unit

Stroke a Path2D with the given style

getOrAlt :: forall v s r' r l h g f. Alternative h => Cons s v r' r => RowToList r l => RGetOrAlt f g s l r => g s -> f r -> h v

above :: forall v me. MonadEffect me => IndexedValue v => v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.above()

aboveOrEqual :: forall v me. MonadEffect me => IndexedValue v => v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.aboveOrEqual()

below :: forall v me. MonadEffect me => IndexedValue v => v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.below()

belowOrEqual :: forall v me. MonadEffect me => IndexedValue v => v -> WhereClause -> me Collection

Documentation: dexie.org/docs/WhereClause/WhereClause.belowOrEqual()

cons :: forall parameter. parameter -> Array QueryParameter -> Array QueryParameter

decodeJsonResponseStream :: forall c m. MonadAff m => DecodeJsonStream c Unit (MaybeT (ExceptT (DecodeException c Unit) (StateT (Tuple (Tuple ParseState (SourcePosition (InPlaceSource String) LineColumnPosition)) (Either c Unit)) m))) => EndJsonDecode c Unit (ExceptT (DecodeException c Unit) (StateT (Tuple (Tuple ParseState (SourcePosition (InPlaceSource String) LineColumnPosition)) (Either c Unit)) m)) => c -> Response -> m Unit