Search results

formatInt :: String -> Int -> String

compile :: forall a. String -> a -> String

Compile a string into a template which can be applied to a context.

This function should be partially applyied, resulting in a compiled function which can be reused, instead of compiling the template on each application.

Note: This function performs no verification on the template string, so it is recommended that an appropriate type signature be given to the resulting function. For example:

hello :: { name :: String } -> String
hello = compile "Hello, {{name}}!"

declareFlowType' :: forall a. HasFlowRep a => String -> a -> String

A convenience function for declaring types taking a concrete value over a proxy.

generateFlowType' :: forall a. HasFlowRep a => String -> a -> String

A convenience function for generating types taking a concrete value over a proxy.

s :: forall a. String -> a -> String

Separator

power :: forall m. Monoid m => m -> Int -> m

Append a value to itself a certain number of times. For the Multiplicative type, and for a non-negative power, this is the same as normal number exponentiation.

If the second argument is negative this function will return mempty (unlike normal number exponentiation). The Monoid constraint alone is not enough to write a power function with the property that power x n cancels with power x (-n), i.e. power x n <> power x (-n) = mempty. For that, we would additionally need the ability to invert elements, i.e. a Group.

power [1,2] 3    == [1,2,1,2,1,2]
power [1,2] 1    == [1,2]
power [1,2] 0    == []
power [1,2] (-3) == []

spy :: forall a. DebugWarning => String -> a -> a

Logs any value and returns it, using a "tag" or key value to annotate the traced value. Useful when debugging something in the middle of a expression, as you can insert this into the expression without having to break it up.

repeat :: forall a. Monoid a => a -> Int -> a

power :: forall g. Group g => g -> Int -> g

Append a value (or its inverse) to itself a certain number of times.

For the Additive Int type, this is the same as multiplication.

pow :: forall a. Semiring a => a -> Int -> a

Integer power

getProperty :: forall o v. String -> o -> v

Get the property with the given name form the given object If property does not exist, will be undefined (see F.S.Undef)

named :: forall o. String -> o -> o

Return the object with a custom name Notes:

• name is a readonly property, so we define over it
• quietly mutates the input - use immediately after creation

removeProperty :: forall o. String -> o -> o

runFn0 :: forall b a. String -> a -> b

taggedLog :: forall a. String -> a -> a

For a string t and value a, calls console.log(t, a), then returns a.

taggedLogShow :: forall a. Show a => String -> a -> a

For a string t and value a, calls console.log(t, (show a)), then returns a.

unsafeGetField :: forall b a. String -> a -> b

attr :: forall m. Testable m => String -> m String

Returns the given attribute of the current-context element.

destroyUnit :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Destroy pointer x. For example, drop a sine wave oscillator from an audio graph. Note that this does not invoke garbage collection - it just removes the reference to the node, allowing it to be garbage collected.

effect0 :: forall b a. String -> a -> b

m :: forall bem. WithModifiers bem => String -> bem -> bem

makeLoopBufWithDeferredBuffer :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make a looping audio buffer node with a deferred buffer.

makePeriodicOscWithDeferredOsc :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make a periodic oscillator.

makePlayBufWithDeferredBuffer :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make an audio buffer node with a deferred buffer.

question :: forall m e. MonadAff (console :: CONSOLE, readline :: READLINE | e) m => MonadAsk Interface m => String -> m String

Prompt for input, then read a line

runThisFn0 :: forall a this. String -> this -> a

translate :: forall x y. IsLength x => IsLength y => x -> y -> String

translate (px 40.0) (px 30.0) → "translate(40px,30px)"

unsafeField :: forall val obj. String -> obj -> val

unsafeLog :: forall a. String -> a -> a

Unsafely write a string to the console.

unsafeLog "unsafe!" unit -- unit (logs "unsafe!")

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

append :: forall a. Semigroup a => a -> a -> a

conj :: forall a. HeytingAlgebra a => a -> a -> a

const :: forall a b. a -> b -> a

Returns its first argument and ignores its second.

const 1 "hello" = 1

It can also be thought of as creating a function that ignores its argument:

const 1 = \_ -> 1

disj :: forall a. HeytingAlgebra a => a -> a -> a

div :: forall a. EuclideanRing a => a -> a -> a

gcd :: forall a. Eq a => EuclideanRing a => a -> a -> a

The greatest common divisor of two values.

genericAdd :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the add member from the Semiring type class.

