Search results

charList :: String -> List Char

toChars :: String -> List Char

toChars :: forall f. Unfoldable f => String -> f Char

Turn a String into an Unfoldable container of Chars. For example:

toChars "Foo" == ['F','o','o'] :: Array Char

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.

repeat :: forall a. a -> List a

Create a list by repeating an element

singleton :: forall a. a -> List a

Create a list with a single element.

Running time: O(1)

singleton :: forall a. a -> List a

Create a list with a single element.

Running time: O(1)

unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

impossible :: forall a. String -> a

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

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

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

children :: forall t f. Recursive t f => Foldable f => t -> List t

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

universe :: forall t f. Recursive t f => Foldable f => t -> List t

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)

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

interp :: forall a. Interp a => String -> a

Use the derived function, i, instead of this function to do string interpolation. Otherwise, you will get a compiler error if the first value is not a String:

interp "a" 42 true == "a42true"
i      "a" 42 true == "a42true"

interp 42 "a" -- does not compile!
i      42 "a" -- compiles!

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

children :: forall a. Node a => a -> List a

crash :: forall m a. Testable m => String -> m a

fromDefault :: forall mod m. MonadAff m => String -> m mod

Import a module with a default export

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

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

halves :: forall a. Ord a => EuclideanRing a => a -> List a

Produces a list containing the results of halving a number over and over again.

halves 30 == [30,15,7,3,1] halves 128 == [128,64,32,16,8,4,2,1] halves (-10) == [-10,-5,-2,-1]

ident :: forall f t. Corecursive t (SqlF f) => String -> t

parse :: forall a. Router a => String -> a

parseError :: forall e. OwoifyError e => String -> e

Representing general parser error. Currently not used.

parseSlot' :: forall a. EmptyableSlot a => String -> a

property' :: forall a. String -> a

read :: forall a. Read a => Partial => String -> a

repeat :: forall a. a -> List a

require :: forall a. String -> a

singleton :: forall a. a -> List a

Create a list of one element

Running time: O(1).

string :: forall t. Corecursive t (SqlF EJsonF) => String -> t

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

unsafeUnserialize :: forall m. UnserializeState m => String -> m

abs :: forall a. Ord a => Ring a => a -> a

The absolute value function. abs x is defined as if x >= zero then x else negate x.

from :: forall a rep. Generic a rep => a -> rep

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

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

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

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

negate x can be used as a shorthand for zero - x.

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

pure :: forall f a. Applicative f => a -> f a

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

signum :: forall a. Ord a => Ring a => a -> a

The sign function; returns one if the argument is positive, negate one if the argument is negative, or zero if the argument is zero. For floating point numbers with signed zeroes, when called with a zero, this function returns the argument in order to preserve the sign. For any x, we should have signum x * abs x == x.

to :: forall a rep. Generic a rep => rep -> a

unwrap :: forall t a. Newtype t a => t -> a

wrap :: forall t a. Newtype t a => a -> t

unsafeCoerce :: forall a b. a -> b

