Comp (ash v3.5.6)

Provides utilities to implement and work with Comparable types

Summary

Types

left()

right()

Functions

compare(left, right)

Compare left and right term

defcomparable(arg1, arg2, list)

Helper to define ordering relation for pair of types, accepts two term :: type pairs and block of code where relation is described.

eq()

equal?(left, right)

Is left term equal to right term?

greater_or_equal?(left, right)

Is left term greater or equal to right term?

greater_than?(left, right)

Is left term greater than right term?

gt()

less_or_equal?(left, right)

Is left term less or equal to right term?

less_than?(left, right)

Is left term less than right term?

lt()

max(left, right)

Returns the biggest of the two given terms, if terms are equal - then the first one is returned

min(left, right)

Returns the smallest of the two given terms, if terms are equal - then the first one is returned

not_equal?(left, right)

Is left term not equal to right term?

type_of(v)

Types

left()

@type left() :: term()

right()

@type right() :: term()

Functions

compare(left, right)

@spec compare(left(), right()) :: Comparable.ord()

Compare left and right term

Examples

iex> Comp.compare(1, 2)
:lt
iex> Comp.compare(2, 1)
:gt
iex> Comp.compare(1, 1)
:eq

defcomparable(arg1, arg2, list)

(macro)

Helper to define ordering relation for pair of types, accepts two term :: type pairs and block of code where relation is described.

Examples

iex> quote do
...>   use Comp
...>   defmodule Foo do
...>     defstruct [:value, :meta]
...>   end
...>   defmodule Bar do
...>     defstruct [:value, :meta]
...>   end
...>   defcomparable %Foo{value: left} :: Foo, %Foo{value: right} :: Foo do
...>     Comp.compare(left, right)
...>   end
...>   defcomparable %Foo{value: left} :: Foo, %Bar{value: right} :: Bar do
...>     Comp.compare(left, right)
...>   end
...>   defcomparable %Foo{value: left} :: Foo, right :: Integer do
...>     Comp.compare(left, right)
...>   end
...> end
...> |> Code.compile_quoted
iex> quote do
...>   x = %Foo{value: 1, meta: 1}
...>   y = %Foo{value: 1, meta: 2}
...>   Comp.equal?(x, y) && Comp.equal?(y, x)
...> end
...> |> Code.eval_quoted
...> |> elem(0)
true
iex> quote do
...>   x = %Foo{value: 1, meta: 1}
...>   y = %Bar{value: 1, meta: 2}
...>   Comp.equal?(x, y) && Comp.equal?(y, x)
...> end
...> |> Code.eval_quoted
...> |> elem(0)
true
iex> quote do
...>   x = %Foo{value: 1, meta: 1}
...>   y = 1
...>   Comp.equal?(x, y) && Comp.equal?(y, x)
...> end
...> |> Code.eval_quoted
...> |> elem(0)
true

eq()

(macro)

equal?(left, right)

@spec equal?(left(), right()) :: boolean()

Is left term equal to right term?

Examples

iex> Comp.equal?(1, 1)
true
iex> Comp.equal?(1, :hello)
false

greater_or_equal?(left, right)

@spec greater_or_equal?(left(), right()) :: boolean()

Is left term greater or equal to right term?

Examples

iex> Comp.greater_or_equal?(1, 1)
true
iex> Comp.greater_or_equal?(1, 2)
false
iex> Comp.greater_or_equal?(2, 1)
true

greater_than?(left, right)

@spec greater_than?(left(), right()) :: boolean()

Is left term greater than right term?

Examples

iex> Comp.greater_than?(1, 1)
false
iex> Comp.greater_than?(1, 2)
false
iex> Comp.greater_than?(2, 1)
true

gt()

(macro)

less_or_equal?(left, right)

@spec less_or_equal?(left(), right()) :: boolean()

Is left term less or equal to right term?

Examples

iex> Comp.less_or_equal?(1, 1)
true
iex> Comp.less_or_equal?(1, 2)
true
iex> Comp.less_or_equal?(2, 1)
false

less_than?(left, right)

@spec less_than?(left(), right()) :: boolean()

Is left term less than right term?

Examples

iex> Comp.less_than?(1, 1)
false
iex> Comp.less_than?(1, 2)
true
iex> Comp.less_than?(2, 1)
false

lt()

(macro)

max(left, right)

@spec max(left(), right()) :: left() | right()

Returns the biggest of the two given terms, if terms are equal - then the first one is returned

Examples

iex> Comp.max(1, 1)
1
iex> Comp.max(1, 2)
2
iex> Comp.max(2, 1)
2

min(left, right)

@spec min(left(), right()) :: left() | right()

Returns the smallest of the two given terms, if terms are equal - then the first one is returned

Examples

iex> Comp.min(1, 1)
1
iex> Comp.min(1, 2)
1
iex> Comp.min(2, 1)
1

not_equal?(left, right)

@spec not_equal?(left(), right()) :: boolean()

Is left term not equal to right term?

Examples

iex> Comp.not_equal?(1, 1)
false
iex> Comp.not_equal?(1, :hello)
true