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.

power [1,2] 3    == [1,2,1,2,1,2]
power [1,2] 1    == [1,2]
power [1,2] 0    == []
power [1,2] (-3) == []
P purescript-prelude M Data.Monoid
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
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
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
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
unsafeGetField :: forall b a. String -> a -> b
P purescript-airconsole M AirConsole.FFI
attr :: forall m. Testable m => String -> m String

Returns the given attribute of the current-context element.

P purescript-elmish-testing-library M Elmish.Test.Query
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.

P purescript-wags M WAGS.Interpret
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
makeLoopBufWithDeferredBuffer :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make a looping audio buffer node with a deferred buffer.

P purescript-wags M WAGS.Interpret
makePeriodicOscWithDeferredOsc :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make a periodic oscillator.

P purescript-wags M WAGS.Interpret
makePlayBufWithDeferredBuffer :: forall audio engine. AudioInterpret audio engine => String -> audio -> engine

Make an audio buffer node with a deferred buffer.

P purescript-wags M WAGS.Interpret
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
translate :: forall x y. IsLength x => IsLength y => x -> y -> String

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

P purescript-pha M Pha.Html.Util
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 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
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
genericAdd :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

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

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

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

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

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

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

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

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

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

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

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

P purescript-prelude M Data.Semiring.Generic
genericMul' :: forall a. GenericSemiring a => a -> a -> a
P purescript-prelude M Data.Semiring.Generic
genericSub :: forall a rep. Generic a rep => GenericRing rep => a -> a -> a

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

P purescript-prelude M Data.Ring.Generic
genericSub' :: forall a. GenericRing a => a -> a -> a
P purescript-prelude M Data.Ring.Generic
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
sans :: forall m a b. At m a b => a -> m -> m
P purescript-profunctor-lenses M Data.Lens.At
impossible :: forall a. String -> a
P purescript-variant M Data.Variant.Internal
add :: forall x y z. Add x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
and :: forall b1 b2 b3. And b1 b2 b3 => b1 -> b2 -> b3
P purescript-typelevel M Data.Typelevel.Bool
div :: forall x y z. Div x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
eq :: forall b1 b2 b3. Eq b1 b2 b3 => b1 -> b2 -> b3
P purescript-typelevel M Data.Typelevel.Bool
gcd :: forall x y z. GCD x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
imp :: forall b1 b2 b3. Imp b1 b2 b3 => b1 -> b2 -> b3
P purescript-typelevel M Data.Typelevel.Bool
max :: forall x y z. Max x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
min :: forall x y z. Min x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
mod :: forall x y r. Mod x y r => x -> y -> r
P purescript-typelevel M Data.Typelevel.Num.Ops
mul :: forall x y z. Mul x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
or :: forall b1 b2 b3. Or b1 b2 b3 => b1 -> b2 -> b3
P purescript-typelevel M Data.Typelevel.Bool
sub :: forall x y z. Sub x y z => x -> y -> z
P purescript-typelevel M Data.Typelevel.Num.Ops
trich :: forall x y r. Trich x y r => x -> y -> r
P purescript-typelevel M Data.Typelevel.Num.Ops
xor :: forall b1 b2 b3. Xor b1 b2 b3 => b1 -> b2 -> b3
P purescript-typelevel M Data.Typelevel.Bool
hmap :: forall f a b. HMap f a b => f -> a -> b
P purescript-heterogeneous M Heterogeneous.Mapping
hmapWithIndex :: forall f a b. HMapWithIndex f a b => f -> a -> b
P purescript-heterogeneous M Heterogeneous.Mapping
mapping :: forall f a b. Mapping f a b => f -> a -> b
P purescript-heterogeneous M Heterogeneous.Mapping
call :: forall s. IsString s => Monoid s => s -> s -> s

Syntax for CSS function call.

