Search results

elem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is an element of a data structure.

notElem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is not an element of a data structure.

contains :: forall b a. HasEqual b => HasReduce a => b -> a b -> Boolean

Returns true if the container contains the element.

[1, 2, 3] :contains 2 -- true
[1, 0, 3] :contains 2 -- false

elem :: forall a. Eq a => a -> Array a -> Boolean

Returns true if the array has the given element.

elem :: forall a. Eq a => a -> NonEmptyArray a -> Boolean

notElem :: forall a. Eq a => a -> Array a -> Boolean

Returns true if the array does not have the given element.

notElem :: forall a. Eq a => a -> NonEmptyArray a -> Boolean

member :: forall a. Ord a => a -> Set a -> Boolean

Test if a value is a member of a set

member :: forall a. Ord a => a -> NonEmptySet a -> Boolean

Test if a value is a member of a set.

member :: forall a. Hashable a => a -> HashSet a -> Boolean

Test whether a value is in a set.

canFindEq :: forall a. Eq a => a -> Array a -> Boolean

canFindEq :: forall a. Eq a => a -> Vector a -> Boolean

eq :: forall n. Eq n => n -> Bound n -> Boolean

greaterThan :: forall n. Ord n => n -> Bound n -> Boolean

greaterThanOrEq :: forall n. Ord n => n -> Bound n -> Boolean

lessThan :: forall n. Ord n => n -> Bound n -> Boolean

lessThanOrEq :: forall n. Ord n => n -> Bound n -> Boolean

member :: forall n. Ord n => n -> Interval n -> Boolean

member :: forall a. Hashable a => a -> MultiSet a -> Boolean

notEq :: forall n. Eq n => n -> Bound n -> Boolean

contains :: forall a. Ord a => a -> Range a -> Boolean

Returns whether the range contains value a

contains :: forall a. Ord a => a -> Interval a -> Boolean

Whether a point falls within the interval (half-open: start <= x < end).

equals :: forall a. a -> EqPred a -> Boolean

member :: forall a. Ord a => a -> IntervalSet a -> Boolean

Whether a point is contained in any interval in the set. O(log n).

unsafeHas :: forall r1. String -> Record r1 -> Boolean

Checks if a record has a key, using a string for the key.

member :: forall a. String -> Object a -> Boolean

Test whether a String appears as a key in a map

lookupTag :: String -> List String -> Boolean

A specialized lookup function which bails early. Foldable's elem is always worst-case.

inBounds :: forall a. Int -> Seq a -> Boolean

O(1). True if the given index specifies an element that exists in the sequence, false otherwise.

inBounds :: forall a. Int -> Seq a -> Boolean

O(1). True if the given index specifies an element that exists in the sequence, false otherwise.

existsAt :: forall a. Path -> Tree a -> Boolean

If the tree contains something at given path. |

hasSubUnits :: forall c. Int -> Money c -> Boolean

Check if the amount has fractional minor units at the given scale. e.g. hasSubUnits 100 (fromCents 1050) is true (10.50 has sub-units), hasSubUnits 100 (fromCents 1000) is false (10.00 has none).

isEqualTo :: forall a. RoomPosition -> TargetPosition a -> Boolean

isNearTo :: forall a. RoomPosition -> TargetPosition a -> Boolean

sectionContains :: forall a. Section -> Cell a -> Boolean

The sectionContains function tells if a section contains a cell.

fullscreen :: P5 -> (Maybe Boolean) -> Boolean

p5js.org documentation

isEnum :: String -> List TypeDefinition -> Boolean

isInEnumValuesDefinition :: String -> List EnumValueDefinition -> Boolean

isProbablePrime :: BigInt -> Maybe Int -> Boolean

isScalar :: String -> List TypeDefinition -> Boolean

intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For example:

> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"

> intercalate "*" ["a", "b", "c"]
= "a*b*c"

> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]

intercalate :: forall f m. Foldable1 f => Semigroup m => m -> f m -> m

Fold a data structure using a Semigroup instance, combining adjacent elements using the specified separator.

surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m

