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
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
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
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
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
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