Search results

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}}!"
P purescript-handlebars M Text.Handlebars
declareFlowType' :: forall a. HasFlowRep a => String -> a -> String

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

P purescript-bismuth M Bismuth.LibDef
generateFlowType' :: forall a. HasFlowRep a => String -> a -> String

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

P purescript-bismuth M Bismuth

s

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

Separator

P purescript-react-basic-textf M React.Basic.DOM.Textf.DateTimeFormat
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.

P purescript-prelude M Data.Monoid
unsafePartialBecause :: forall a. String -> (Partial => a) -> a

deprecated: use unsafePartial instead.

P purescript-partial M Partial.Unsafe
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.

P purescript-debug M Debug.Trace
repeat :: forall a. Monoid a => a -> Int -> a
P purescript-formatters M Data.Formatter.Internal
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.

P purescript-group M Data.Group
taggedLog :: forall a. String -> a -> a

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

P purescript-debuggest M Debug
taggedLogShow :: forall a. Show a => String -> a -> a

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

P purescript-debuggest M Debug
pow :: forall a. Semiring a => a -> Int -> a

Integer power

P purescript-sparse-polynomials M Data.Sparse.Polynomial
runFn0 :: forall b a. String -> a -> b
P purescript-airconsole M AirConsole.FFI
unsafeGetField :: forall b a. String -> a -> b
P purescript-airconsole M AirConsole.FFI
effect0 :: forall b a. String -> a -> b
P purescript-weber M Weber.Event

m

m :: forall bem. WithModifiers bem => String -> bem -> bem
P purescript-css-bem M CSS.BEM
question :: forall m e. MonadAff (console :: CONSOLE, readline :: READLINE | e) m => MonadAsk Interface m => String -> m String

Prompt for input, then read a line

P purescript-line-reader M LineReader
runThisFn0 :: forall a this. String -> this -> a
P purescript-screeps-classy M Screeps.FFI
unsafeField :: forall val obj. String -> obj -> val
P purescript-screeps-classy M Screeps.FFI
unsafeLog :: forall a. String -> a -> a

Unsafely write a string to the console.

unsafeLog "unsafe!" unit -- unit (logs "unsafe!")
P purescript-neon M Neon.Helper
add :: forall a. Semiring a => a -> a -> a
P purescript-prelude M Data.Semiring
append :: forall a. Semigroup a => a -> a -> a
P purescript-prelude M Data.Semigroup
conj :: forall a. HeytingAlgebra a => a -> a -> a
P purescript-prelude M Data.HeytingAlgebra
const :: forall b a. a -> b -> a

Returns its first argument and ignores its second.

const 1 "hello" = 1
P purescript-prelude M Data.Function
disj :: forall a. HeytingAlgebra a => a -> a -> a
P purescript-prelude M Data.HeytingAlgebra
div :: forall a. EuclideanRing a => a -> a -> a
P purescript-prelude M Data.EuclideanRing
gcd :: forall a. Eq a => EuclideanRing a => a -> a -> a

The greatest common divisor of two values.

P purescript-prelude M Data.EuclideanRing
implies :: forall a. HeytingAlgebra a => a -> a -> a
P purescript-prelude M Data.HeytingAlgebra
lcm :: forall a. Eq a => EuclideanRing a => a -> a -> a

The least common multiple of two values.

P purescript-prelude M Data.EuclideanRing
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.

P purescript-prelude M Data.DivisionRing
max :: forall a. Ord a => a -> a -> a

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

P purescript-prelude M Data.Ord
min :: forall a. Ord a => a -> a -> a

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

P purescript-prelude M Data.Ord
mod :: forall a. EuclideanRing a => a -> a -> a
P purescript-prelude M Data.EuclideanRing
mul :: forall a. Semiring a => a -> a -> a
P purescript-prelude M Data.Semiring
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.

P purescript-prelude M Data.DivisionRing
sub :: forall a. Ring a => a -> a -> a
P purescript-prelude M Data.Ring
crashWith :: forall a. Partial => String -> a

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

P purescript-partial M Partial
unsafeCrashWith :: forall a. String -> a

A function which crashes with the specified error message.

P purescript-partial M Partial.Unsafe
unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

P purescript-exceptions M Effect.Exception.Unsafe
genericAdd :: forall rep a. Generic a rep => GenericSemiring rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.Semiring
genericAdd' :: forall a. GenericSemiring a => a -> a -> a
P purescript-generics-rep M Data.Generic.Rep.Semiring
genericAppend :: forall rep a. Generic a rep => GenericSemigroup rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.Semigroup
genericAppend' :: forall a. GenericSemigroup a => a -> a -> a
P purescript-generics-rep M Data.Generic.Rep.Semigroup
genericConj :: forall rep a. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericConj' :: forall a. GenericHeytingAlgebra a => a -> a -> a
P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericDisj :: forall rep a. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericDisj' :: forall a. GenericHeytingAlgebra a => a -> a -> a
P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericImplies :: forall rep a. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericImplies' :: forall a. GenericHeytingAlgebra a => a -> a -> a
P purescript-generics-rep M Data.Generic.Rep.HeytingAlgebra
genericMul :: forall rep a. Generic a rep => GenericSemiring rep => a -> a -> a

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

P purescript-generics-rep M Data.Generic.Rep.Semiring