fold but with each element surrounded by some fixed value.

For example:

> surround "*" []
= "*"

> surround "*" ["1"]
= "*1*"

> surround "*" ["1", "2"]
= "*1*2*"

> surround "*" ["1", "2", "3"]
= "*1*2*3*"

consMax :: forall a f. Foldable f => Ord a => a -> f a -> a

consMin :: forall a f. Foldable f => Ord a => a -> f a -> a

fromMaybe :: forall a. a -> Maybe a -> a

Takes a default value, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the value inside the Just is returned.

fromMaybe x Nothing == x
fromMaybe x (Just y) == y

intercalate :: forall a. Monoid a => a -> Array a -> a

intercalate :: forall a. Semigroup a => a -> NonEmptyArray a -> a

peek :: forall s w a. ComonadStore s w => s -> w a -> a

track :: forall t w a. ComonadTraced t w => t -> w a -> a

fromUndefinedOr :: forall a. a -> UndefinedOr a -> a

fromOpt :: forall a. a -> Opt a -> a

Let's be consistent with fromMaybe args order here

xpose :: forall a. Semiring a => a -> Polynomial a -> a

buildLeaf :: forall e f p v. ElementBuilder e f p v => e -> f p -> v

fromMaybeChurch :: forall a. a -> MaybeChurch a -> a

withDefault :: forall a. a -> Maybe a -> a

If the given value is Nothing, return the default. Otherwise return the value.

withDefault 2 Nothing -- 2
withDefault 2 (Just 1) -- 1

eq1 :: forall f a. Eq1 f => Eq a => f a -> f a -> Boolean

notEq1 :: forall f a. Eq1 f => Eq a => f a -> f a -> Boolean

member :: forall k v. Ord k => k -> Map k v -> Boolean

Test if a key is a member of a map

default :: forall a r. a -> Variant r -> a

Combinator for partial matching with a default value in case of failure.

caseFn :: forall r. Variant (foo :: Int, bar :: String | r) -> String
caseFn = default "No match"
 # on (Proxy :: Proxy "foo") (\foo -> "Foo: " <> show foo)
 # on (Proxy :: Proxy "bar") (\bar -> "Bar: " <> bar)

withEvent :: forall e a. Eventable e a => a -> EventHandlers e -> a

Add an event handler to a markup node.

member :: forall k v. Hashable k => k -> HashMap k v -> Boolean

Test whether a key is in a map.

hasNode :: forall node weight. Ord node => node -> WeightedDigraph node weight -> Boolean

Check if a node exists in the graph

prj :: forall size a n' n t'' t' t. TupleSize size t => Lt n size => ShowNat n n' => ListToRow t t' => Cons n' a t'' t' => Nat n => n -> TupleN t -> a

Project a value of index n from a TupleN, using Data.TypeLevel.Num.Reps.dN as Nat values.

set :: forall @n a b. Set n a b => a -> Polynomial b -> b

isMember :: forall x xs r lproxy. IsMember x xs r => Proxy x -> lproxy xs -> Boolean

eq1 :: forall f a. Eq1 f => f a -> f a -> Boolean

equal :: forall r l f. REqual f l r => RowToList r l => f r -> f r -> Boolean

greaterThan1 :: forall f a. Ord1 f => f a -> f a -> Boolean

greaterThanOrEq1 :: forall f a. Ord1 f => f a -> f a -> Boolean

isInCycle :: forall v k. Ord k => k -> Graph k v -> Boolean

Checks if given key is part of a cycle.

lessThan1 :: forall f a. Ord1 f => f a -> f a -> Boolean

lessThanOrEq1 :: forall f a. Ord1 f => f a -> f a -> Boolean

member :: forall k v. EncodeKey k => k -> Map k v -> Boolean

member :: forall k v. Key k => k -> Map k v -> Boolean

Test whether a key appears in a map

notEq1 :: forall f a. Eq1 f => f a -> f a -> Boolean

sameElements :: forall a f. Foldable f => Eq a => f a -> f a -> Boolean

Checks if two arrays have exactly the same elements. The order of elements does not matter.