P purescript-css M CSS.Common
fromString :: forall s. IsString s => String -> s
P purescript-css M CSS.String
url :: forall a. URL a => String -> a
P purescript-css M CSS.Common
reduce :: forall f i o. Reducible f i o => f -> i -> o
P purescript-untagged-union M Untagged.Union
convertOptions :: forall t i o. ConvertOptions t i o => t -> i -> o
P purescript-convertable-options M ConvertableOptions
defaults :: forall defaults provided all. Defaults defaults provided all => defaults -> provided -> all
P purescript-convertable-options M ConvertableOptions
fromString :: forall a. IsString a => String -> a
P purescript-yarn M Data.String.Yarn
lact :: forall g s. LeftAction g s => g -> s -> s
P purescript-group M Data.Group.Action
maddL :: forall x r. LeftModule x r => x -> x -> x
P purescript-modules M Data.Ring.Module
maddR :: forall x r. RightModule x r => x -> x -> x
P purescript-modules M Data.Ring.Module
mmulL :: forall x r. LeftModule x r => r -> x -> x
P purescript-modules M Data.Ring.Module
mmulR :: forall x r. RightModule x r => x -> r -> x
P purescript-modules M Data.Ring.Module
msubL :: forall x r. LeftModule x r => x -> x -> x
P purescript-modules M Data.Ring.Module
msubR :: forall x r. RightModule x r => x -> x -> x
P purescript-modules M Data.Ring.Module
ract :: forall g s. RightAction g s => s -> g -> s
P purescript-group M Data.Group.Action
readDefault :: forall a. Read a => Zero a => String -> a

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

P purescript-read M Data.String.Read
text :: forall html a. Html html => String -> html a
P purescript-chameleon M Chameleon.Class
dot :: forall p n. ToPos n p => Semiring n => p -> p -> n

Get the dot product of two vectors

P purescript-polymorphic-vectors M Data.Vector.Polymorphic
mapProduct :: forall mp a b. MapProduct mp a b => mp -> a -> b
P purescript-classless M Classless
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

P purescript-polymorphic-vectors M Data.Vector.Polymorphic
stringValue :: forall a. Value a => String -> a
P purescript-markdown M Text.Markdown.SlamDown.Syntax.Value
act :: forall m s. Action m s => m -> s -> s

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

P purescript-monoid-extras M Data.Monoid.Action
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.

P purescript-httpure M HTTPure.Lookup
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.

P purescript-httpurple M HTTPurple.Lookup
join :: forall a. JoinSemilattice a => a -> a -> a
P purescript-lattice M Data.Lattice
meet :: forall a. MeetSemilattice a => a -> a -> a
P purescript-lattice M Data.Lattice
pathAppend :: forall m. XPathLike m => m -> m -> m

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

P purescript-xpath-like M Data.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".