A highly unsafe function, which can be used to persuade the type system that any type is the same as any other type. When using this function, it is your (that is, the caller's) responsibility to ensure that the underlying representation for both types is the same.

Because this function is extraordinarily flexible, type inference can greatly suffer. It is highly recommended to define specializations of this function rather than using it as-is. For example:

fromBoolean :: Boolean -> Json
fromBoolean = unsafeCoerce

This way, you won't have any nasty surprises due to the inferred type being different to what you expected.

After the v0.14.0 PureScript release, some of what was accomplished via unsafeCoerce can now be accomplished via coerce from purescript-safe-coerce. See that library's documentation for more context.

inj :: forall a b. Inject a b => a -> b

unsafePartial :: forall a. (Partial => a) -> a

Discharge a partiality constraint, unsafely.

singleton :: forall f a. Unfoldable1 f => a -> f a

Contain a single value. For example:

singleton "foo" == (NEL.singleton "foo" :: NEL.NonEmptyList String)

from :: forall a b. TypeEquals a b => b -> a

to :: forall a b. TypeEquals a b => a -> b

downFrom :: forall a u. Enum a => Unfoldable u => a -> u a

Produces all predecessors of an Enum value, excluding the start value.

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

Produces all predecessors of an Enum value, including the start value.

downFromIncluding top will return all values in an Enum, in reverse order.

upFrom :: forall a u. Enum a => Unfoldable u => a -> u a

Produces all successors of an Enum value, excluding the start value.

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

Produces all successors of an Enum value, including the start value.

upFromIncluding bottom will return all values in an Enum.

throwError :: forall e m a. MonadThrow e m => e -> m a

convertDuration :: forall a b. Duration a => Duration b => a -> b

Converts directly between durations of differing types.

negateDuration :: forall a. Duration a => a -> a

Negates a duration, turning a positive duration negative or a negative duration positive.

coerce :: forall a b. Coercible a b => a -> b

Coerce a value of one type to a value of some other type, without changing its runtime representation. This function behaves identically to unsafeCoerce at runtime. Unlike unsafeCoerce, it is safe, because the Coercible constraint prevents any use of this function from compiling unless the compiler can prove that the two types have the same runtime representation.

One application for this function is to avoid doing work that you know is a no-op because of newtypes. For example, if you have an Array (Conj a) and you want an Array (Disj a), you could do Data.Array.map (un Conj >>> Disj), but this performs an unnecessary traversal of the array, with O(n) cost. coerce accomplishes the same with only O(1) cost:

mapConjToDisj :: forall a. Array (Conj a) -> Array (Disj a)
mapConjToDisj = coerce

div10 :: forall x q. Div10 x q => x -> q

isDivBy :: forall d x. IsDivBy d x => d -> x

mul10 :: forall x q. Mul10 x q => x -> q

not :: forall b1 b2. Not b1 b2 => b1 -> b2

pred :: forall x y. Pred x y => x -> y

succ :: forall x y. Succ x y => x -> y

cast :: forall a b. Castable a b => a -> b

coerce :: forall expected given. Coerce given expected => given -> expected

coerce :: forall expected given. Coerce given expected => given -> expected

ginverse :: forall g. Group g => g -> g

convertTo :: forall t f r. Recursive t f => Corecursive r f => t -> r

fill :: forall partial complete. Fillable partial complete => partial -> complete

justify :: forall unjust just. Justifiable unjust just => unjust -> just

lambek :: forall t f. Recursive t f => Corecursive t f => t -> f t

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

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

nextPrime :: forall a. Ord a => Semiring a => EuclideanRing a => a -> a

Ad infinitum

pad :: forall @n a b. Pad n a b => a -> b

project :: forall t f. Recursive t f => t -> f t

unpad :: forall @n a b. Unpad n a b => b -> a

area :: forall s n. ToSize n s => Semiring n => s -> n

Get the area of a size

convertPos :: forall p1 p2 n. ToPos n p1 => FromPos n p2 => p1 -> p2

convertRegion :: forall p1 p2 n. ToRegion n p1 => FromRegion n p2 => p1 -> p2

convertSize :: forall p1 p2 n. ToSize n p1 => FromSize n p2 => p1 -> p2

init :: forall fn a. Init fn a => fn -> a

initProduct :: forall f a. InitProduct f a => f -> a

measure :: forall a v. Measured a v => a -> v

midPos :: forall s p n. ToRegion n s => FromPos n p => EuclideanRing n => s -> p

Get the center position of a region

perimeter :: forall s n. ToSize n s => Semiring n => s -> n

Get the perimeter of a size

ratio :: forall s n. ToSize n s => EuclideanRing n => s -> n

Get the ratio of a size by dividing the width by the height

sequenceProduct :: forall specI specO f. SequenceProduct specI specO f => specI -> f specO

undefer :: forall a. (Deferred => a) -> a

Note: use of this function may result in arbitrary side effects.

always :: forall a b. Always a b => a -> b

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

Prepend an '@'

complement :: forall p. Bounded p => Ring p => p -> p

convert :: forall b a. TokenUnit a => TokenUnit b => a -> b

Convert between two denominations

debugger :: forall a. a -> a

Inserts a JavaScript debugger statement, then returns its argument.

dir :: forall a. a -> a

Calls console.dir with its argument, then returns it.

inj :: forall l a. Includes l a => a -> l

Inject a value into an otherwise empty heterogeneous list.

log :: forall a. a -> a

Calls console.log with its argument, then returns it.

-- log a value as it's used
func a = todo $ log a

-- explicitly log an argument because it may not be used
func a =
  let
    _ = log a
  in
    todo

-- log the value inside a functor
func ma = do
  a <- log <$> pure ma
  todo

logShow :: forall a. Show a => a -> a

For an argument a, calls console.log on show a, then returns a.

nextSibling :: forall n m. IsNode n => IsNode m => n -> m

Gets the next sibling

parentNode :: forall n m. IsNode n => IsNode m => n -> m

prevSibling :: forall n m. IsNode n => IsNode m => n -> m

Gets the previous sibling

pure :: forall v f c. HasPure c f => ObjectOf c v => v -> f v

tUnit :: forall u1 u0 bf c. HasTUnit c bf u0 u1 => HasUnit c u1 => u0 -> u1

unsafeDir :: forall a b. a -> b

Like dir except it coerces the input to any type.

unsafeLog :: forall a b. a -> b

Like log except it coerces the input to any type.

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

Prepend a dummy namespace

abs :: forall a. Num a => a -> a

asTS :: forall b a. IsTSEq a b => a -> b

bottom1_ :: forall f a. Bottom1_ f => a -> f a

bottom2 :: forall f a b. Bottom2 f a => a -> f b

coerce :: forall a b. Coercible a b => a -> b

convertImpl :: forall input output. ToInternalConverter input output => input -> output

dbgs :: forall s. Show s => s -> s

embed :: forall a r. Algebra a r => r -> a

foldLineNames :: forall i o. FoldLineNames i o => i -> o

foldOf :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses (Forget a) s t a b => s -> a

fromFractional :: forall b a. Fractional a => Fractional b => a -> b

A helper function for general conversion between Fractional values.

fromIntegral :: forall b a. Integral a => Integral b => a -> b

A helper function for general conversion between Integral values.

hasJSRep :: forall a. HasJSRep a => a -> a

magicProps :: forall props. props -> props

mkPrim :: forall a b. Primitive a b => a -> b

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

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

negate :: forall a. Num a => a -> a

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

px :: forall next res. PursxStringAnonymous ((Proxy "a") /\ (Proxy "") /\ (Record ())) next res => next -> res

signum :: forall a. Num a => a -> a

stripLeadingZeros :: forall a. Elastic a => a -> a

top1_ :: forall f a. Top1_ f => a -> f a

toTuples :: forall a b. ToTuples a b => a -> b

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

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

view :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses (Forget a) s t a b => s -> a

xformEventProps :: forall props. props -> props

_diagram :: forall t @d. IsTool t => IsDiagram d => t -> d

_fromVertex :: forall _l _n e v. LayoutNetwork _l _n e v => e -> v

_layout :: forall d @l. IsDiagram d => IsLayout l => d -> l

_locationObject :: forall p @g. IsPart p => IsGraphObject g => p -> g

_model :: forall d @m. IsDiagram d => IsModel m => d -> m

_network :: forall l n _e _v. LayoutNetwork l n _e _v => l -> n

_nodeTemplate :: forall d @p. IsDiagram d => IsPart p => d -> p

_originalFromNode :: forall t @n. IsLinkingBaseTool t => IsNode n => t -> n