sameElements ["A", "B", "B"] ["B", "A", "B"] == true
sameElements ["A", "B", "B"] ["A", "B"] == false

typeVarKinded :: forall a e name. TypeVar a e => ToName name Ident => name -> Type e -> a

An overloaded constructor for kinded type variables.

apply :: forall b a f. f -> Array a -> b

elem :: forall w a. Ord a => a -> Graph a w -> Boolean

Test whether a vertex is in a graph.

isLongerThan :: forall b a t2 t1. Unconsable t1 => Unconsable t2 => t1 a -> t2 b -> Boolean

Checks whether the first list is longer than the second.

isOfSameLength :: forall b a t2 t1. Unconsable t1 => Unconsable t2 => t1 a -> t2 b -> Boolean

Checks whether two lists are of the same length.

isShorterThan :: forall b a t2 t1. Unconsable t1 => Unconsable t2 => t1 a -> t2 b -> Boolean

Checks whether the first list is shorter than the second.

member :: forall k v. Newtype k String => k -> ObjectMap k v -> Boolean

member :: forall k v. EncodeJson k => k -> ObjectMap k v -> Boolean

member :: forall v k. Hashable k => k -> HashMap k v -> Boolean

withEvent :: forall e a. Eventable e a => a -> EventHandlers e -> a

Add an event handler to a markup node.

unsafeGet :: forall r a. String -> Record r -> a

Unsafely gets a value from a record, using a string for the key.

If the key does not exist this will cause a runtime error elsewhere.

properSubset :: forall a. Ord a => Set a -> Set a -> Boolean

True if and only if the first set is a subset of the second set and the sets are not equal

properSubset :: forall a. Ord a => NonEmptySet a -> NonEmptySet a -> Boolean

True if and only if the first set is a subset of the second set and the sets are not equal.

subset :: forall a. Ord a => Set a -> Set a -> Boolean

True if and only if every element in the first set is an element of the second set

subset :: forall a. Ord a => NonEmptySet a -> NonEmptySet a -> Boolean

True if and only if every element in the first set is an element of the second set.

equal :: forall r rs. RowToList r rs => EqualFields rs r => Record r -> Record r -> Boolean

Check two records of the same type for equality.

isSubmap :: forall a. Eq a => Object a -> Object a -> Boolean

Test whether one map contains all of the keys and values contained in another map

unsafeGetCell :: forall a. Int -> Array a -> a

unsafeGetField :: forall r a. String -> Record r -> a

