Search results

length :: String -> Int

Returns the number of code points in the string. Operates in constant space and in time linear to the length of the string.

>>> length "b 𝐀𝐀 c 𝐀"
8
-- compare to Data.String:
>>> length "b 𝐀𝐀 c 𝐀"
11

length :: String -> Int

Returns the number of characters the string is composed of.

length "Hello World" == 11

isIP' :: String -> Int

Returns 4 if the String is a valid IPv4 address, 6 if the String is a valid IPv6 address, and 0 otherwise.

length :: Warn (Text "DEPRECATED: `Data.String.Utils.length`") => String -> Int

DEPRECATED: This function is now available in purescript-strings.

Return the number of Unicode code points in a string. Note that this function correctly accounts for Unicode symbols that are made up of surrogate pairs. If you want a simple wrapper around JavaScript's string.length property, you should use the Data.String.CodeUnits.length function from purescript-strings.

length "PureScript" == 10
length "ℙ∪𝕣ⅇႽ𝚌𝕣ⅈ𝚙†" == 10    -- 14 with `Data.String.length`

toCodePoint :: String -> Int

Return the Unicode code point of a character. This function uses String instead of Char because PureScript Chars must be UTF-16 code units and hence cannot represent all Unicode code points.

Example:

toCodePoint '∀' == 8704

binParseInt :: String -> Int

byteLength :: String -> Int

byteLength :: String -> Int

The UTF-8 byte length. On wasm: the StrLen intrinsic (array.len on the $Bytes).

cyrb53 :: String -> Int

fromRoman :: String -> Int

midiPitch :: String -> Int

simpleHash :: String -> Int

Simple hash function (for demonstration - not cryptographically secure!)

degree :: forall a. EuclideanRing a => a -> Int

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.

defaultFromEnum :: forall a. Enum a => a -> Int

Provides a default implementation for fromEnum.

• Assumes toEnum 0 = Just bottom.
• Cannot be used in conjuction with defaultPred.

Runs in O(n) where n is fromEnum a.

fromEnum :: forall a. BoundedEnum a => a -> Int

genericFromEnum :: forall a rep. Generic a rep => GenericBoundedEnum rep => a -> Int

A Generic implementation of the fromEnum member from the BoundedEnum type class.

genericFromEnum' :: forall a. GenericBoundedEnum a => a -> Int

unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

impossible :: forall a. String -> a

toInt :: forall n. Nat n => n -> Int

hash :: forall a. Hashable a => a -> Int

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

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

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

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

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

arity :: forall a. Display a => a -> Int

eventPhaseIndex :: forall e. IsEvent e => e -> Int

The integer value for the current event phase.

length :: forall a. a -> Int

Gets the length of a pseudoarray

nodeTypeIndex :: forall n. IsNode n => n -> Int

The numeric value for the type of a node.

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

childCount :: forall n. IsParent n => n -> Int

Returns the number of child Elements

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

_zOrder :: forall p. IsPart p => p -> Int

cooldown :: forall a. Coolsdown a => a -> Int

dayIndex :: forall a. Temporal a => a -> Int

dayOfWeek :: forall a. Temporal a => a -> Int

depositLeft :: forall a. Deposit a => a -> Int

energy :: forall a. Refillable a => a -> Int

energyCapacity :: forall a. Refillable a => a -> Int

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

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

getUuid :: forall m. HasUuid m => m -> Int

hits :: forall d. Destructible d => d -> Int

hitsMax :: forall d. Destructible d => d -> Int

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

intervalLane :: forall a. TimeInterval a => a -> Int

length :: forall r. Fold LenS r (Int -> Int) => r -> Int

length :: forall a. Length a => a -> Int

nodeTypeIndex :: forall n. NodeOp n => n -> Int

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

progress :: forall a. Progress a => a -> Int

progressTotal :: forall a. Progress a => a -> Int

property' :: forall a. String -> a

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

require :: forall a. String -> a

size :: forall a. FFTArray a => a -> Int

storeCapacity :: forall a. Stores a => a -> Int

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

ticksToDecay :: forall a. Decays a => a -> Int

ticksToRegeneration :: forall s. Regenerates s => s -> Int

toInt :: forall a. HasToInt a => a -> Int

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

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.

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

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

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

genInt16 :: forall m. MonadGen m => m Int

genInt32 :: forall m. MonadGen m => m Int

genInt8 :: forall m. MonadGen m => m Int

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

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

coerceReactProps :: forall props nonDataProps targetProps. CoerceReactProps props nonDataProps targetProps => props -> targetProps