genericAdd' :: forall a. GenericSemiring a => a -> a -> a

genericAppend :: forall a rep. Generic a rep => GenericSemigroup rep => a -> a -> a

A Generic implementation of the append member from the Semigroup type class.

genericAppend' :: forall a. GenericSemigroup a => a -> a -> a

genericConj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the conj member from the HeytingAlgebra type class.

genericConj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericDisj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the disj member from the HeytingAlgebra type class.

genericDisj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericImplies :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the implies member from the HeytingAlgebra type class.

genericImplies' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericMul :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the mul member from the Semiring type class.

genericMul' :: forall a. GenericSemiring a => a -> a -> a

genericSub :: forall a rep. Generic a rep => GenericRing rep => a -> a -> a

A Generic implementation of the sub member from the Ring type class.

genericSub' :: forall a. GenericRing a => a -> a -> a

implies :: forall a. HeytingAlgebra a => a -> a -> a

lcm :: forall a. Eq a => EuclideanRing a => a -> a -> a

The least common multiple of two values.

leftDiv :: forall a. DivisionRing a => a -> a -> a

Left division, defined as leftDiv a b = recip b * a. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

max :: forall a. Ord a => a -> a -> a

Take the maximum of two values. If they are considered equal, the first argument is chosen.

min :: forall a. Ord a => a -> a -> a

Take the minimum of two values. If they are considered equal, the first argument is chosen.

mod :: forall a. EuclideanRing a => a -> a -> a

mul :: forall a. Semiring a => a -> a -> a

rightDiv :: forall a. DivisionRing a => a -> a -> a

Right division, defined as rightDiv a b = a * recip b. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

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

crashWith :: forall a. Partial => String -> a

A partial function which crashes on any input with the specified message.

unsafeCrashWith :: forall a. String -> a

A function which crashes with the specified error message.

unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

impossible :: forall a. String -> a

sans :: forall m a b. At m a b => a -> m -> m

add :: forall x y z. Add x y z => x -> y -> z

and :: forall b1 b2 b3. And b1 b2 b3 => b1 -> b2 -> b3

div :: forall x y z. Div x y z => x -> y -> z

eq :: forall b1 b2 b3. Eq b1 b2 b3 => b1 -> b2 -> b3

gcd :: forall x y z. GCD x y z => x -> y -> z

imp :: forall b1 b2 b3. Imp b1 b2 b3 => b1 -> b2 -> b3

max :: forall x y z. Max x y z => x -> y -> z

min :: forall x y z. Min x y z => x -> y -> z

mod :: forall x y r. Mod x y r => x -> y -> r

mul :: forall x y z. Mul x y z => x -> y -> z

or :: forall b1 b2 b3. Or b1 b2 b3 => b1 -> b2 -> b3

sub :: forall x y z. Sub x y z => x -> y -> z

trich :: forall x y r. Trich x y r => x -> y -> r

xor :: forall b1 b2 b3. Xor b1 b2 b3 => b1 -> b2 -> b3

hmap :: forall f a b. HMap f a b => f -> a -> b

hmapWithIndex :: forall f a b. HMapWithIndex f a b => f -> a -> b

mapping :: forall f a b. Mapping f a b => f -> a -> b

call :: forall s. IsString s => Monoid s => s -> s -> s

Syntax for CSS function call.

fromString :: forall s. IsString s => String -> s

url :: forall a. URL a => String -> a

reduce :: forall f i o. Reducible f i o => f -> i -> o

lact :: forall g s. LeftAction g s => g -> s -> s

ract :: forall g s. RightAction g s => s -> g -> s

convertOptions :: forall t i o. ConvertOptions t i o => t -> i -> o

defaults :: forall defaults provided all. Defaults defaults provided all => defaults -> provided -> all

fromString :: forall a. IsString a => String -> a

maddL :: forall x r. LeftModule x r => x -> x -> x

maddR :: forall x r. RightModule x r => x -> x -> x

mmulL :: forall x r. LeftModule x r => r -> x -> x

mmulR :: forall x r. RightModule x r => x -> r -> x

msubL :: forall x r. LeftModule x r => x -> x -> x

msubR :: forall x r. RightModule x r => x -> x -> x

readDefault :: forall a. Read a => Zero a => String -> a

Read a value a from a String but fallback on Zero a on failure

text :: forall html a. Html html => String -> html a

bindTo :: forall f o. f -> o -> f