Unsafe field access (we've verified types at compile time)

properSubset :: forall a. Eq a => OSet a -> OSet a -> Boolean

subset :: forall a. Eq a => OSet a -> OSet a -> Boolean

contains :: String -> Map CaseInsensitiveString String -> Boolean

eqEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

eqStableName :: forall b a. StableName a -> StableName b -> Boolean

Equality on 'StableName' that does not require that the types of the arguments match.

greaterThanEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

greaterThanOrEqEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

lessThanEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

lessThanOrEqEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

notEqEverywhere :: forall a. Ord a => NonEmpty a -> NonEmpty a -> Boolean

abuts :: forall a. Ord a => Interval a -> Interval a -> Boolean

Whether two intervals are adjacent with no gap (one's end is the other's start). Adjacent half-open intervals compose cleanly: [a, b) abuts [b, c).

allTouchedImpl :: forall rl r. AllTouched rl r => RLProxy rl -> Record r -> Boolean

colinear :: forall a. Eq a => Field a => Vector a -> Vector a -> Boolean

returns true if v1 and v2 are colinear i.e. there exists a scalar n such that v1 = n v2 https://en.wikipedia.org/wiki/Collinearity

encloses :: forall a. Ord a => Interval a -> Interval a -> Boolean

Whether the first interval fully contains the second.

eqConstraint :: forall a b. Constraint a -> Constraint b -> Boolean

eqType :: forall a b. Type a -> Type b -> Boolean

eqTypeRep :: forall a b. TypeRep a -> TypeRep b -> Boolean

Compare two TypeRep, potentially of differing types, for equality

findTypeEq :: forall b a. FindType a -> FindType b -> Boolean

hasQueryParam :: forall route params. String -> Request route params -> Boolean

haveSameAmount :: forall c1 c2. Money c1 -> Money c2 -> Boolean

Compare amounts across different currencies (ignoring currency). Returns true if the underlying minor unit counts are equal.

haveSameContents :: forall a. Eq a => Array a -> Array a -> Boolean

invokeFunction :: forall f t. Corecursive t (SqlF f) => Ident -> List t -> t

isAfter :: forall a. Ord a => Interval a -> Interval a -> Boolean

Whether the first interval is entirely after the second (with or without gap).

isBefore :: forall a. Ord a => Interval a -> Interval a -> Boolean

Whether the first interval is entirely before the second (with or without gap).

lookEq :: forall b a. LookType a -> LookType b -> Boolean

matchesAny :: forall a. a -> Array (EqPred a) -> Boolean

mkClient :: forall routesSpec client. ClientApi routesSpec client => Options -> Spec routesSpec -> client

overlaps :: forall a. Ord a => Interval a -> Interval a -> Boolean

Whether two intervals share any time (colloquial "overlaps"). Adjacent intervals (Meets/MetBy) do NOT overlap in half-open semantics.

propertyPath :: forall b a. a -> Array String -> b

runFresh :: forall a. String -> Fresh a -> a

seq :: forall a. Eq a => Slice a -> Slice a -> Boolean

Equality test.

seq :: forall a. Eq a => Slice a -> Slice a -> Boolean

Equality test.

unsafeFromJustBecause :: forall a. String -> Maybe a -> a

unsafeFromJustBecause :: forall a. String -> Maybe a -> a

withOptionalStyle :: forall h. HasStyle h => h -> Maybe Style -> h

equalArrays :: Array Number -> Array Number -> Boolean

Uses equal to check that all numbers in the given arrays are approximately the same.

matchSegments :: Array String -> Array String -> Boolean

eq :: forall a. Eq a => a -> a -> Boolean

genericEq :: forall a rep. Generic a rep => GenericEq rep => a -> a -> Boolean

A Generic implementation of the eq member from the Eq type class.

genericEq' :: forall a. GenericEq a => a -> a -> Boolean

greaterThan :: forall a. Ord a => a -> a -> Boolean

Test whether one value is strictly greater than another.

greaterThanOrEq :: forall a. Ord a => a -> a -> Boolean

Test whether one value is non-strictly greater than another.

lessThan :: forall a. Ord a => a -> a -> Boolean

Test whether one value is strictly less than another.

lessThanOrEq :: forall a. Ord a => a -> a -> Boolean

Test whether one value is non-strictly less than another.

notEq :: forall a. Eq a => a -> a -> Boolean

notEq tests whether one value is not equal to another. Shorthand for not (eq x y).

reallyUnsafeRefEq :: forall a b. a -> b -> Boolean

Compares two values of different types using strict (===) equality.

unsafeRefEq :: forall a. a -> a -> Boolean

Compares two values of the same type using strict (===) equality.

defaultEq :: forall r s. Eq s => Refer s r => r -> r -> Boolean

instanceOf :: forall a b. a -> b -> Boolean

Checks whether an object is an instance of an invokable

inside :: forall r p n. ToRegion n r => ToPos n p => Ord n => Semiring n => r -> p -> Boolean

Checks if a position is inside a region. Size of the region should be positive. Inclusive on the lower bound, exclusive on the higher bound.

outside :: forall r p n. ToRegion n r => ToPos n p => Ord n => Semiring n => r -> p -> Boolean

inside, but with its result negated.

parallel :: forall p n. ToPos n p => EuclideanRing n => Eq n => p -> p -> Boolean

Check if two vectors are parallel

perpendicular :: forall p n. ToPos n p => Semiring n => Eq n => p -> p -> Boolean

Check if two vectors are perpendicular

contains :: forall n. IsNode n => n -> n -> Boolean

absorption :: forall a. HeytingAlgebra a => Eq a => a -> a -> Boolean