P purescript-xpath-like M Data.XPath
setCtx :: forall props' props ctx. WithContextProps props' props ctx => ctx -> props' -> props
P purescript-react-hocs M ReactHocs.Class
adjacentSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c
P purescript-tecton M Tecton.Internal
and :: forall a. Binary a => a -> a -> a
P purescript-binary M Data.Binary
child :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c
P purescript-tecton M Tecton.Internal
dbg :: forall s a. Show s => s -> a -> a
P purescript-binary M Debug
descendant :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c
P purescript-tecton M Tecton.Internal
diff :: forall a d. Diff a d => a -> a -> d
P purescript-incremental-functions M Data.Incremental
generalSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c
P purescript-tecton M Tecton.Internal
join :: forall a. JoinSemilattice a => a -> a -> a
P purescript-colehaus-lattice M Data.Lattice
maddL :: forall x r. LeftModule x r => x -> x -> x
P purescript-ring-modules M Data.Ring.Module
maddR :: forall x r. RightModule x r => x -> x -> x
P purescript-ring-modules M Data.Ring.Module
meet :: forall a. MeetSemilattice a => a -> a -> a
P purescript-colehaus-lattice M Data.Lattice
mmulL :: forall x r. LeftModule x r => r -> x -> x
P purescript-ring-modules M Data.Ring.Module
mmulR :: forall x r. RightModule x r => x -> r -> x
P purescript-ring-modules M Data.Ring.Module
msubL :: forall x r. LeftModule x r => x -> x -> x
P purescript-ring-modules M Data.Ring.Module
msubR :: forall x r. RightModule x r => x -> x -> x
P purescript-ring-modules M Data.Ring.Module
nand :: forall α. HeytingAlgebra α => α -> α -> α
P purescript-unicode-prelude M Data.HeytingAlgebra.Unicode
nor :: forall α. HeytingAlgebra α => α -> α -> α
P purescript-unicode-prelude M Data.HeytingAlgebra.Unicode
or :: forall a. Binary a => a -> a -> a
P purescript-binary M Data.Binary
patch :: forall a d. Patch a d => a -> d -> a
P purescript-incremental-functions M Data.Incremental
pursxStringAnonymous :: forall accumulator next res. PursxStringAnonymous accumulator next res => accumulator -> next -> res
P purescript-deku M Deku.Pursx.Anonymous
pursxValAnonymous :: forall accumulator next res. PursxValAnonymous accumulator next res => accumulator -> next -> res
P purescript-deku M Deku.Pursx.Anonymous
set :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses Function s t a b => b -> s -> t
P purescript-barlow-lens M Data.Lens.Barlow.Helpers
string :: forall t. Corecursive t EJsonF => String -> t
P purescript-ejson M Data.Json.Extended
xor :: forall a. Binary a => a -> a -> a
P purescript-binary M Data.Binary
xor :: forall a. HeytingAlgebra a => a -> a -> a
P purescript-boolean-eq M Data.BooleanEq
xor :: forall α. HeytingAlgebra α => α -> α -> α
P purescript-unicode-prelude M Data.HeytingAlgebra.Unicode
_add :: forall a. HasAdd a => a -> a -> a
P purescript-neon M Neon.Operator
_and :: forall a. HasAnd a => a -> a -> a
P purescript-neon M Neon.Operator
_divide :: forall a. HasDivide a => a -> a -> a
P purescript-neon M Neon.Operator
_multiply :: forall a. HasMultiply a => a -> a -> a
P purescript-neon M Neon.Operator
_or :: forall a. HasOr a => a -> a -> a
P purescript-neon M Neon.Operator
_power :: forall a. HasPower a => a -> a -> a
P purescript-neon M Neon.Operator
_remainder :: forall a. HasRemainder a => a -> a -> a
P purescript-neon M Neon.Operator
_subtract :: forall a. HasSubtract a => a -> a -> a
P purescript-neon M Neon.Operator
add :: forall a. HasAdd a => a -> a -> a
P purescript-neon M Neon.Class.HasAdd
add :: forall a b c r. Arith a b c r => a -> b -> c
P purescript-z3 M Z3
always :: forall b a. a -> b -> a

Always returns the first argument.

"anything" :always 1 -- 1

This is the constant function.

P purescript-neon M Neon.Primitive.Function
and :: forall a. HasAnd a => a -> a -> a
P purescript-neon M Neon.Class.HasAnd
and :: forall a b r. LogicalMatcher a b r => a -> b -> r
P purescript-pmock M Test.PMock.Param
asTypeOf :: forall a. a -> a -> a

A type-restricted version of always.

[] :asTypeOf [1] -- [] :: Array Int
P purescript-neon M Neon.Helper
bind :: forall a g f. f -> a -> g
P purescript-ffi-utils M FFI.Util.Function
cons :: forall a b r. ConsGen a b r => a -> b -> r
P purescript-pmock M Test.PMock.Param
crash :: forall m a. Testable m => String -> m a
P purescript-elmish-testing-library M Elmish.Test.State
decorate :: forall a b. Decorate a b => a -> b -> a
P purescript-materialize M Materialize.Markup.Decorate