defaultUndef :: forall a. a -> a -> a

new :: forall f a o. f -> a -> o

Call new on the function with an array or pseudoarray of arguments

unsafeGlobal :: forall t. String -> t

Like global, but for when you're really sure it exists and are willing to tolerate it being quietly undefined (or plan to use the Undef module functions)

dot :: forall p n. ToPos n p => Semiring n => p -> p -> n

Get the dot product of two vectors

mapProduct :: forall mp a b. MapProduct mp a b => mp -> a -> b

putInsideMod :: forall r p n. ToRegion n r => AsPosEndo n p => EuclideanRing n => r -> p -> p

Put a position inside a region by using the modulus operator

stringValue :: forall a. Value a => String -> a

act :: forall m s. Action m s => m -> s -> s

Convert a value of type @m@ to an action on @s@ values.

at :: forall c k r. Monoid r => Lookup c k r => c -> k -> r

This simple helper works on any Lookup instance where the return type is a Monoid, and is the same as lookup except that it returns a t instead of a Maybe t. If lookup would return Nothing, then at returns mempty.

at :: forall c k r. Monoid r => Lookup c k r => c -> k -> r

This simple helper works on any Lookup instance where the return type is a Monoid, and is the same as lookup except that it returns a t instead of a Maybe t. If lookup would return Nothing, then at returns mempty.

join :: forall a. JoinSemilattice a => a -> a -> a

meet :: forall a. MeetSemilattice a => a -> a -> a

pathAppend :: forall m. XPathLike m => m -> m -> m

Put a path seperator between two XPaths and return the resulting XPath.

pathAppendNSx :: forall m. XPathLike m => m -> m -> m

Useful variant of pathAppend needed for some XPath implementations; insert a separator with a dummy namespace ("x") for the second XPath fragment. For example: root /? "record" /? "identifier" == "/x:record/x:identifier".

setCtx :: forall props' props ctx. WithContextProps props' props ctx => ctx -> props' -> props

adjacentSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

and :: forall a. Binary a => a -> a -> a

child :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

dbg :: forall s a. Show s => s -> a -> a

descendant :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

diff :: forall a d. Diff a d => a -> a -> d

generalSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

join :: forall a. JoinSemilattice a => a -> a -> a

maddL :: forall x r. LeftModule x r => x -> x -> x

maddR :: forall x r. RightModule x r => x -> x -> x

meet :: forall a. MeetSemilattice a => a -> a -> a

mmulL :: forall x r. LeftModule x r => r -> x -> x

mmulR :: forall x r. RightModule x r => x -> r -> x

msubL :: forall x r. LeftModule x r => x -> x -> x

msubR :: forall x r. RightModule x r => x -> x -> x

nand :: forall α. HeytingAlgebra α => α -> α -> α

nor :: forall α. HeytingAlgebra α => α -> α -> α

or :: forall a. Binary a => a -> a -> a

patch :: forall a d. Patch a d => a -> d -> a

pursxStringAnonymous :: forall accumulator next res. PursxStringAnonymous accumulator next res => accumulator -> next -> res

pursxValAnonymous :: forall accumulator next res. PursxValAnonymous accumulator next res => accumulator -> next -> res

reciprocal :: forall n n1 n2 a r. Add n2 1 n1 => Add n1 1 n => Arity a n => Divisible r => Eq r => EuclideanRing r => Leadable r => Ord r => Pad n2 (Polynomial r) a => Peel r r => Unpad n2 (Polynomial r) a => a -> a -> a

Computes the reciprocal of the first polynomial in the extension whose minimal polynomial is provided by the second polynomial

set :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses Function s t a b => b -> s -> t

string :: forall t. Corecursive t EJsonF => String -> t

xor :: forall a. Binary a => a -> a -> a

xor :: forall a. HeytingAlgebra a => a -> a -> a

xor :: forall α. HeytingAlgebra α => α -> α -> α

_add :: forall a. HasAdd a => a -> a -> a

_and :: forall a. HasAnd a => a -> a -> a

_divide :: forall a. HasDivide a => a -> a -> a

_multiply :: forall a. HasMultiply a => a -> a -> a

_or :: forall a. HasOr a => a -> a -> a

_power :: forall a. HasPower a => a -> a -> a

_remainder :: forall a. HasRemainder a => a -> a -> a

_subtract :: forall a. HasSubtract a => a -> a -> a

add :: forall a. HasAdd a => a -> a -> a