Equality and Ordering
Equality and ordering in East may work slightly differently to how you may be used to in imperative or object-oriented languages. The main thing to keep in mind is the values of nested data is compared "deeply". Equality and ordering is defined between all East values out-of-the-box.
Comparison operators
East provides six comparison operators, much like ==, !=, <, <=, > and >= in other programming languages.
| East function | Description | Example usage | Result |
|---|---|---|---|
Equal | Determine if two values are equal | Equal(1, 2) | false |
NotEqual | Determine if two values are not equal | NotEqual(1, 2) | true |
Less | Determine if the first value is less than the second | Less(1, 2) | true |
LessEqual | Determine if the first value is less than or equal to the second | LessEqual(1, 2) | true |
Greater | Determine if the first value is greater than the second | Greater(1, 2) | false |
GreaterEqual | Determine if the first value is greater than or equal to the second | GreaterEqual(1, 2) | false |
East does not have an "object identity" check like === or Object.is in JavaScript/TypeScript.
Since it is not possible to mutate objects, the identity (location in memory where the object is stored – a pointer or reference) is not observable.
Another thing to note is that you cannot compare two incompatible types.
You cannot compare an integer and a string, since they will never by allowed in the same "slot".
You can compare null to any nullable type, or a value of type T with a value of type Nullable(T), because these types are subsets of each other.
You can also compare variants of different types, so long as they are compatible on any overlapping cases.
This holds similarly for nested data (an array of variants, or a struct containing nullable data).
See the
Comparison of nested data
The East comparison operators will inspect the contents of nested data when performing a comparison.
The fields of a struct will be inspected in order.
Two arrays are equal only if they have the same size, and each of their elements compare equal.
Expressions like Equal and Less will recursively descend into data structures until it encounters primitive values.
Equality is reflexive
While this may seem obvious, every value in East is equal to itself. And if two values are observably different in any way, they are not equal.
One place where programming languages often confuse beginners is handling of NaN and null.
According to the "standard" IEEE 754 floating-point number comparison operators, NaN != NaN.
And in some programing environments null == null returns false or even null.
The default comparisons in East use a "total ordering".
Note that IEEE 754 defines a total ordering of floats using a second set of comparison operators.
East only considers a single value for NaN, one which is greater than every other float.
All bit representations of NaN are considered identical (and signalling bits are neither observable in East nor accepted by the Elara platform).
Ordering is total
A total order is one where every value is ordered consistently with respect to every other value.
This invol
The Less
Ordering for the various data types
Boolean
Like other languages, false is less than true.
(There is often a correspondence between false and the number 0, and true and the number 1, so this ordering is consistent with that).
Integers
Integers are ordered in numerical order.
Floats
Integers are ordered in numerical order. The value NaN is greater than every other float.
Strings
Strings are ordered in lexical order (like words in a dictionary, where "cat" comes before "dog").
They are compared character by character until one character is different to another.
If one string is a prefix to another, they are said to be lesser.
For example "ab" is less than "abc".
String comparison is case sensitive. Characters are compared by their numerical Unicode code points.
Dates
Dates are ordered in chronological order. An earlier date-time is less than a later date-time.
Null
The null value is greater than every other value (including NaN) in a nullable type.
Structs
The fields in a struct are ordered.
When comparing two strings, first compare the first field, then the second.
For example (a = 1, b = 2,) is less than (a = 2, b = 1) because the first field has a lesser value.
Variants
Variants consist of set of cases, which have their own ordering. Each case has a name, or a tag (much like the fields of a struct have a name). Because flow typing (i.e. type inference) is used extensively throughout the EDK, it is usually not practical for users to define the ordering of the variant cases by hand. The EDK will automatically order variant cases by their name (or tag) as strings to provide a predictable ordering.
In that way .none null is less than .some 1, because the string "none" comes before "some".
When two variants of the same case are compared, their associated data is compared next.
Thus .some 1 is less than .some 2.
Arrays
Arrays are compared lexically, like the characters of a string.
They are compared value-by-value until the values differ or no more values remain.
So [1, 2, 3] is less than [1, 2, 4].
In the case that one array is the prefix to another, the shorter array is lesser.
For example [1, 2,] is less than [1, 2, 3,].
Sets
The keys of a set are ordered according to East's standard ordering (as described here). Two sets are compared to each other element-by-element much like an array.
For example {"a", "b",} is less than {"a", "c"}, and {"a",} is less than {"a", "b",}.
Dictionaries
The keys of a dictionary are ordered according to East's standard ordering (as described here). Two dictionaries are compared to each other entry-by-entry much like an array or set. For each entry, the key is compared first, and if the keys match the value is compared.
For example {"a": 1, "b": 2,} is less than {"a": 1, "b": 3}, and {"a": 1, "b": 2,} is less than {"a": 1, "c": 2}.
Blobs
Blobs are compared by lexical order, much like a "string of bytes".
For example 0x0102 is less than 0x0201.
Next steps
Continue to the next section to understand how to construct and deconstruct strongly typed compound data in East and Elara with structs and variants.