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

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

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

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

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

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.

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

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

x <= y && y <= x => x == y

commutative :: forall a. CommutativeRing a => Eq a => a -> a -> Boolean

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

compareHom :: forall a. BoundedEnum a => Ord a => a -> a -> Boolean

compare x y == compare (fromEnum x) (fromEnum y)

divides :: forall α. Eq α => EuclideanRing α => α -> α -> Boolean

genericEq1 :: forall a. GenericEq1 a => a -> a -> Boolean

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

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

integralDomain :: forall a. EuclideanRing a => Eq a => a -> a -> Boolean

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

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

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

x /= y => not (x == y)

notDivides :: forall α. Eq α => EuclideanRing α => α -> α -> Boolean

quotientRemainder :: forall a. EuclideanRing a => Eq a => a -> a -> Boolean

submultiplicative :: forall a. EuclideanRing a => Eq a => a -> a -> Boolean

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

x == y => y == x?

_equal :: forall a. HasEqual a => a -> a -> Boolean

_greater :: forall a. HasGreater a => a -> a -> Boolean

_greaterOrEqual :: forall a. HasEqual a => HasGreater a => a -> a -> Boolean

_less :: forall a. HasLess a => a -> a -> Boolean

_lessOrEqual :: forall a. HasEqual a => HasLess a => a -> a -> Boolean

_notEqual :: forall a. HasEqual a => a -> a -> Boolean