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
Char
s must be UTF-16 code units and hence cannot represent all Unicode
code points.
Example:
toCodePoint '∀' == 8704
binParseInt :: String -> Int
cyrb53 :: String -> Int
fromRoman :: String -> Int
midiPitch :: String -> Int
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
fromString :: forall s. IsString s => String -> s
url :: forall a. URL a => String -> a
hash :: forall a. Hashable a => a -> Int
fromString :: forall a. IsString 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
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
string :: forall t. Corecursive t EJsonF => String -> t
_zOrder :: forall p. IsPart p => p -> Int
cooldown :: forall a. Coolsdown 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
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!
length :: forall r. Fold LenS r (Int -> Int) => r -> 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
genInt16 :: forall m. MonadGen m => m Int
genInt32 :: forall m. MonadGen m => m Int
genInt8 :: forall m. MonadGen m => m Int
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
convertTo :: forall t f r. Recursive t f => Corecursive r f => t -> r
fill :: forall partial complete. Fillable partial complete => partial -> complete
ginverse :: forall g. Group g => g -> g
justify :: forall unjust just. Justifiable unjust just => unjust -> just
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
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