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