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

compareReference :: forall a. a -> a -> Boolean

divisibleBy :: forall a. HasEqual a => HasRemainder a => HasZero a => a -> a -> Boolean

Returns true if the number is divisible by the other.

9 :divisibleBy 3 -- true
8 :divisibleBy 3 -- false

eqById :: forall a. HasId a => a -> a -> Boolean

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

Returns true if the value is greater than or equal to the other.

2 :greaterOrEqual 1 -- true
2 :greaterOrEqual 2 -- true
2 :greaterOrEqual 3 -- false

includes :: forall key range. IDBKey key => IDBKeyRange range => range -> key -> Boolean

Returns true if key is included in the range, and false otherwise.

includes :: forall range key. IDBKey key => IDBKeyRange range => range -> key -> Boolean

Returns true if key is included in the range, and false otherwise.

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

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

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

Returns true if the value is less than or equal to the other.

2 :lessOrEqual 1 -- false
2 :lessOrEqual 2 -- true
2 :lessOrEqual 3 -- true

matchObjectsOnId :: forall a b. HasUuid a => HasUuid b => a -> b -> Boolean

modelHasChanged :: forall model. model -> model -> Boolean

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

Returns true if the value is not equal to the other.

2 :notEqual 1 -- true
1 :notEqual 1 -- true

notMatchObjectsOnId :: forall a b. HasUuid a => HasUuid b => a -> b -> Boolean

rEq :: forall r. Fold EqS r (AppCat (Function r) Function Boolean Boolean) => r -> r -> Boolean

add :: forall a. Semiring a => a -> a -> a

append :: forall a. Semigroup a => a -> a -> a

conj :: forall a. HeytingAlgebra a => a -> a -> a

const :: forall a b. a -> b -> a

Returns its first argument and ignores its second.

const 1 "hello" = 1

It can also be thought of as creating a function that ignores its argument:

const 1 = \_ -> 1

disj :: forall a. HeytingAlgebra a => a -> a -> a

div :: forall a. EuclideanRing a => a -> a -> a

gcd :: forall a. Eq a => EuclideanRing a => a -> a -> a

The greatest common divisor of two values.

genericAdd :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the add member from the Semiring type class.

genericAdd' :: forall a. GenericSemiring a => a -> a -> a

genericAppend :: forall a rep. Generic a rep => GenericSemigroup rep => a -> a -> a

A Generic implementation of the append member from the Semigroup type class.

genericAppend' :: forall a. GenericSemigroup a => a -> a -> a

genericConj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the conj member from the HeytingAlgebra type class.

genericConj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericDisj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the disj member from the HeytingAlgebra type class.

genericDisj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericImplies :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the implies member from the HeytingAlgebra type class.

genericImplies' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericMul :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the mul member from the Semiring type class.

genericMul' :: forall a. GenericSemiring a => a -> a -> a

genericSub :: forall a rep. Generic a rep => GenericRing rep => a -> a -> a

A Generic implementation of the sub member from the Ring type class.

genericSub' :: forall a. GenericRing a => a -> a -> a

implies :: forall a. HeytingAlgebra a => a -> a -> a

lcm :: forall a. Eq a => EuclideanRing a => a -> a -> a

The least common multiple of two values.

leftDiv :: forall a. DivisionRing a => a -> a -> a

Left division, defined as leftDiv a b = recip b * a. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

max :: forall a. Ord a => a -> a -> a

Take the maximum of two values. If they are considered equal, the first argument is chosen.

min :: forall a. Ord a => a -> a -> a

Take the minimum of two values. If they are considered equal, the first argument is chosen.

mod :: forall a. EuclideanRing a => a -> a -> a

mul :: forall a. Semiring a => a -> a -> a

rightDiv :: forall a. DivisionRing a => a -> a -> a

Right division, defined as rightDiv a b = a * recip b. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

sub :: forall a. Ring a => a -> a -> a

sans :: forall m a b. At m a b => a -> m -> m

add :: forall x y z. Add x y z => x -> y -> z

and :: forall b1 b2 b3. And b1 b2 b3 => b1 -> b2 -> b3

div :: forall x y z. Div x y z => x -> y -> z