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