From a170e5342d3576c7ddf0f24f63b5c91e2b74c73a Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 19 Jan 2023 11:43:38 +0100 Subject: [PATCH 01/60] Copy initial sources from jtulach/DefaultCustomEq branch --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 30 +++++--- .../Standard/Base/0.0.0-dev/src/Data/Eq.enso | 29 ++++++++ .../Base/0.0.0-dev/src/Data/Ordering.enso | 66 +++++++++++++++++ .../Base/0.0.0-dev/src/Data/Text.enso | 8 +++ .../Base/0.0.0-dev/src/Data/Time/Date.enso | 10 +++ .../0.0.0-dev/src/Data/Time/Date_Time.enso | 9 +++ .../lib/Standard/Base/0.0.0-dev/src/Main.enso | 2 + test/Tests/src/Semantic/Eq_Spec.enso | 71 +++++++++++++++++++ 8 files changed, 216 insertions(+), 9 deletions(-) create mode 100644 distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso create mode 100644 test/Tests/src/Semantic/Eq_Spec.enso diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 29b9aadbb8da..11ff18338f8f 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -133,7 +133,7 @@ type Any Arguments: - that: The value to compare `self` against. - To have `>` defined, a type must define `compare_to`, returning an Ordering. + To have `>` defined, a type must define `comparator`, returning an Ordering. ! Implementing Greater Than Many types can admit a definition of greater than that is more efficient @@ -149,7 +149,11 @@ type Any a = 7 * 28 a > 147 > : Any -> Boolean - > self that = self.compare_to that == Ordering.Greater + > self that = case self.comparator of + Nothing -> Error.throw (Type_Error_Data Text self "self") + c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else + ordering = c.compare self that + ordering == Ordering.Greater ## ALIAS Greater Than or Equal @@ -175,9 +179,11 @@ type Any a = 6 * 21 a >= 147 >= : Any -> Boolean - >= self that = - ordering = self.compare_to that - (ordering == Ordering.Greater) || (ordering == Ordering.Equal) + >= self that = case self.comparator of + Nothing -> Error.throw (Type_Error_Data Text self "self") + c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else + ordering = c.compare self that + (ordering == Ordering.Greater) || (ordering == Ordering.Equal) ## ALIAS Less Than @@ -202,7 +208,11 @@ type Any a = 7 * 21 a < 147 < : Any -> Boolean - < self that = self.compare_to that == Ordering.Less + < self that = case self.comparator of + Nothing -> Error.throw (Type_Error_Data Text self "self") + c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else + ordering = c.compare self that + ordering == Ordering.Less ## ALIAS Less Than or Equal @@ -228,9 +238,11 @@ type Any a = 7 * 21 a < 147 <= : Any -> Boolean - <= self that = - ordering = self.compare_to that - (ordering == Ordering.Less) || (ordering == Ordering.Equal) + <= self that = case self.comparator of + Nothing -> Error.throw (Type_Error_Data Text self "self") + c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else + ordering = c.compare self that + (ordering == Ordering.Less) || (ordering == Ordering.Equal) ## Checks if the type is an instance of `Nothing`. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso new file mode 100644 index 000000000000..29039e34ae85 --- /dev/null +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso @@ -0,0 +1,29 @@ +import project.Meta +import project.IO + +from project.Data.Boolean import Boolean, True, False +from project.Data.Json import all +from project.Data.Range import all +from project.Error.Common import Error, dataflow_error_handler + +# TODO: Do we need Num_Eq? isn't that implemented in some builtin? +type Num_Eq + hash self n = n + compare self n1 n2 = if n1 == n2 then Ordering.Ordering.Equal else + if n1 < n2 then Ordering.Ordering.Less else Ordering.Ordering.Greater + +Comparable.from (_:Number) = Num_Eq + +Any.=== self that = + eq_self = Comparable.from self + eq_that = Comparable.from that + + if eq_self.is_nothing then False else + # There might be one comparator for multiple types. Therefore, we do not + # check for type equality of `self` and `that`. + similar_type = eq_self == eq_that + if similar_type.not then False else + hash_self = eq_self.hash self + hash_that = eq_that.hash that + if hash_self != hash_that then False else + eq_self.compare self that == Ordering.Ordering.Equal diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index c9ed32818d28..6d4f1682c049 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -1,6 +1,72 @@ import project.Data.Numbers.Integer import project.Error.Common.Type_Error import project.Error.Error +import project.Nothing + +## Provides custom ordering, equality check and hash code for types that need it. + + The Enso runtime system offers default implementation of _equality_ + as well as capability to _compute hash code_ (for use in `Map`) automatically. + The default implementation is sufficient for most of the programming activities. + Especially when defining new type and its constructors, they get sensible + implementation of both functions. + + Should there be a need to redefine the default implementation, here is a way: + Define function `comparator` in your `type` and return pointer to + another `type` that satisfies following definition: + + ``` + type Comparator T + compare : T -> T -> (Ordering | Nothing) + hash : T -> (Integer | Nothing) + ``` + + > Example + Representation of _rational numbers_ as a pair of integers needs a + special equality. Here is a way to define it: + + ``` + type Rational + Fraction (numerator:Integer) (denominator:Integer) + + comparator self = Rational_Ordering + ``` + + The `comparator` definition overrides the extension function on + `Any` defined by `Ordering` module and returns reference to following + type: + + ``` + type Rational_Ordering + compare self r1 r2 = + v1 = r1.numerator * r2.denominator + v2 = r2.numerator * r1.denominator + if v1 < v2 then Ordering.Less else + if v1 > v2 then Ordering.Greater else + Ordering.Equal + hash self r1 = 42 # or something better + ``` + + By defining the `Rational_Ordering` and making it available via + `Rational.comparator` method all parts of the Enso system will use + the custom `compare` and `hash` methods whenever equality or hash code + is needed. + + The equality check of two objects: + - verifies both objects share the same `comparator` + - consults their `compare` method + - if the result is `Ordering.Equal` the system also checks that both instances have the same `hash` + - the `hash` code check may be done only from time to time to speed things up + +type Comparable + compare : Any -> Any -> (Ordering | Nothing) + compare self x y = Nothing + + hash : Any -> (Integer | Nothing) + hash self x = Nothing + +Comparable.from (_:Any) = Nothing + ## Types representing the ordering of values. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index 191e7df18b50..ef8589c68625 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -50,6 +50,9 @@ type Text Ordering.from_sign comparison_result _ -> Error.throw (Type_Error.Error Text that "that") + comparator : Text_Comparator + comparator = Text_Comparator + ## Checks whether `self` is equal to `that`, ignoring the case of the texts. Arguments: @@ -134,3 +137,8 @@ type Text Conversion to Text that overrides the default `to_text` behavior. to_text : Text to_text self = self + +## PRIVATE +type Text_Comparator + compare self t1 t2 = t1.compare_to t2 + hash self _ = Error.throw "No hash for Text" diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso index 8cae6e2d46c2..a62c3cfa4b52 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso @@ -589,6 +589,7 @@ type Date format : Text -> Text format self pattern = Time_Utils.local_date_format self pattern + # TODO: Remove and replace only with comparator ## Compares `self` to `that` to produce an ordering. Arguments: @@ -605,6 +606,9 @@ type Date Ordering.from_sign sign _ -> Error.throw (Type_Error.Error Date that "that") + comparator : Date_Comparator + comparator = Date_Comparator + ## PRIVATE week_days_between start end = @@ -641,3 +645,9 @@ is_weekend date = ## PRIVATE fits_in_range start end date = (start <= date) && (date < end) + + +## PRIVATE +type Date_Comparator + compare self d1 d2 = d1.compare_to d2 + hash self _ = Error.throw "no hash for Date" diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso index 79d2eda35f23..f3d9884675d9 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso @@ -701,3 +701,12 @@ type Date_Time sign = Time_Utils.compare_to_zoneddatetime self that Ordering.from_sign sign _ -> Error.throw (Type_Error.Error Date_Time that "that") + + comparator : Date_Time_Comparator + comparator = Date_Time_Comparator + + +## PRIVATE +type Date_Time_Comparator + compare self d1 d2 = d1.compare_to d2 + hash self _ = Error.throw "no hash for Date_Time" diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso index 3b53fba97bd6..2c5d5f4ff626 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso @@ -29,6 +29,7 @@ import project.System.Platform import project.System.Process import project.System.Process.Exit_Code.Exit_Code import project.Warning.Warning +from project.Data.Eq import all export project.Any.Any export project.Data.Array.Array @@ -57,6 +58,7 @@ export project.System.Platform export project.System.Process export project.System.Process.Exit_Code.Exit_Code export project.Warning.Warning +from project.Data.Eq export all from project.Data.Boolean export Boolean, True, False from project.Function export all diff --git a/test/Tests/src/Semantic/Eq_Spec.enso b/test/Tests/src/Semantic/Eq_Spec.enso new file mode 100644 index 000000000000..7bb4457be123 --- /dev/null +++ b/test/Tests/src/Semantic/Eq_Spec.enso @@ -0,0 +1,71 @@ +# TODO[PM]: This file should be merged with Equals_Spec.enso once the usage of equality is +# unified. + +from Standard.Base import all +import Standard.Base.Data.Index_Sub_Range +from Standard.Base.Data.Eq import all + +from Standard.Test import Test, Test_Suite + +spec = + Test.group "Test equality on numbers" <| + Test.specify "Compare different numbers" <| + 10 === 20.3 . should_be_false + + Test.specify "Compare same numbers" <| + 10 === 10 . should_be_true + + Test.specify "Different hash prevents equality" <| + x = Wrong_Hash.Elem1 + y = Wrong_Hash.Elem2 + + t = x === y + t . should_equal False + + Test.group "Test inequality on numbers" <| + Test.specify "Compare two numbers" <| + x = 10 + y = 11 + t = x < y + t . should_equal True + + Test.group "Rational Numbers" <| + Test.specify "3/4 == 6/8" <| + r1 = Rational.Fraction 3 4 + r2 = Rational.Fraction 6 8 + t = r1 === r2 + t . should_equal True + + Test.specify "1/2 != 2/6" <| + r1 = Rational.Fraction 1 2 + r2 = Rational.Fraction 2 6 + t = r1 === r2 + t . should_equal False + +type Wrong_Hash + Elem1 + Elem2 + +Comparable.from (_ : Wrong_Hash) = Wrong_Hash_Eq + +type Wrong_Hash_Eq + hash self e = case e of + Wrong_Hash.Elem1 -> 1 + Wrong_Hash.Elem2 -> 2 + compare self _ _ = True + +type Rational + Fraction (numerator:Integer) (denominator:Integer) + +Comparable.from (_ : Rational) = Rational_Ordering + +type Rational_Ordering + compare self r1 r2 = + v1 = r1.numerator * r2.denominator + v2 = r2.numerator * r1.denominator + if v1 < v2 then Ordering.Less else + if v1 > v2 then Ordering.Greater else + Ordering.Equal + hash self _ = 42 + +main = Test_Suite.run_main spec From 91c227d7350ccb86d8837d23c9884cb834def0bd Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 23 Jan 2023 15:56:13 +0100 Subject: [PATCH 02/60] Comparable.from returns union of three types - Revert changes in Any, so that we have still the old behavior - Define new Any.=== , Any.<== and Any.>== operators as extension methods in Eq.enso - Make Any.hash_code accessible as a temporary workaround --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 30 ++----- .../Standard/Base/0.0.0-dev/src/Data/Eq.enso | 53 ++++++++--- .../Base/0.0.0-dev/src/Data/Ordering.enso | 87 +++++++++++++++---- .../Base/0.0.0-dev/src/Data/Text.enso | 15 ++-- .../lib/Standard/Base/0.0.0-dev/src/Main.enso | 8 ++ .../builtin/meta/HashCodeAnyNode.java | 9 ++ 6 files changed, 143 insertions(+), 59 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 11ff18338f8f..29b9aadbb8da 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -133,7 +133,7 @@ type Any Arguments: - that: The value to compare `self` against. - To have `>` defined, a type must define `comparator`, returning an Ordering. + To have `>` defined, a type must define `compare_to`, returning an Ordering. ! Implementing Greater Than Many types can admit a definition of greater than that is more efficient @@ -149,11 +149,7 @@ type Any a = 7 * 28 a > 147 > : Any -> Boolean - > self that = case self.comparator of - Nothing -> Error.throw (Type_Error_Data Text self "self") - c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else - ordering = c.compare self that - ordering == Ordering.Greater + > self that = self.compare_to that == Ordering.Greater ## ALIAS Greater Than or Equal @@ -179,11 +175,9 @@ type Any a = 6 * 21 a >= 147 >= : Any -> Boolean - >= self that = case self.comparator of - Nothing -> Error.throw (Type_Error_Data Text self "self") - c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else - ordering = c.compare self that - (ordering == Ordering.Greater) || (ordering == Ordering.Equal) + >= self that = + ordering = self.compare_to that + (ordering == Ordering.Greater) || (ordering == Ordering.Equal) ## ALIAS Less Than @@ -208,11 +202,7 @@ type Any a = 7 * 21 a < 147 < : Any -> Boolean - < self that = case self.comparator of - Nothing -> Error.throw (Type_Error_Data Text self "self") - c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else - ordering = c.compare self that - ordering == Ordering.Less + < self that = self.compare_to that == Ordering.Less ## ALIAS Less Than or Equal @@ -238,11 +228,9 @@ type Any a = 7 * 21 a < 147 <= : Any -> Boolean - <= self that = case self.comparator of - Nothing -> Error.throw (Type_Error_Data Text self "self") - c -> if that.comparator != c then Error.throw (Type_Error_Data Text that "that") else - ordering = c.compare self that - (ordering == Ordering.Less) || (ordering == Ordering.Equal) + <= self that = + ordering = self.compare_to that + (ordering == Ordering.Less) || (ordering == Ordering.Equal) ## Checks if the type is an instance of `Nothing`. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso index 29039e34ae85..81016a936a52 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso @@ -1,29 +1,54 @@ import project.Meta import project.IO +import project.Any.Any +import project.Error.Error +from project.Data.Ordering import all +from project.Data.Numbers import all from project.Data.Boolean import Boolean, True, False from project.Data.Json import all from project.Data.Range import all -from project.Error.Common import Error, dataflow_error_handler - -# TODO: Do we need Num_Eq? isn't that implemented in some builtin? -type Num_Eq - hash self n = n - compare self n1 n2 = if n1 == n2 then Ordering.Ordering.Equal else - if n1 < n2 then Ordering.Ordering.Less else Ordering.Ordering.Greater - -Comparable.from (_:Number) = Num_Eq +from project.Error.Common import Error, dataflow_error_handler, Type_Error +# New version of Any.== +Any.=== : Any -> Any -> Boolean Any.=== self that = eq_self = Comparable.from self eq_that = Comparable.from that - - if eq_self.is_nothing then False else - # There might be one comparator for multiple types. Therefore, we do not - # check for type equality of `self` and `that`. + if eq_self.is_a Incomparable then False else similar_type = eq_self == eq_that if similar_type.not then False else hash_self = eq_self.hash self hash_that = eq_that.hash that if hash_self != hash_that then False else - eq_self.compare self that == Ordering.Ordering.Equal + case eq_self.is_ordered of + True -> eq_self.compare self that == Ordering.Equal + False -> eq_self.equals self that + +Any.<== : Any -> Any -> Boolean +Any.<== self that = + assert_ordered_comparators self that <| + case (Comparable.from self).compare self that of + Ordering.Less -> True + Ordering.Equal -> True + Ordering.Greater -> False + + +Any.>== : Any -> Any -> Boolean +Any.>== self that = + assert_ordered_comparators self that <| + case (Comparable.from self).compare self that of + Ordering.Less -> False + Ordering.Equal -> True + Ordering.Greater -> True + +## PRIVATE + Checks if both comparators of the given objects are both of same type and ordered. + If they are not of same type, a `Type_Error` is thrown. + If the comparators are either `Incomparable`, or unordered, `False` is returned. +assert_ordered_comparators : Any -> Any -> (Any -> Any) -> Any +assert_ordered_comparators self that ~action = + comp_self = Comparable.from self + comp_that = Comparable.from that + if comp_self.type_of != comp_that.type_of then Error.throw (Type_Error.Error comp_self.type_of "self" self) else + if comp_self.is_a Incomparable || comp_self.is_ordered.not then False else action diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 6d4f1682c049..54bf1a2f893e 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -1,7 +1,12 @@ import project.Data.Numbers.Integer +import project.Data.Numbers.Decimal +import project.Data.Numbers.Number import project.Error.Common.Type_Error import project.Error.Error +import project.Error.Unimplemented.Unimplemented import project.Nothing +import project.Any.Any +from project.Data.Boolean import all ## Provides custom ordering, equality check and hash code for types that need it. @@ -12,15 +17,26 @@ import project.Nothing implementation of both functions. Should there be a need to redefine the default implementation, here is a way: - Define function `comparator` in your `type` and return pointer to - another `type` that satisfies following definition: + Define conversion function `Comparable.from` for your `type` and return pointer to + another `type` that satisfies either of the following two definitions: ``` - type Comparator T - compare : T -> T -> (Ordering | Nothing) - hash : T -> (Integer | Nothing) + type Default_Ordered_Comparator T + is_ordered = True + compare : T -> T -> Ordering + hash : T -> Integer + + type Default_Unordered_Comparator T + is_ordered = False + equals : T -> T -> Boolean + hash : T -> Integer ``` + There is an implicit conversion from any type to `Comparable` with `Comparable.from`. + But due to technical limitations, we cannot specify its signature in code. + The return type of `Comparable.from (_ : MyType)` is + `(Default_Ordered_Comparator|Default_Unordered_Comparator|Incomparable)`. + > Example Representation of _rational numbers_ as a pair of integers needs a special equality. Here is a way to define it: @@ -29,15 +45,16 @@ import project.Nothing type Rational Fraction (numerator:Integer) (denominator:Integer) - comparator self = Rational_Ordering + Comparable.from (_:Rational) = Rational_Ordering ``` The `comparator` definition overrides the extension function on - `Any` defined by `Ordering` module and returns reference to following + `Any` defined by `Ordering` module and returns reference to the following type: ``` type Rational_Ordering + is_ordered = True compare self r1 r2 = v1 = r1.numerator * r2.denominator v2 = r2.numerator * r1.denominator @@ -48,24 +65,56 @@ import project.Nothing ``` By defining the `Rational_Ordering` and making it available via - `Rational.comparator` method all parts of the Enso system will use - the custom `compare` and `hash` methods whenever equality or hash code - is needed. + `Comparable.from (_:Rational)` method, all parts of the Enso system will use + the custom comparator whenever equality or hash code is needed. The equality check of two objects: - - verifies both objects share the same `comparator` - - consults their `compare` method + - verifies both objects share the same type of `comparator` + - consults their `compare`, or `equals` method, based on whether the comparator is + ordered or unordered. - if the result is `Ordering.Equal` the system also checks that both instances have the same `hash` - the `hash` code check may be done only from time to time to speed things up - type Comparable - compare : Any -> Any -> (Ordering | Nothing) - compare self x y = Nothing - - hash : Any -> (Integer | Nothing) - hash self x = Nothing -Comparable.from (_:Any) = Nothing +## Singleton denoting that values of certain type are not comparable. +type Incomparable + Singleton + +## Default implementation of unordered comparator. Uses the builtin equals and hash_code. +type Default_Unordered_Comparator + is_ordered = False + + equals : Any -> Any -> Boolean + equals x y = x === y + + hash : Any -> Integer + hash object = object.hash_code + +## Default implementation of an ordered _comparator_ that forwards to `>`, `<` etc. + operators. +type Default_Ordered_Comparator + is_ordered = True + + compare : Any -> Any -> Ordering + compare x y = + if x < y then Ordering.Less else + if x === y then Ordering.Equal else + if x > y then Ordering.Greater + + hash : Number -> Integer + hash x = x.hash_code + + +# By default, there is no conversion from Any to Default_Ordered_Comparator +# Note that we allow also conversion from types, e.g., `Comparable.from Integer` +# for convenience. +Comparable.from (that:Any) = + case that of + _ : Number -> Default_Ordered_Comparator + Integer -> Default_Ordered_Comparator + Decimal -> Default_Ordered_Comparator + Number -> Default_Ordered_Comparator + _ -> Default_Unordered_Comparator ## Types representing the ordering of values. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index ef8589c68625..bf4a26899a48 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -5,6 +5,7 @@ import project.Error.Common.Type_Error import project.Error.Error import project.Meta +from project.Data.Ordering import all from project.Data.Boolean import Boolean, True, False polyglot java import org.enso.base.Text_Utils @@ -50,9 +51,6 @@ type Text Ordering.from_sign comparison_result _ -> Error.throw (Type_Error.Error Text that "that") - comparator : Text_Comparator - comparator = Text_Comparator - ## Checks whether `self` is equal to `that`, ignoring the case of the texts. Arguments: @@ -140,5 +138,12 @@ type Text ## PRIVATE type Text_Comparator - compare self t1 t2 = t1.compare_to t2 - hash self _ = Error.throw "No hash for Text" + is_ordered = True + compare t1 t2 = t1.compare_to t2 + hash text = text.hash_code + +Comparable.from (that:Text) = + case that of + _ : Text -> Text_Comparator + Text -> Text_Comparator + diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso index 2c5d5f4ff626..4e97a20bcd0c 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso @@ -78,6 +78,10 @@ import project.Data.Maybe.Maybe import project.Data.Noise import project.Data.Ordering.Natural_Order import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Incomparable +import project.Data.Ordering.Default_Unordered_Comparator +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Ordering.Sort_Direction.Sort_Direction import project.Data.Pair.Pair import project.Data.Range.Range @@ -129,6 +133,10 @@ export project.Data.Locale.Locale export project.Data.Maybe.Maybe export project.Data.Ordering.Natural_Order export project.Data.Ordering.Ordering +export project.Data.Ordering.Comparable +export project.Data.Ordering.Incomparable +export project.Data.Ordering.Default_Unordered_Comparator +export project.Data.Ordering.Default_Ordered_Comparator export project.Data.Ordering.Sort_Direction.Sort_Direction export project.Data.Pair.Pair export project.Data.Range.Range diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java index 25f976f9aac2..ec2c6e6bc57e 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java @@ -21,6 +21,7 @@ import java.time.ZonedDateTime; import java.util.Arrays; import org.enso.interpreter.dsl.AcceptsError; +import org.enso.interpreter.dsl.BuiltinMethod; import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.callable.atom.Atom; @@ -45,6 +46,14 @@ * */ @GenerateUncached +@BuiltinMethod( + type = "Any", + name = "hash_code", + description = """ + Returns hash code of this atom. Use only for overriding default Comparator. + """, + autoRegister = false +) public abstract class HashCodeAnyNode extends Node { public static HashCodeAnyNode build() { From 7e4df51106ece14967e4ef3216c195bbef0533c2 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 23 Jan 2023 16:09:54 +0100 Subject: [PATCH 03/60] Fix Eq.assert_ordered_comparators. - Must not contain `self` keyword. --- .../lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso index 81016a936a52..9ff5564d12a0 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso @@ -47,8 +47,11 @@ Any.>== self that = If they are not of same type, a `Type_Error` is thrown. If the comparators are either `Incomparable`, or unordered, `False` is returned. assert_ordered_comparators : Any -> Any -> (Any -> Any) -> Any -assert_ordered_comparators self that ~action = - comp_self = Comparable.from self +assert_ordered_comparators this that ~action = + comp_this = Comparable.from this comp_that = Comparable.from that - if comp_self.type_of != comp_that.type_of then Error.throw (Type_Error.Error comp_self.type_of "self" self) else - if comp_self.is_a Incomparable || comp_self.is_ordered.not then False else action + case Meta.type_of comp_this == Meta.type_of comp_that of + False -> + Error.throw (Type_Error.Error (Meta.type_of comp_this) "this" this) + True -> + if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action From 5b5fc70e8bca116e5e0faf81b35856c40758e75f Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 23 Jan 2023 18:40:01 +0100 Subject: [PATCH 04/60] Hide hash_code method as much as possible - Move it to Meta.hash_code --- .../Base/0.0.0-dev/src/Data/Ordering.enso | 5 ++-- .../Base/0.0.0-dev/src/Data/Text.enso | 2 +- .../lib/Standard/Base/0.0.0-dev/src/Meta.enso | 5 ++++ ...HashCodeAnyNode.java => HashCodeNode.java} | 28 +++++++++---------- .../runtime/data/hash/EnsoHashMap.java | 8 +++--- .../runtime/data/hash/EnsoHashMapBuilder.java | 18 ++++++------ .../runtime/data/hash/HashMapInsertNode.java | 4 +-- .../runtime/data/hash/HashMapRemoveNode.java | 4 +-- .../enso/interpreter/test/HashCodeTest.java | 6 ++-- 9 files changed, 43 insertions(+), 37 deletions(-) rename engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/{HashCodeAnyNode.java => HashCodeNode.java} (94%) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 54bf1a2f893e..e02df5b6e079 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -7,6 +7,7 @@ import project.Error.Unimplemented.Unimplemented import project.Nothing import project.Any.Any from project.Data.Boolean import all +import project.Meta ## Provides custom ordering, equality check and hash code for types that need it. @@ -88,7 +89,7 @@ type Default_Unordered_Comparator equals x y = x === y hash : Any -> Integer - hash object = object.hash_code + hash object = Meta.hash_code object ## Default implementation of an ordered _comparator_ that forwards to `>`, `<` etc. operators. @@ -102,7 +103,7 @@ type Default_Ordered_Comparator if x > y then Ordering.Greater hash : Number -> Integer - hash x = x.hash_code + hash x = Meta.hash_code x # By default, there is no conversion from Any to Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index bf4a26899a48..40d1a9975111 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -140,7 +140,7 @@ type Text type Text_Comparator is_ordered = True compare t1 t2 = t1.compare_to t2 - hash text = text.hash_code + hash text = Meta.hash_code text Comparable.from (that:Text) = case that of diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso index 4a6652e27d68..963e78a4ea6c 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso @@ -442,3 +442,8 @@ get_simple_type_name value = @Builtin_Method "Meta.get_simple_type_name" - value: the value to get the type of. get_qualified_type_name : Any -> Text get_qualified_type_name value = @Builtin_Method "Meta.get_qualified_type_name" + + +## PRIVATE +hash_code : Any -> Integer +hash_code x = @Builtin_Method "Meta.hash_code" diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java similarity index 94% rename from engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java rename to engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index ec2c6e6bc57e..648a53a9742c 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -47,20 +47,20 @@ */ @GenerateUncached @BuiltinMethod( - type = "Any", + type = "Meta", name = "hash_code", description = """ Returns hash code of this atom. Use only for overriding default Comparator. """, autoRegister = false ) -public abstract class HashCodeAnyNode extends Node { +public abstract class HashCodeNode extends Node { - public static HashCodeAnyNode build() { - return HashCodeAnyNodeGen.create(); + public static HashCodeNode build() { + return HashCodeNodeGen.create(); } - public abstract long execute(@AcceptsError Object self); + public abstract long execute(@AcceptsError Object object); /** Specializations for primitive values * */ @Specialization @@ -117,12 +117,12 @@ long hashCodeForAtomConstructor(AtomConstructor atomConstructor) { return System.identityHashCode(atomConstructor); } - /** How many {@link HashCodeAnyNode} nodes should be created for fields in atoms. */ + /** How many {@link HashCodeNode} nodes should be created for fields in atoms. */ static final int hashCodeNodeCountForFields = 10; - static HashCodeAnyNode[] createHashCodeNodes(int size) { - HashCodeAnyNode[] nodes = new HashCodeAnyNode[size]; - Arrays.fill(nodes, HashCodeAnyNode.build()); + static HashCodeNode[] createHashCodeNodes(int size) { + HashCodeNode[] nodes = new HashCodeNode[size]; + Arrays.fill(nodes, HashCodeNode.build()); return nodes; } @@ -130,7 +130,7 @@ static HashCodeAnyNode[] createHashCodeNodes(int size) { long hashCodeForAtom( Atom atom, @Cached(value = "createHashCodeNodes(hashCodeNodeCountForFields)", allowUncached = true) - HashCodeAnyNode[] fieldHashCodeNodes, + HashCodeNode[] fieldHashCodeNodes, @Cached ConditionProfile isHashCodeCached, @Cached ConditionProfile enoughHashCodeNodesForFields, @Cached LoopConditionProfile loopProfile) { @@ -163,7 +163,7 @@ long hashCodeForAtom( @TruffleBoundary private void hashCodeForAtomFieldsUncached(Object[] fields, int[] fieldHashes) { for (int i = 0; i < fields.length; i++) { - fieldHashes[i] = (int) HashCodeAnyNodeGen.getUncached().execute(fields[i]); + fieldHashes[i] = (int) HashCodeNodeGen.getUncached().execute(fields[i]); } } @@ -173,7 +173,7 @@ private void hashCodeForAtomFieldsUncached(Object[] fields, int[] fieldHashes) { long hashCodeForWarning( Object selfWithWarning, @CachedLibrary("selfWithWarning") WarningsLibrary warnLib, - @Cached HashCodeAnyNode hashCodeNode) { + @Cached HashCodeNode hashCodeNode) { try { return hashCodeNode.execute(warnLib.removeWarnings(selfWithWarning)); } catch (UnsupportedMessageException e) { @@ -327,7 +327,7 @@ long hashCodeForString(Object selfStr, @CachedLibrary("selfStr") InteropLibrary long hashCodeForArray( Object selfArray, @CachedLibrary("selfArray") InteropLibrary interop, - @Cached HashCodeAnyNode hashCodeNode, + @Cached HashCodeNode hashCodeNode, @Cached("createCountingProfile()") LoopConditionProfile loopProfile) { try { long arraySize = interop.getArraySize(selfArray); @@ -352,7 +352,7 @@ long hashCodeForArray( long hashCodeForMap( Object selfMap, @CachedLibrary(limit = "5") InteropLibrary interop, - @Cached HashCodeAnyNode hashCodeNode) { + @Cached HashCodeNode hashCodeNode) { int mapSize; long keysHashCode = 0; long valuesHashCode = 0; diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java index 1af429894d59..8c61c8990c69 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java @@ -12,7 +12,7 @@ import com.oracle.truffle.api.profiles.ConditionProfile; import org.enso.interpreter.dsl.Builtin; import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; -import org.enso.interpreter.node.expression.builtin.meta.HashCodeAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.Vector; @@ -58,8 +58,8 @@ static EnsoHashMap createWithBuilder(EnsoHashMapBuilder mapBuilder, int snapshot return new EnsoHashMap(mapBuilder, snapshotSize); } - static EnsoHashMap createEmpty(HashCodeAnyNode hashCodeAnyNode, EqualsAnyNode equalsNode) { - return new EnsoHashMap(EnsoHashMapBuilder.create(hashCodeAnyNode, equalsNode), 0); + static EnsoHashMap createEmpty(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { + return new EnsoHashMap(EnsoHashMapBuilder.create(hashCodeNode, equalsNode), 0); } EnsoHashMapBuilder getMapBuilder() { @@ -100,7 +100,7 @@ public void setInsertCalled() { @Builtin.Method @Builtin.Specialize public static EnsoHashMap empty( - @Cached HashCodeAnyNode hashCodeNode, @Cached EqualsAnyNode equalsNode) { + @Cached HashCodeNode hashCodeNode, @Cached EqualsAnyNode equalsNode) { return createEmpty(hashCodeNode, equalsNode); } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java index fc986cd1d195..502a1370be01 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java @@ -4,7 +4,7 @@ import java.util.ArrayList; import java.util.List; import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; -import org.enso.interpreter.node.expression.builtin.meta.HashCodeAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.graalvm.collections.EconomicMap; import org.graalvm.collections.Equivalence; @@ -18,14 +18,14 @@ public final class EnsoHashMapBuilder { /** All entries stored by their sequential index. */ private final List sequentialEntries; - private final HashCodeAnyNode hashCodeNode; + private final HashCodeNode hashCodeNode; private final EqualsAnyNode equalsNode; private int size; - private EnsoHashMapBuilder(HashCodeAnyNode hashCodeAnyNode, EqualsAnyNode equalsNode) { - this.storage = EconomicMap.create(new StorageStrategy(equalsNode, hashCodeAnyNode)); + private EnsoHashMapBuilder(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { + this.storage = EconomicMap.create(new StorageStrategy(equalsNode, hashCodeNode)); this.sequentialEntries = new ArrayList<>(); - this.hashCodeNode = hashCodeAnyNode; + this.hashCodeNode = hashCodeNode; this.equalsNode = equalsNode; } @@ -56,7 +56,7 @@ private EnsoHashMapBuilder(EnsoHashMapBuilder other) { * @param hashCodeNode Node that will be stored in the storage for invoking `hash_code` on keys. * @param equalsNode Node that will be stored in the storage for invoking `==` on keys. */ - public static EnsoHashMapBuilder create(HashCodeAnyNode hashCodeNode, EqualsAnyNode equalsNode) { + public static EnsoHashMapBuilder create(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { return new EnsoHashMapBuilder(hashCodeNode, equalsNode); } @@ -164,13 +164,13 @@ record StorageEntry( /** * Custom {@link Equivalence} used for the {@link EconomicMap} that delegates {@code equals} to - * {@link EqualsAnyNode} and {@code hash_code} to {@link HashCodeAnyNode}. + * {@link EqualsAnyNode} and {@code hash_code} to {@link HashCodeNode}. */ private static final class StorageStrategy extends Equivalence { private final EqualsAnyNode equalsNode; - private final HashCodeAnyNode hashCodeNode; + private final HashCodeNode hashCodeNode; - private StorageStrategy(EqualsAnyNode equalsNode, HashCodeAnyNode hashCodeNode) { + private StorageStrategy(EqualsAnyNode equalsNode, HashCodeNode hashCodeNode) { this.equalsNode = equalsNode; this.hashCodeNode = hashCodeNode; } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java index 52452993981e..8e449fba4869 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java @@ -11,7 +11,7 @@ import com.oracle.truffle.api.nodes.Node; import org.enso.interpreter.dsl.BuiltinMethod; import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; -import org.enso.interpreter.node.expression.builtin.meta.HashCodeAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; @BuiltinMethod( type = "Map", @@ -61,7 +61,7 @@ EnsoHashMap doEnsoHashMap(EnsoHashMap hashMap, Object key, Object value) { EnsoHashMap doForeign(Object foreignMap, Object keyToInsert, Object valueToInsert, @CachedLibrary("foreignMap") InteropLibrary mapInterop, @CachedLibrary(limit = "3") InteropLibrary iteratorInterop, - @Cached HashCodeAnyNode hashCodeNode, + @Cached HashCodeNode hashCodeNode, @Cached EqualsAnyNode equalsNode) { var mapBuilder = EnsoHashMapBuilder.create(hashCodeNode, equalsNode); try { diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java index e7cdc323d8b1..d3d773383f83 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java @@ -12,7 +12,7 @@ import com.oracle.truffle.api.nodes.Node; import org.enso.interpreter.dsl.BuiltinMethod; import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; -import org.enso.interpreter.node.expression.builtin.meta.HashCodeAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.enso.interpreter.runtime.error.DataflowError; @BuiltinMethod( @@ -49,7 +49,7 @@ EnsoHashMap removeFromEnsoMap(EnsoHashMap ensoMap, Object key) { ) EnsoHashMap removeFromInteropMap(Object map, Object keyToRemove, @CachedLibrary(limit = "5") InteropLibrary interop, - @Cached HashCodeAnyNode hashCodeNode, + @Cached HashCodeNode hashCodeNode, @Cached EqualsAnyNode equalsNode) { // We cannot simply call interop.isHashEntryExisting, because it would, most likely // use the default `hashCode` and `equals` Java methods. But we need to use our diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java index ef313514fb47..00e31a5f8c5e 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java @@ -8,7 +8,7 @@ import java.util.List; import java.util.stream.Collectors; import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; -import org.enso.interpreter.node.expression.builtin.meta.HashCodeAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Value; import org.junit.AfterClass; @@ -24,7 +24,7 @@ public class HashCodeTest extends TestBase { private static Context context; private static final InteropLibrary interop = InteropLibrary.getUncached(); - private HashCodeAnyNode hashCodeNode; + private HashCodeNode hashCodeNode; private EqualsAnyNode equalsNode; @BeforeClass @@ -37,7 +37,7 @@ public static void initContextAndData() { @Before public void initNodes() { executeInContext(context, () -> { - hashCodeNode = HashCodeAnyNode.build(); + hashCodeNode = HashCodeNode.build(); equalsNode = EqualsAnyNode.build(); return null; }); From f9c9bdd700eade1874b27abc0404372aac979e25 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 23 Jan 2023 18:40:25 +0100 Subject: [PATCH 05/60] When comparators are not of same type, comparison throws Incomparable_Values --- distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso index 9ff5564d12a0..b376ae8c5115 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso @@ -2,6 +2,7 @@ import project.Meta import project.IO import project.Any.Any import project.Error.Error +import project.Error.Incomparable_Values from project.Data.Ordering import all from project.Data.Numbers import all @@ -52,6 +53,6 @@ assert_ordered_comparators this that ~action = comp_that = Comparable.from that case Meta.type_of comp_this == Meta.type_of comp_that of False -> - Error.throw (Type_Error.Error (Meta.type_of comp_this) "this" this) + Error.throw Incomparable_Values True -> if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action From d12c485a8a69513d42560fca4205ed803e5e6bd0 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 24 Jan 2023 14:00:38 +0100 Subject: [PATCH 06/60] Any.== uses comparator pattern. Any.< is a builtin --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 52 ++- .../Standard/Base/0.0.0-dev/src/Data/Eq.enso | 58 ---- .../Base/0.0.0-dev/src/Data/Ordering.enso | 8 +- .../lib/Standard/Base/0.0.0-dev/src/Main.enso | 2 - .../builtin/meta/EqualsAnyNode.java | 13 +- .../builtin/ordering/LessThanAnyNode.java | 299 ++++++++++++++++++ 6 files changed, 359 insertions(+), 73 deletions(-) delete mode 100644 distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 29b9aadbb8da..9ddb2938df9a 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -1,4 +1,7 @@ import project.Data.Ordering.Ordering +# TODO: Will this import also the conversion methods Comparable.from (_:Any) = Default_Comparator ... ? +import project.Data.Ordering.Comparable +import project.Data.Ordering.Incomparable import project.Data.Pair.Pair import project.Data.Range.Extensions import project.Data.Text.Text @@ -101,7 +104,18 @@ type Any a = 7 * 21 a == 147 == : Any -> Boolean - == self that = @Builtin_Method "Any.==" + == self that = + eq_self = Comparable.from self + eq_that = Comparable.from that + if eq_self.is_a Incomparable then False else + similar_type = eq_self == eq_that + if similar_type.not then False else + hash_self = eq_self.hash self + hash_that = eq_that.hash that + if hash_self != hash_that then False else + case eq_self.is_ordered of + True -> eq_self.compare self that == Ordering.Equal + False -> eq_self.equals self that ## ALIAS Inequality @@ -149,7 +163,9 @@ type Any a = 7 * 28 a > 147 > : Any -> Boolean - > self that = self.compare_to that == Ordering.Greater + > self that = + assert_ordered_comparators self that <| + (Comparable.from self).compare self that == Ordering.Greater ## ALIAS Greater Than or Equal @@ -176,8 +192,11 @@ type Any a >= 147 >= : Any -> Boolean >= self that = - ordering = self.compare_to that - (ordering == Ordering.Greater) || (ordering == Ordering.Equal) + assert_ordered_comparators self that <| + case (Comparable.from self).compare self that of + Ordering.Less -> False + Ordering.Equal -> True + Ordering.Greater -> True ## ALIAS Less Than @@ -202,7 +221,9 @@ type Any a = 7 * 21 a < 147 < : Any -> Boolean - < self that = self.compare_to that == Ordering.Less + < self that = + assert_ordered_comparators self that <| + (Comparable.from self).compare self that == Ordering.Less ## ALIAS Less Than or Equal @@ -229,8 +250,11 @@ type Any a < 147 <= : Any -> Boolean <= self that = - ordering = self.compare_to that - (ordering == Ordering.Less) || (ordering == Ordering.Equal) + assert_ordered_comparators self that <| + case (Comparable.from self).compare self that of + Ordering.Less -> True + Ordering.Equal -> True + Ordering.Greater -> False ## Checks if the type is an instance of `Nothing`. @@ -396,3 +420,17 @@ type Any (+1 >> *2) 2 >> : (Any -> Any) -> (Any -> Any) -> Any -> Any >> self ~that = x -> that (self x) + + ## PRIVATE + Checks if both comparators of the given objects are both of same type and ordered. + If they are not of same type, a `Type_Error` is thrown. + If the comparators are either `Incomparable`, or unordered, `False` is returned. + assert_ordered_comparators : Any -> Any -> (Any -> Any) -> Any + assert_ordered_comparators this that ~action = + comp_this = Comparable.from this + comp_that = Comparable.from that + case Meta.type_of comp_this == Meta.type_of comp_that of + False -> + Error.throw Incomparable_Values + True -> + if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso deleted file mode 100644 index b376ae8c5115..000000000000 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Eq.enso +++ /dev/null @@ -1,58 +0,0 @@ -import project.Meta -import project.IO -import project.Any.Any -import project.Error.Error -import project.Error.Incomparable_Values -from project.Data.Ordering import all -from project.Data.Numbers import all - -from project.Data.Boolean import Boolean, True, False -from project.Data.Json import all -from project.Data.Range import all -from project.Error.Common import Error, dataflow_error_handler, Type_Error - -# New version of Any.== -Any.=== : Any -> Any -> Boolean -Any.=== self that = - eq_self = Comparable.from self - eq_that = Comparable.from that - if eq_self.is_a Incomparable then False else - similar_type = eq_self == eq_that - if similar_type.not then False else - hash_self = eq_self.hash self - hash_that = eq_that.hash that - if hash_self != hash_that then False else - case eq_self.is_ordered of - True -> eq_self.compare self that == Ordering.Equal - False -> eq_self.equals self that - -Any.<== : Any -> Any -> Boolean -Any.<== self that = - assert_ordered_comparators self that <| - case (Comparable.from self).compare self that of - Ordering.Less -> True - Ordering.Equal -> True - Ordering.Greater -> False - - -Any.>== : Any -> Any -> Boolean -Any.>== self that = - assert_ordered_comparators self that <| - case (Comparable.from self).compare self that of - Ordering.Less -> False - Ordering.Equal -> True - Ordering.Greater -> True - -## PRIVATE - Checks if both comparators of the given objects are both of same type and ordered. - If they are not of same type, a `Type_Error` is thrown. - If the comparators are either `Incomparable`, or unordered, `False` is returned. -assert_ordered_comparators : Any -> Any -> (Any -> Any) -> Any -assert_ordered_comparators this that ~action = - comp_this = Comparable.from this - comp_that = Comparable.from that - case Meta.type_of comp_this == Meta.type_of comp_that of - False -> - Error.throw Incomparable_Values - True -> - if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index e02df5b6e079..06b75daf4029 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -86,7 +86,7 @@ type Default_Unordered_Comparator is_ordered = False equals : Any -> Any -> Boolean - equals x y = x === y + equals x y = x.equals_builtin y hash : Any -> Integer hash object = Meta.hash_code object @@ -98,9 +98,9 @@ type Default_Ordered_Comparator compare : Any -> Any -> Ordering compare x y = - if x < y then Ordering.Less else - if x === y then Ordering.Equal else - if x > y then Ordering.Greater + if x.less_builtin y then Ordering.Less else + if x.equals_builtin y then Ordering.Equal else + if y.less_builtin x then Ordering.Greater hash : Number -> Integer hash x = Meta.hash_code x diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso index 4e97a20bcd0c..c435b4185ed1 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso @@ -29,7 +29,6 @@ import project.System.Platform import project.System.Process import project.System.Process.Exit_Code.Exit_Code import project.Warning.Warning -from project.Data.Eq import all export project.Any.Any export project.Data.Array.Array @@ -58,7 +57,6 @@ export project.System.Platform export project.System.Process export project.System.Process.Exit_Code.Exit_Code export project.Warning.Warning -from project.Data.Eq export all from project.Data.Boolean export Boolean, True, False from project.Function export all diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java index 6da55f4415e8..74f74829f9a7 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java @@ -42,8 +42,17 @@ @BuiltinMethod( type = "Any", - name = "==", - description = "Implementation of Any.==" + name = "equals_builtin", + description = """ + Compares self with other object and returns True iff `self` is exactly the same as + the other object, including all its transitively accessible properties or fields. + Can handle arbitrary objects, including all foreign objects. + + Does not throw exceptions. + + Note that this is different than `Meta.is_same_object`, which checks whether two + references point to the same object on the heap. + """ ) @GenerateUncached public abstract class EqualsAnyNode extends Node { diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java new file mode 100644 index 000000000000..6bacf123d021 --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java @@ -0,0 +1,299 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import com.ibm.icu.text.Normalizer; +import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; +import com.oracle.truffle.api.dsl.Cached; +import com.oracle.truffle.api.dsl.Fallback; +import com.oracle.truffle.api.dsl.GenerateUncached; +import com.oracle.truffle.api.dsl.Specialization; +import com.oracle.truffle.api.interop.InteropLibrary; +import com.oracle.truffle.api.interop.UnsupportedMessageException; +import com.oracle.truffle.api.library.CachedLibrary; +import com.oracle.truffle.api.nodes.Node; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZonedDateTime; +import org.enso.interpreter.dsl.AcceptsError; +import org.enso.interpreter.dsl.BuiltinMethod; +import org.enso.interpreter.runtime.data.text.Text; +import org.enso.interpreter.runtime.error.DataflowError; +import org.enso.interpreter.runtime.error.WarningsLibrary; +import org.enso.interpreter.runtime.number.EnsoBigInteger; + +@BuiltinMethod( + type = "Any", + name = "less_builtin", + description = """ + Returns true if self is less than `other`. Or throw an error if the values are + not comparable. + """ +) +@GenerateUncached +public abstract class LessThanAnyNode extends Node { + public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object other); + + @Specialization + boolean lessIntegers(int i, int j) { + return i < j; + } + + @Specialization + boolean lessBools(boolean b1, boolean b2) { + return !b1 && b2; + } + + @Specialization + boolean lessLongs(long l1, long l2) { + return l1 < l2; + } + + @Specialization + boolean lessDoubles(double self, double other) { + return self < other; + } + + @Specialization + boolean lessLongDouble(long self, double other) { + return (double) self < other; + } + + @Specialization + boolean lessDoubleLong(double self, long other) { + return self < (double) other; + } + + @Specialization + boolean lessIntLong(int self, long other) { + return (long) self < other; + } + + @Specialization + boolean lessLongInt(long self, int other) { + return self < (long) other; + } + + + @Specialization + boolean lessIntDouble(int self, double other) { + return (double) self < other; + } + + @Specialization + boolean lessDoubleInt(double self, int other) { + return self < (double) other; + } + + @Specialization + @TruffleBoundary + boolean lessBigInt(EnsoBigInteger self, EnsoBigInteger other) { + return self.getValue().compareTo(other.getValue()) < 0; + } + + @Specialization + @TruffleBoundary + boolean lessBitIntDouble(EnsoBigInteger self, double other) { + return self.doubleValue() < other; + } + + @Specialization + @TruffleBoundary + boolean lessDoubleBigInt(double self, EnsoBigInteger other) { + return self < other.doubleValue(); + } + + /** + * If one of the objects has warnings attached, just treat it as an object without any + * warnings. + */ + @Specialization(guards = { + "selfWarnLib.hasWarnings(selfWithWarnings) || otherWarnLib.hasWarnings(otherWithWarnings)" + }, limit = "3") + boolean lessWithWarnings(Object selfWithWarnings, Object otherWithWarnings, + @CachedLibrary("selfWithWarnings") WarningsLibrary selfWarnLib, + @CachedLibrary("otherWithWarnings") WarningsLibrary otherWarnLib, + @Cached LessThanAnyNode lessThanNode + ) { + try { + Object self = + selfWarnLib.hasWarnings(selfWithWarnings) ? selfWarnLib.removeWarnings(selfWithWarnings) + : selfWithWarnings; + Object other = + otherWarnLib.hasWarnings(otherWithWarnings) ? otherWarnLib.removeWarnings(otherWithWarnings) + : otherWithWarnings; + return lessThanNode.execute(self, other); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Specialization(limit = "3") + boolean lessTexts(Text selfText, Text otherText, + @CachedLibrary("selfText") InteropLibrary selfInterop, + @CachedLibrary("otherText") InteropLibrary otherInterop) { + if (selfText.is_normalized() && otherText.is_normalized()) { + return selfText.toString().compareTo(otherText.toString()) < 0; + } else { + return lessInteropStrings(selfText, otherText, selfInterop, otherInterop); + } + } + + @Specialization( + guards = { + "selfInterop.isString(selfStr)", + "otherInterop.isString(otherStr)" + }, + limit = "5" + ) + @TruffleBoundary + boolean lessInteropStrings(Object selfStr, Object otherStr, + @CachedLibrary("selfStr") InteropLibrary selfInterop, + @CachedLibrary("otherStr") InteropLibrary otherInterop) { + String selfJavaString; + String otherJavaString; + try { + selfJavaString = selfInterop.asString(selfStr); + otherJavaString = otherInterop.asString(otherStr); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + return Normalizer.compare( + selfJavaString, + otherJavaString, + Normalizer.FOLD_CASE_DEFAULT + ) < 0; + } + + @Specialization(guards = { + "selfInterop.isBoolean(selfBoolean)", + "otherInterop.isBoolean(otherBoolean)" + }, limit = "3") + boolean lessInteropBoolean( + Object selfBoolean, + Object otherBoolean, + @CachedLibrary("selfBoolean") InteropLibrary selfInterop, + @CachedLibrary("otherBoolean") InteropLibrary otherInterop + ) { + try { + return !selfInterop.asBoolean(selfBoolean) && otherInterop.asBoolean(otherBoolean); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @TruffleBoundary + @Specialization(guards = { + "selfInterop.isDate(selfZonedDateTime)", + "selfInterop.isTime(selfZonedDateTime)", + "selfInterop.isTimeZone(selfZonedDateTime)", + "otherInterop.isDate(otherZonedDateTime)", + "otherInterop.isTime(otherZonedDateTime)", + "otherInterop.isTimeZone(otherZonedDateTime)" + }, limit = "3") + boolean lessInteropZonedDateTimes(Object selfZonedDateTime, Object otherZonedDateTime, + @CachedLibrary("selfZonedDateTime") InteropLibrary selfInterop, + @CachedLibrary("otherZonedDateTime") InteropLibrary otherInterop) { + try { + var self = ZonedDateTime.of( + selfInterop.asDate(selfZonedDateTime), + selfInterop.asTime(selfZonedDateTime), + selfInterop.asTimeZone(selfZonedDateTime) + ); + var other = ZonedDateTime.of( + otherInterop.asDate(otherZonedDateTime), + otherInterop.asTime(otherZonedDateTime), + otherInterop.asTimeZone(otherZonedDateTime) + ); + return self.compareTo(other) < 0; + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Specialization(guards = { + "selfInterop.isDate(selfDateTime)", + "selfInterop.isTime(selfDateTime)", + "!selfInterop.isTimeZone(selfDateTime)", + "otherInterop.isDate(otherDateTime)", + "otherInterop.isTime(otherDateTime)", + "!otherInterop.isTimeZone(otherDateTime)" + }, limit = "3") + boolean lessInteropDateTimes(Object selfDateTime, Object otherDateTime, + @CachedLibrary("selfDateTime") InteropLibrary selfInterop, + @CachedLibrary("otherDateTime") InteropLibrary otherInterop) { + try { + var self = LocalDateTime.of( + selfInterop.asDate(selfDateTime), + selfInterop.asTime(selfDateTime) + ); + var other = LocalDateTime.of( + otherInterop.asDate(otherDateTime), + otherInterop.asTime(otherDateTime) + ); + return self.isBefore(other); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Specialization(guards = { + "selfInterop.isDate(selfDate)", + "!selfInterop.isTime(selfDate)", + "!selfInterop.isTimeZone(selfDate)", + "otherInterop.isDate(otherDate)", + "!otherInterop.isTime(otherDate)", + "!otherInterop.isTimeZone(otherDate)" + }, limit = "3") + boolean lessInteropDates(Object selfDate, Object otherDate, + @CachedLibrary("selfDate") InteropLibrary selfInterop, + @CachedLibrary("otherDate") InteropLibrary otherInterop) { + try { + return selfInterop.asDate(selfDate).isBefore( + otherInterop.asDate(otherDate) + ); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Specialization(guards = { + "!selfInterop.isDate(selfTime)", + "selfInterop.isTime(selfTime)", + "!selfInterop.isTimeZone(selfTime)", + "!otherInterop.isDate(otherTime)", + "otherInterop.isTime(otherTime)", + "!otherInterop.isTimeZone(otherTime)" + }, limit = "3") + boolean lessInteropTimes(Object selfTime, Object otherTime, + @CachedLibrary("selfTime") InteropLibrary selfInterop, + @CachedLibrary("otherTime") InteropLibrary otherInterop) { + try { + return selfInterop.asTime(selfTime).isBefore( + otherInterop.asTime(otherTime) + ); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Specialization(guards = { + "selfInterop.isDuration(selfDuration)", + "otherInterop.isDuration(otherDuration)" + }, limit = "3") + boolean lessInteropDuration(Object selfDuration, Object otherDuration, + @CachedLibrary("selfDuration") InteropLibrary selfInterop, + @CachedLibrary("otherDuration") InteropLibrary otherInterop) { + try { + Duration selfDur = selfInterop.asDuration(selfDuration); + Duration otherDur = otherInterop.asDuration(otherDuration); + return selfDur.compareTo(otherDur) < 0; + } catch (UnsupportedMessageException e) { + throw new IllegalStateException(e); + } + } + + @Fallback + boolean fallBack(Object self, Object other) { + // Will be 'converted' to Incomparable_Values_Error + throw DataflowError.withoutTrace("Incomparable values: " + self + " and " + other, null); + } +} From 93ed516f7aac1e0961a539a04bd3c968672e624b Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 24 Jan 2023 14:01:08 +0100 Subject: [PATCH 07/60] Refactor Eq_Spec to the newest comparator pattern. - We should remove Eq_Spec in the future. --- test/Tests/src/Semantic/Eq_Spec.enso | 41 ++++++++++++++-------------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/test/Tests/src/Semantic/Eq_Spec.enso b/test/Tests/src/Semantic/Eq_Spec.enso index 7bb4457be123..3415e3349651 100644 --- a/test/Tests/src/Semantic/Eq_Spec.enso +++ b/test/Tests/src/Semantic/Eq_Spec.enso @@ -16,31 +16,26 @@ spec = 10 === 10 . should_be_true Test.specify "Different hash prevents equality" <| - x = Wrong_Hash.Elem1 - y = Wrong_Hash.Elem2 - - t = x === y - t . should_equal False + Wrong_Hash.Elem1 === Wrong_Hash.Elem2 . should_be_false Test.group "Test inequality on numbers" <| Test.specify "Compare two numbers" <| - x = 10 - y = 11 - t = x < y - t . should_equal True + 10 <== 11 . should_be_true Test.group "Rational Numbers" <| Test.specify "3/4 == 6/8" <| - r1 = Rational.Fraction 3 4 - r2 = Rational.Fraction 6 8 - t = r1 === r2 - t . should_equal True + Rational.Fraction 3 4 === Rational.Fraction 6 8 . should_be_true Test.specify "1/2 != 2/6" <| - r1 = Rational.Fraction 1 2 - r2 = Rational.Fraction 2 6 - t = r1 === r2 - t . should_equal False + Rational.Fraction 1 2 === Rational.Fraction 2 6 . should_be_false + + Test.group "Other" <| + Test.specify "texts" <| + "aaa" === "bbb" . should_be_false + "aaa" === "aaa" . should_be_true + "xxx" === "XxX" . should_be_false + "aaa" <== "xxx" . should_be_true + "aaa" >== "xxx" . should_be_false type Wrong_Hash Elem1 @@ -49,10 +44,11 @@ type Wrong_Hash Comparable.from (_ : Wrong_Hash) = Wrong_Hash_Eq type Wrong_Hash_Eq - hash self e = case e of + is_ordered = True + hash e = case e of Wrong_Hash.Elem1 -> 1 Wrong_Hash.Elem2 -> 2 - compare self _ _ = True + compare _ _ = True type Rational Fraction (numerator:Integer) (denominator:Integer) @@ -60,12 +56,15 @@ type Rational Comparable.from (_ : Rational) = Rational_Ordering type Rational_Ordering - compare self r1 r2 = + is_ordered = True + + compare r1 r2 = v1 = r1.numerator * r2.denominator v2 = r2.numerator * r1.denominator if v1 < v2 then Ordering.Less else if v1 > v2 then Ordering.Greater else Ordering.Equal - hash self _ = 42 + + hash _ = 42 main = Test_Suite.run_main spec From 803ffb19c5391edf8c6d2ae7af8ba74a81bd200b Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 24 Jan 2023 18:34:06 +0100 Subject: [PATCH 08/60] Any.== uses equals_builtin to avoid infinite recursion --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 41 ++++++++++--------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 9ddb2938df9a..3d8e28b0c800 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -1,11 +1,10 @@ -import project.Data.Ordering.Ordering -# TODO: Will this import also the conversion methods Comparable.from (_:Any) = Default_Comparator ... ? -import project.Data.Ordering.Comparable -import project.Data.Ordering.Incomparable +# We have to import also conversion methods from Ordering, therefore, we import all +from project.Data.Ordering import all import project.Data.Pair.Pair import project.Data.Range.Extensions import project.Data.Text.Text import project.Error.Error +import project.Error.Incomparable_Values.Incomparable_Values import project.Nothing.Nothing import project.Meta @@ -108,13 +107,13 @@ type Any eq_self = Comparable.from self eq_that = Comparable.from that if eq_self.is_a Incomparable then False else - similar_type = eq_self == eq_that + similar_type = eq_self.equals_builtin eq_that if similar_type.not then False else hash_self = eq_self.hash self hash_that = eq_that.hash that - if hash_self != hash_that then False else + if hash_self.equals_builtin hash_that . not then False else case eq_self.is_ordered of - True -> eq_self.compare self that == Ordering.Equal + True -> eq_self.compare self that . equals_builtin Ordering.Equal False -> eq_self.equals self that ## ALIAS Inequality @@ -421,16 +420,18 @@ type Any >> : (Any -> Any) -> (Any -> Any) -> Any -> Any >> self ~that = x -> that (self x) - ## PRIVATE - Checks if both comparators of the given objects are both of same type and ordered. - If they are not of same type, a `Type_Error` is thrown. - If the comparators are either `Incomparable`, or unordered, `False` is returned. - assert_ordered_comparators : Any -> Any -> (Any -> Any) -> Any - assert_ordered_comparators this that ~action = - comp_this = Comparable.from this - comp_that = Comparable.from that - case Meta.type_of comp_this == Meta.type_of comp_that of - False -> - Error.throw Incomparable_Values - True -> - if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action + +## PRIVATE + Checks if both comparators of the given objects are both of same type and ordered. + If they are not of same type, a `Type_Error` is thrown. + If the comparators are either `Incomparable`, or unordered, `False` is returned. +assert_ordered_comparators : Any -> (Any -> Any) -> Any +assert_ordered_comparators this that ~action = + comp_this = Comparable.from this + comp_that = Comparable.from that + case Meta.type_of comp_this == Meta.type_of comp_that of + False -> + Error.throw Incomparable_Values + True -> + if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action + From 3d76e9f2f41fe455cb0a275ef65825263f95d098 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 24 Jan 2023 18:34:39 +0100 Subject: [PATCH 09/60] Implement LessThanAnyNode.build - fix for generated code. --- .../node/expression/builtin/ordering/LessThanAnyNode.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java index 6bacf123d021..0e70dc28db9a 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java @@ -30,6 +30,11 @@ ) @GenerateUncached public abstract class LessThanAnyNode extends Node { + + public static LessThanAnyNode build() { + return LessThanAnyNodeGen.create(); + } + public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object other); @Specialization From f4e12f8e25162e387661f4e86a7b66fd162b571c Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 25 Jan 2023 18:18:38 +0100 Subject: [PATCH 10/60] Text has Default_Ordered_Comparator --- .../lib/Standard/Base/0.0.0-dev/src/Data/Text.enso | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index 40d1a9975111..fd60f56200c2 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -136,14 +136,4 @@ type Text to_text : Text to_text self = self -## PRIVATE -type Text_Comparator - is_ordered = True - compare t1 t2 = t1.compare_to t2 - hash text = Meta.hash_code text - -Comparable.from (that:Text) = - case that of - _ : Text -> Text_Comparator - Text -> Text_Comparator - +Comparable.from (that:Text) = Default_Ordered_Comparator From 2958fa89f6f63501b623ae4c033d2cbd8b42d9ce Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 25 Jan 2023 18:19:04 +0100 Subject: [PATCH 11/60] Fix a small bug in Type.getMetaParents --- .../java/org/enso/interpreter/runtime/data/Type.java | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/Type.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/Type.java index 0fc00094ddae..bab0765a588c 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/Type.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/Type.java @@ -5,6 +5,7 @@ import com.oracle.truffle.api.interop.InteropLibrary; import com.oracle.truffle.api.interop.TruffleObject; import com.oracle.truffle.api.interop.UnknownIdentifierException; +import com.oracle.truffle.api.interop.UnsupportedMessageException; import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.library.ExportLibrary; import com.oracle.truffle.api.library.ExportMessage; @@ -192,9 +193,12 @@ Type getMetaObject() { } @ExportMessage - Object getMetaParents() { - assert supertype != null; - return new Array(supertype); + Object getMetaParents() throws UnsupportedMessageException { + if (hasMetaParents()) { + return new Array(supertype); + } else { + throw UnsupportedMessageException.create(); + } } @ExportMessage From 0bfde33963aa98466b5c9f695f31efabf1f005a2 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:31:01 +0100 Subject: [PATCH 12/60] Comparable and default comparators are builtin types --- .../Base/0.0.0-dev/src/Data/Ordering.enso | 3 +++ .../builtin/ordering/Comparable.java | 15 +++++++++++++ .../ordering/DefaultOrderedComparator.java | 9 ++++++++ .../ordering/DefaultUnorderedComparator.java | 10 +++++++++ .../interpreter/runtime/builtin/Builtins.java | 21 +++++++++++++++++++ 5 files changed, 58 insertions(+) create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 06b75daf4029..2f62faadaec6 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -75,6 +75,7 @@ import project.Meta ordered or unordered. - if the result is `Ordering.Equal` the system also checks that both instances have the same `hash` - the `hash` code check may be done only from time to time to speed things up +@Builtin_Type type Comparable ## Singleton denoting that values of certain type are not comparable. @@ -82,6 +83,7 @@ type Incomparable Singleton ## Default implementation of unordered comparator. Uses the builtin equals and hash_code. +@Builtin_Type type Default_Unordered_Comparator is_ordered = False @@ -93,6 +95,7 @@ type Default_Unordered_Comparator ## Default implementation of an ordered _comparator_ that forwards to `>`, `<` etc. operators. +@Builtin_Type type Default_Ordered_Comparator is_ordered = True diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java new file mode 100644 index 000000000000..5062313b1368 --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java @@ -0,0 +1,15 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import org.enso.interpreter.dsl.BuiltinType; +import org.enso.interpreter.node.expression.builtin.Builtin; + + +/** + * A hidden builtin. Only conversions with target type of Comparable are visible. + */ +@BuiltinType( + name = "Standard.Base.Data.Ordering.Comparable" +) +public class Comparable extends Builtin { + +} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java new file mode 100644 index 000000000000..0e47ac05f5dd --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java @@ -0,0 +1,9 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import org.enso.interpreter.dsl.BuiltinType; +import org.enso.interpreter.node.expression.builtin.Builtin; + +@BuiltinType(name = "Standard.Base.Data.Ordering.Default_Ordered_Comparator") +public class DefaultOrderedComparator extends Builtin { + +} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java new file mode 100644 index 000000000000..252975a9b71a --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java @@ -0,0 +1,10 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import org.enso.interpreter.dsl.BuiltinType; +import org.enso.interpreter.node.expression.builtin.Builtin; + +@BuiltinType(name = "Standard.Base.Data.Ordering.Default_Unordered_Comparator") +public class DefaultUnorderedComparator extends Builtin { + +} + diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java index 302055d68344..92a78425b28e 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java @@ -29,6 +29,9 @@ import org.enso.interpreter.node.expression.builtin.mutable.Array; import org.enso.interpreter.node.expression.builtin.mutable.Ref; import org.enso.interpreter.node.expression.builtin.immutable.Vector; +import org.enso.interpreter.node.expression.builtin.ordering.Comparable; +import org.enso.interpreter.node.expression.builtin.ordering.DefaultOrderedComparator; +import org.enso.interpreter.node.expression.builtin.ordering.DefaultUnorderedComparator; import org.enso.interpreter.node.expression.builtin.ordering.Ordering; import org.enso.interpreter.node.expression.builtin.resource.ManagedResource; import org.enso.interpreter.node.expression.builtin.text.Text; @@ -82,6 +85,9 @@ public static class Debug { private final Number number; private final Boolean bool; private final Ordering ordering; + private final Comparable comparable; + private final DefaultOrderedComparator defaultOrderedComparator; + private final DefaultUnorderedComparator defaultUnorderedComparator; private final System system; private final Special special; @@ -128,6 +134,9 @@ public Builtins(EnsoContext context) { error = new Error(this, context); ordering = getBuiltinType(Ordering.class); + comparable = getBuiltinType(Comparable.class); + defaultUnorderedComparator = getBuiltinType(DefaultUnorderedComparator.class); + defaultOrderedComparator = getBuiltinType(DefaultOrderedComparator.class); system = new System(this); number = new Number(this); bool = this.getBuiltinType(Boolean.class); @@ -584,6 +593,18 @@ public Ordering ordering() { return ordering; } + public Comparable comparable() { + return comparable; + } + + public DefaultOrderedComparator defaultOrderedComparator() { + return defaultOrderedComparator; + } + + public DefaultUnorderedComparator defaultUnorderedComparator() { + return defaultUnorderedComparator; + } + /** @return the container for the dataflow error-related builtins */ public Type dataflowError() { return dataflowError.getType(); From 468691bb8fda9437aefaf0f10f4ec9f5af4f2c45 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:33:11 +0100 Subject: [PATCH 13/60] Implement Comparable.equals_builtin and Comparable.less_builtin --- distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso | 9 ++++++--- .../node/expression/builtin/meta/EqualsAnyNode.java | 2 +- .../expression/builtin/ordering/LessThanAnyNode.java | 4 ++-- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 3d8e28b0c800..9494aa7ecc0a 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -107,13 +107,16 @@ type Any eq_self = Comparable.from self eq_that = Comparable.from that if eq_self.is_a Incomparable then False else - similar_type = eq_self.equals_builtin eq_that + # Comparable.equals_builtin is a hack how to directly access EqualsNode from the + # engine, so that we don't end up in an infinite recursion here. + similar_type = Comparable.equals_builtin eq_self eq_that if similar_type.not then False else hash_self = eq_self.hash self hash_that = eq_that.hash that - if hash_self.equals_builtin hash_that . not then False else + if Comparable.equals_builtin hash_self hash_that . not then False else case eq_self.is_ordered of - True -> eq_self.compare self that . equals_builtin Ordering.Equal + True -> + Comparable.equals_builtin (eq_self.compare self that) Ordering.Equal False -> eq_self.equals self that ## ALIAS Inequality diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java index 86f4b29f480a..41bf6b2e54d8 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java @@ -44,7 +44,7 @@ import org.enso.polyglot.MethodNames; @BuiltinMethod( - type = "Any", + type = "Comparable", name = "equals_builtin", description = """ Compares self with other object and returns True iff `self` is exactly the same as diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java index 0e70dc28db9a..38c256a66a36 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java @@ -21,8 +21,8 @@ import org.enso.interpreter.runtime.number.EnsoBigInteger; @BuiltinMethod( - type = "Any", - name = "less_builtin", + type = "Comparable", + name = "less_than_builtin", description = """ Returns true if self is less than `other`. Or throw an error if the values are not comparable. From 3a099b331aa5c85237519d048cedbf68cfbc97ba Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:36:51 +0100 Subject: [PATCH 14/60] Implement special handling for both EqualsNode and HashCodeNode once atom with custom comparator is encountered. - EqualsNode calls `Any.==`. - HashCodeNode calls `Comparable.hash_callback`. --- .../Base/0.0.0-dev/src/Data/Ordering.enso | 26 ++++-- .../lib/Standard/Base/0.0.0-dev/src/Meta.enso | 5 - .../builtin/meta/EqualsAnyNode.java | 91 ++++++++----------- .../expression/builtin/meta/HashCodeNode.java | 22 +++-- .../ordering/HasCustomComparatorNode.java | 79 ++++++++++++++++ .../builtin/ordering/HashCallbackNode.java | 82 +++++++++++++++++ 6 files changed, 233 insertions(+), 72 deletions(-) create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java create mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 2f62faadaec6..153e7a562dd2 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -8,6 +8,7 @@ import project.Nothing import project.Any.Any from project.Data.Boolean import all import project.Meta +import project.Meta.Atom ## Provides custom ordering, equality check and hash code for types that need it. @@ -77,6 +78,18 @@ import project.Meta - the `hash` code check may be done only from time to time to speed things up @Builtin_Type type Comparable + ## PRIVATE + Called as a callback from internal engine code for an atom with a custom + comparator. It is assumed that the given atom has a custom comparator, that is + a comparator different than `Default_Unordered_Comparator`.: + hash_callback : Atom -> Integer + hash_callback atom = (Comparable.from atom).hash atom + + ## PRIVATE + has_custom_comparator : Atom -> Boolean + has_custom_comparator atom = + comp = Comparable.from atom + (comp.is_a Default_Unordered_Comparator).not && (comp.is_a Default_Unordered_Comparator).not ## Singleton denoting that values of certain type are not comparable. type Incomparable @@ -88,10 +101,11 @@ type Default_Unordered_Comparator is_ordered = False equals : Any -> Any -> Boolean - equals x y = x.equals_builtin y + equals x y = Comparable.equals_builtin x y hash : Any -> Integer - hash object = Meta.hash_code object + hash object = Comparable.hash_builtin object + ## Default implementation of an ordered _comparator_ that forwards to `>`, `<` etc. operators. @@ -101,12 +115,12 @@ type Default_Ordered_Comparator compare : Any -> Any -> Ordering compare x y = - if x.less_builtin y then Ordering.Less else - if x.equals_builtin y then Ordering.Equal else - if y.less_builtin x then Ordering.Greater + if Comparable.less_than_builtin x y then Ordering.Less else + if Comparable.equals_builtin x y then Ordering.Equal else + if Comparable.less_than_builtin y x then Ordering.Greater hash : Number -> Integer - hash x = Meta.hash_code x + hash x = Comparable.hash_builtin x # By default, there is no conversion from Any to Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso index 963e78a4ea6c..4a6652e27d68 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Meta.enso @@ -442,8 +442,3 @@ get_simple_type_name value = @Builtin_Method "Meta.get_simple_type_name" - value: the value to get the type of. get_qualified_type_name : Any -> Text get_qualified_type_name value = @Builtin_Method "Meta.get_qualified_type_name" - - -## PRIVATE -hash_code : Any -> Integer -hash_code x = @Builtin_Method "Meta.hash_code" diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java index 41bf6b2e54d8..7edbacf89c3d 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java @@ -1,7 +1,6 @@ package org.enso.interpreter.node.expression.builtin.meta; import com.ibm.icu.text.Normalizer; -import com.ibm.icu.text.Normalizer2; import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import com.oracle.truffle.api.dsl.Cached; import com.oracle.truffle.api.dsl.Fallback; @@ -19,24 +18,24 @@ import com.oracle.truffle.api.nodes.Node; import com.oracle.truffle.api.profiles.ConditionProfile; import com.oracle.truffle.api.profiles.LoopConditionProfile; - import java.time.LocalDateTime; import java.time.ZonedDateTime; import java.util.Arrays; import java.util.Map; - import org.enso.interpreter.dsl.AcceptsError; import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.callable.ExecuteCallNode; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNodeGen.InvokeEqualsNodeGen; +import org.enso.interpreter.node.callable.InvokeCallableNode.ArgumentsExecutionMode; +import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode; +import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; +import org.enso.interpreter.node.expression.builtin.ordering.HasCustomComparatorNode; import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.callable.UnresolvedConversion; import org.enso.interpreter.runtime.callable.UnresolvedSymbol; +import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; import org.enso.interpreter.runtime.callable.atom.Atom; import org.enso.interpreter.runtime.callable.atom.AtomConstructor; import org.enso.interpreter.runtime.callable.atom.StructsLibrary; import org.enso.interpreter.runtime.callable.function.Function; -import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.WarningsLibrary; import org.enso.interpreter.runtime.number.EnsoBigInteger; @@ -483,14 +482,17 @@ boolean equalsAtoms( Atom other, @Cached LoopConditionProfile loopProfile, @Cached(value = "createEqualsNodes(equalsNodeCountForFields)", allowUncached = true) EqualsAnyNode[] fieldEqualsNodes, - @Cached InvokeEqualsNode atomInvokeEqualsNode, @Cached ConditionProfile enoughEqualNodesForFieldsProfile, @Cached ConditionProfile constructorsNotEqualProfile, @CachedLibrary(limit = "3") StructsLibrary selfStructs, - @CachedLibrary(limit = "3") StructsLibrary otherStructs + @CachedLibrary(limit = "3") StructsLibrary otherStructs, + @Cached HasCustomComparatorNode hasCustomComparatorNode, + @Cached InvokeAnyEqualsNode invokeAnyEqualsNode ) { - if (atomOverridesEquals(self)) { - return atomInvokeEqualsNode.execute(self, other); + if (hasCustomComparatorNode.execute(self)) { + // We don't check whether `other` has the same type of comparator, that is checked in + // `Any.==` that we invoke here anyway. + return invokeAnyEqualsNode.execute(self, other); } if (constructorsNotEqualProfile.profile( @@ -527,7 +529,7 @@ private static boolean equalsAtomsFieldsUncached(Object[] selfFields, Object[] o if (selfFields[i] instanceof Atom selfFieldAtom && otherFields[i] instanceof Atom otherFieldAtom && atomOverridesEquals(selfFieldAtom)) { - areFieldsSame = InvokeEqualsNode.getUncached().execute(selfFieldAtom, otherFieldAtom); + areFieldsSame = InvokeAnyEqualsNode.getUncached().execute(selfFieldAtom, otherFieldAtom); } else { areFieldsSame = EqualsAnyNodeGen.getUncached().execute(selfFields[i], otherFields[i]); } @@ -542,66 +544,47 @@ && atomOverridesEquals(selfFieldAtom)) { * Helper node for invoking `==` method on atoms, that override this method. */ @GenerateUncached - static abstract class InvokeEqualsNode extends Node { - static InvokeEqualsNode getUncached() { - return InvokeEqualsNodeGen.getUncached(); - } - - static InvokeEqualsNode build() { - return InvokeEqualsNodeGen.create(); + static abstract class InvokeAnyEqualsNode extends Node { + static InvokeAnyEqualsNode getUncached() { + return EqualsAnyNodeGen.InvokeAnyEqualsNodeGen.getUncached(); } abstract boolean execute(Atom selfAtom, Atom otherAtom); - @Specialization(guards = "cachedSelfAtomCtor == selfAtom.getConstructor()") - boolean invokeEqualsCachedAtomCtor(Atom selfAtom, Atom otherAtom, - @Cached("selfAtom.getConstructor()") AtomConstructor cachedSelfAtomCtor, - @Cached("getEqualsMethod(cachedSelfAtomCtor)") Function equalsMethod, - @Cached ExecuteCallNode executeCallNode, + @Specialization + boolean invokeEqualsCachedAtomCtor(Atom selfAtom, Atom thatAtom, + @Cached(value = "getAnyEqualsMethod()", allowUncached = true) Function anyEqualsFunc, + @Cached(value = "buildInvokeFuncNodeForAnyEquals()", allowUncached = true) InvokeFunctionNode invokeAnyEqualsNode, @CachedLibrary(limit = "3") InteropLibrary interop) { - assert atomOverridesEquals(selfAtom); - Object ret = executeCallNode.executeCall( - equalsMethod, + Object ret = invokeAnyEqualsNode.execute( + anyEqualsFunc, null, State.create(EnsoContext.get(this)), - new Object[]{selfAtom, otherAtom} + new Object[]{selfAtom, thatAtom} ); try { return interop.asBoolean(ret); } catch (UnsupportedMessageException e) { - throw new IllegalStateException(e); + throw new IllegalStateException("Return value from Any== should be Boolean", e); } + } @TruffleBoundary - @Specialization(replaces = "invokeEqualsCachedAtomCtor") - boolean invokeEqualsUncached(Atom selfAtom, Atom otherAtom, - @Cached ExecuteCallNode executeCallNode) { - Function equalsMethod = getEqualsMethod(selfAtom.getConstructor()); - Object ret = executeCallNode.executeCall( - equalsMethod, - null, - State.create(EnsoContext.get(this)), - new Object[]{selfAtom, otherAtom} - ); - assert InteropLibrary.getUncached().isBoolean(ret); - try { - return InteropLibrary.getUncached().asBoolean(ret); - } catch (UnsupportedMessageException e) { - throw new IllegalStateException(e); - } + Function getAnyEqualsMethod() { + var anyType = EnsoContext.get(this).getBuiltins().any(); + Function anyEqualsFunc = + anyType.getDefinitionScope().getMethods().get(anyType).get("=="); + assert anyEqualsFunc != null : "Any.== method must exist"; + return anyEqualsFunc; } - @TruffleBoundary - static Function getEqualsMethod(AtomConstructor atomConstructor) { - Type atomType = atomConstructor.getType(); - Function equalsFunction = atomConstructor - .getDefinitionScope() - .getMethods() - .get(atomType) - .get("=="); - assert equalsFunction != null; - return equalsFunction; + InvokeFunctionNode buildInvokeFuncNodeForAnyEquals() { + return InvokeFunctionNode.build( + new CallArgumentInfo[]{new CallArgumentInfo("self"), new CallArgumentInfo("that")}, + DefaultsExecutionMode.EXECUTE, + ArgumentsExecutionMode.EXECUTE + ); } } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index 3fa5affe9d89..e79ecb58617e 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -24,11 +24,15 @@ import org.enso.interpreter.dsl.AcceptsError; import org.enso.interpreter.dsl.BuiltinMethod; +import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; +import org.enso.interpreter.node.expression.builtin.ordering.HasCustomComparatorNode; +import org.enso.interpreter.node.expression.builtin.ordering.HashCallbackNode; import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.callable.atom.Atom; import org.enso.interpreter.runtime.callable.atom.AtomConstructor; import org.enso.interpreter.runtime.callable.atom.StructsLibrary; +import org.enso.interpreter.runtime.callable.function.Function; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.WarningsLibrary; import org.enso.interpreter.runtime.number.EnsoBigInteger; @@ -50,12 +54,11 @@ */ @GenerateUncached @BuiltinMethod( - type = "Meta", - name = "hash_code", + type = "Comparable", + name = "hash_builtin", description = """ Returns hash code of this atom. Use only for overriding default Comparator. - """, - autoRegister = false + """ ) public abstract class HashCodeNode extends Node { @@ -137,12 +140,17 @@ long hashCodeForAtom( @Cached ConditionProfile isHashCodeCached, @Cached ConditionProfile enoughHashCodeNodesForFields, @Cached LoopConditionProfile loopProfile, - @CachedLibrary(limit = "10") StructsLibrary structs) { + @CachedLibrary(limit = "10") StructsLibrary structs, + @Cached HasCustomComparatorNode hasCustomComparatorNode, + @Cached HashCallbackNode hashCallbackNode) { if (isHashCodeCached.profile(atom.getHashCode() != null)) { return atom.getHashCode(); } - // TODO[PM]: If atom overrides hash_code, call that method (Will be done in a follow-up PR for - // https://www.pivotaltracker.com/story/show/183945328) + + if (hasCustomComparatorNode.execute(atom)) { + return hashCallbackNode.execute(atom); + } + Object[] fields = structs.getFields(atom); int fieldsCount = fields.length; diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java new file mode 100644 index 000000000000..dc5ea75ecab4 --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java @@ -0,0 +1,79 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; +import com.oracle.truffle.api.dsl.Cached; +import com.oracle.truffle.api.dsl.GenerateUncached; +import com.oracle.truffle.api.dsl.Specialization; +import com.oracle.truffle.api.interop.InteropLibrary; +import com.oracle.truffle.api.interop.UnsupportedMessageException; +import com.oracle.truffle.api.library.CachedLibrary; +import com.oracle.truffle.api.nodes.Node; +import org.enso.interpreter.node.callable.InvokeCallableNode.ArgumentsExecutionMode; +import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode; +import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; +import org.enso.interpreter.runtime.EnsoContext; +import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; +import org.enso.interpreter.runtime.callable.atom.Atom; +import org.enso.interpreter.runtime.callable.function.Function; +import org.enso.interpreter.runtime.state.State; + +/** + * Helper node for invocation of {@code Comparable.has_custom_comparator atom}. + * Note that emulating the semantics of that function in Java code would be too complicated, + * so we rather implemented it in Enso and just call it from this node. + */ +@GenerateUncached +public abstract class HasCustomComparatorNode extends Node { + /** + * Returns true if the given atom has a custom comparator, that is a comparator that is different + * than the default (internal) ones. The default comparators are {@code Default_Unordered_Comparator} + * and {@code Default_Ordered_Comparator}. + * + * @param atom Atom for which we check whether it has custom comparator + * @return true iff the given atom has a custom comparator + */ + public abstract boolean execute(Atom atom); + + @Specialization + boolean hasCustomComparatorCached( + Atom atom, + @Cached(value = "getHasCustomComparatorFunction()", allowUncached = true) Function hasCustomComparatorFunc, + @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hasCustomComparatorInvokeNode, + @CachedLibrary(limit = "5") InteropLibrary interop + ) { + var ctx = EnsoContext.get(this); + var comparableType = ctx.getBuiltins().comparable().getType(); + Object res = hasCustomComparatorInvokeNode.execute( + hasCustomComparatorFunc, + null, + State.create(ctx), + new Object[]{comparableType, atom} + ); + assert interop.isBoolean(res); + try { + return interop.asBoolean(res); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException("Return type from Comparable.has_custom_comparator should be Boolean", e); + } + } + + /** + * Builds an {@link InvokeFunctionNode} for a method with just one argument named {@code atom}. + */ + static InvokeFunctionNode buildInvokeNodeWithAtomArgument() { + return InvokeFunctionNode.build( + new CallArgumentInfo[]{new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, + DefaultsExecutionMode.EXECUTE, + ArgumentsExecutionMode.EXECUTE + ); + } + + @TruffleBoundary + Function getHasCustomComparatorFunction() { + var comparableType = EnsoContext.get(this).getBuiltins().comparable().getType(); + Function hasCustomComparatorFunc = + comparableType.getDefinitionScope().getMethods().get(comparableType).get("has_custom_comparator"); + assert hasCustomComparatorFunc != null : "Comparable.has_custom_comparator function must exist"; + return hasCustomComparatorFunc; + } +} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java new file mode 100644 index 000000000000..5049a34eaaa1 --- /dev/null +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java @@ -0,0 +1,82 @@ +package org.enso.interpreter.node.expression.builtin.ordering; + +import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; +import com.oracle.truffle.api.dsl.Cached; +import com.oracle.truffle.api.dsl.GenerateUncached; +import com.oracle.truffle.api.dsl.Specialization; +import com.oracle.truffle.api.interop.InteropLibrary; +import com.oracle.truffle.api.interop.UnsupportedMessageException; +import com.oracle.truffle.api.library.CachedLibrary; +import com.oracle.truffle.api.nodes.Node; +import org.enso.interpreter.node.callable.InvokeCallableNode.ArgumentsExecutionMode; +import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode; +import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; +import org.enso.interpreter.runtime.EnsoContext; +import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; +import org.enso.interpreter.runtime.callable.atom.Atom; +import org.enso.interpreter.runtime.callable.function.Function; +import org.enso.interpreter.runtime.state.State; + +/** + * Helper node for invocation of {@code Comparable.hash_callback atom}. + * Note that emulating the semantics of that function in Java code would be too complicated, + * so we rather implemented it in Enso and just call it from this node. + */ +@GenerateUncached +public abstract class HashCallbackNode extends Node { + /** + * Dispatches to the appropriate comparator for the given atom and calls {@code hash} + * method on it. Returns the value from that method. + * + * Note that the given atom should have a custom comparator, otherwise it could be + * handled by {@link org.enso.interpreter.node.expression.builtin.meta.HashCodeNode}. + * + * @param atom Atom, preferably with a custom comparator, for which we get the custom + * comparator and call {@code hash} method on the comparator. + * @return Hash code for the atom, as returned by the custom comparator. + */ + public abstract long execute(Atom atom); + + @Specialization + long hashCallbackCached( + Atom atom, + @Cached(value = "getHashCallbackFunction()", allowUncached = true) Function hashCallbackFunc, + @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hasCustomComparatorInvokeNode, + @CachedLibrary(limit = "5") InteropLibrary interop + ) { + var ctx = EnsoContext.get(this); + var comparableType = ctx.getBuiltins().comparable().getType(); + Object res = hasCustomComparatorInvokeNode.execute( + hashCallbackFunc, + null, + State.create(ctx), + new Object[]{comparableType, atom} + ); + assert interop.fitsInLong(res); + try { + return interop.asLong(res); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException("Return type from Comparable.hash_callback should be Long", e); + } + } + + /** + * Builds an {@link InvokeFunctionNode} for a method with just one argument named {@code atom}. + */ + static InvokeFunctionNode buildInvokeNodeWithAtomArgument() { + return InvokeFunctionNode.build( + new CallArgumentInfo[]{new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, + DefaultsExecutionMode.EXECUTE, + ArgumentsExecutionMode.EXECUTE + ); + } + + @TruffleBoundary + Function getHashCallbackFunction() { + var comparableType = EnsoContext.get(this).getBuiltins().comparable().getType(); + Function hashCallback = + comparableType.getDefinitionScope().getMethods().get(comparableType).get("hash_callback"); + assert hashCallback != null : "Comparable.hash_callback function must exist"; + return hashCallback; + } +} From f75b5c12dd8a86aa20d2a9be8e3780f00225e7bc Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:41:44 +0100 Subject: [PATCH 15/60] Handle Comparable.from conversion for numbers in Numbers module --- .../lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso | 4 ++++ .../lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso | 8 +------- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso index 7e639fb38bb5..7e09b68cd530 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso @@ -1,4 +1,6 @@ import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Text.Text import project.Data.Locale.Locale import project.Error.Common.Arithmetic_Error @@ -964,6 +966,8 @@ type Integer parse_builtin text radix = @Builtin_Method "Integer.parse" +Comparable.from (_:Number) = Default_Ordered_Comparator + ## UNSTABLE A syntax error when parsing a double. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 153e7a562dd2..fac3f834349a 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -126,13 +126,7 @@ type Default_Ordered_Comparator # By default, there is no conversion from Any to Default_Ordered_Comparator # Note that we allow also conversion from types, e.g., `Comparable.from Integer` # for convenience. -Comparable.from (that:Any) = - case that of - _ : Number -> Default_Ordered_Comparator - Integer -> Default_Ordered_Comparator - Decimal -> Default_Ordered_Comparator - Number -> Default_Ordered_Comparator - _ -> Default_Unordered_Comparator +Comparable.from (that:Any) = Default_Unordered_Comparator ## Types representing the ordering of values. From ed03031e02122281ec2377575bd11c2f51392a34 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:43:47 +0100 Subject: [PATCH 16/60] Migrate Equals_Spec to the new comparator API --- test/Tests/src/Semantic/Equals_Spec.enso | 34 +++++++++++++----------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/test/Tests/src/Semantic/Equals_Spec.enso b/test/Tests/src/Semantic/Equals_Spec.enso index ec09c3f15e01..400cd6d082ff 100644 --- a/test/Tests/src/Semantic/Equals_Spec.enso +++ b/test/Tests/src/Semantic/Equals_Spec.enso @@ -14,32 +14,33 @@ type CustomEqType CustomEqType.C1 f1 -> f1 CustomEqType.C2 f1 f2 -> f1 + f2 - == self other = self.sum == other.sum +type CustomEqType_Comparator + is_ordered = False + equals o1 o2 = o1.sum == o2.sum + hash o = + comp = Comparable.from o.sum + comp.hash o.sum + +Comparable.from (_:CustomEqType) = CustomEqType_Comparator type Child Value number - == : Any -> Boolean - == self other = case other of - _ : Child -> (self.number % 100) == (other.number % 100) - _ -> False +type Child_Comparator + is_ordered = False + equals child1 child2 = child1.number % 100 == child2.number % 100 + hash child = + comp = Comparable.from child.number + (comp.hash child.number) % 100 + +Comparable.from (_:Child) = Child_Comparator type Parent Value child - == : Any -> Boolean - == self other = case other of - _ : Parent -> self.child == other.child - _ -> False - type GrandParent Value parent - == : Any -> Boolean - == self other = case other of - _ : GrandParent -> self.parent == other.parent - _ -> False - type ManyFieldType Value f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 f13 f14 f15 @@ -120,6 +121,9 @@ spec = ((Point.Value 'ś' 23.0) == (Point.Value 's\u0301' 23)) . should_be_true Test.specify "should dispatch to overriden `==` on atoms" <| + (Child.Value 11 == Child.Value 111) . should_be_true + + Test.specify "should dispatch to overriden `==` on atoms transitively" <| child1 = Child.Value 11 parent1 = Parent.Value child1 grand_parent1 = GrandParent.Value parent1 From c9716446e34b78ed477054aa4450dfe9f63d0804 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:44:02 +0100 Subject: [PATCH 17/60] Cosmetics --- .../node/callable/dispatch/IndirectInvokeFunctionNode.java | 2 +- .../enso/interpreter/runtime/callable/UnresolvedConversion.java | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/dispatch/IndirectInvokeFunctionNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/dispatch/IndirectInvokeFunctionNode.java index 376dab26697f..d3fb301ac277 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/dispatch/IndirectInvokeFunctionNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/dispatch/IndirectInvokeFunctionNode.java @@ -29,7 +29,7 @@ public abstract class IndirectInvokeFunctionNode extends Node { * Executes the {@link IndirectInvokeFunctionNode} to apply the function to given arguments. * * @param callable the function to call - * @param callerFrame the caller frame to pass to the function + * @param callerFrame the caller frame to pass to the function, may be null. * @param state the state to pass to the function * @param arguments the arguments being passed to {@code function} * @param schema the names and ordering of arguments for this call site diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/UnresolvedConversion.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/UnresolvedConversion.java index 304074816835..3c7c1bfefcb9 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/UnresolvedConversion.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/UnresolvedConversion.java @@ -40,7 +40,6 @@ public ModuleScope getScope() { * is returned. This is useful for certain subtyping relations, such as "any constructor is a * subtype of Any" or "Nat is a subtype of Int, is a subtype of Number". * - * @param constructors the constructors hierarchy for which this symbol should be resolved * @return the resolved function definition, or null if not found */ public Function resolveFor(Type into, Type from) { From c0e08e9dc14309b359d0dcffdbea1693d7214163 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:45:33 +0100 Subject: [PATCH 18/60] Fix Map visualization --- .../enso/interpreter/instrument/job/VisualizationResult.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java b/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java index 5dbaa67512d9..df6274cb1327 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java @@ -30,6 +30,10 @@ public static byte[] visualizationResultToBytes(Object value) { } catch (UnsupportedMessageException ex) { // fallthru } + } else if (iop.hasHashEntries(value)) { + return visualizationResultToBytes( + iop.toDisplayString(value) + ); } return null; } From fafd2856f18309ccfce0dfc0e34925fb01997f18 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 26 Jan 2023 19:48:07 +0100 Subject: [PATCH 19/60] Rename EqualsAnyNode to EqualsNode --- .../{EqualsAnyNode.java => EqualsNode.java} | 30 +++++++++---------- .../expression/builtin/meta/HashCodeNode.java | 2 +- .../runtime/data/hash/EnsoHashMap.java | 6 ++-- .../runtime/data/hash/EnsoHashMapBuilder.java | 14 ++++----- .../runtime/data/hash/HashMapInsertNode.java | 4 +-- .../runtime/data/hash/HashMapRemoveNode.java | 6 ++-- .../org/enso/interpreter/test/EqualsTest.java | 6 ++-- .../enso/interpreter/test/HashCodeTest.java | 6 ++-- 8 files changed, 37 insertions(+), 37 deletions(-) rename engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/{EqualsAnyNode.java => EqualsNode.java} (96%) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java similarity index 96% rename from engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java rename to engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index 7edbacf89c3d..bd8eaee5e202 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -57,12 +57,12 @@ """ ) @GenerateUncached -public abstract class EqualsAnyNode extends Node { +public abstract class EqualsNode extends Node { protected static String EQUALS_MEMBER_NAME = MethodNames.Function.EQUALS; - public static EqualsAnyNode build() { - return EqualsAnyNodeGen.create(); + public static EqualsNode build() { + return EqualsNodeGen.create(); } public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object right); @@ -141,14 +141,14 @@ boolean equalsDoubleBigInt(double self, EnsoBigInteger other) { @Specialization boolean equalsUnresolvedSymbols(UnresolvedSymbol self, UnresolvedSymbol otherSymbol, - @Cached EqualsAnyNode equalsNode) { + @Cached EqualsNode equalsNode) { return self.getName().equals(otherSymbol.getName()) && equalsNode.execute(self.getScope(), otherSymbol.getScope()); } @Specialization boolean equalsUnresolvedConversion(UnresolvedConversion selfConversion, UnresolvedConversion otherConversion, - @Cached EqualsAnyNode equalsNode) { + @Cached EqualsNode equalsNode) { return equalsNode.execute(selfConversion.getScope(), otherConversion.getScope()); } @@ -162,7 +162,7 @@ boolean equalsUnresolvedConversion(UnresolvedConversion selfConversion, Unresolv boolean equalsWithWarnings(Object selfWithWarnings, Object otherWithWarnings, @CachedLibrary("selfWithWarnings") WarningsLibrary selfWarnLib, @CachedLibrary("otherWithWarnings") WarningsLibrary otherWarnLib, - @Cached EqualsAnyNode equalsNode + @Cached EqualsNode equalsNode ) { try { Object self = @@ -401,7 +401,7 @@ boolean equalsStrings(Object selfString, Object otherString, boolean equalsArrays(Object selfArray, Object otherArray, @CachedLibrary("selfArray") InteropLibrary selfInterop, @CachedLibrary("otherArray") InteropLibrary otherInterop, - @Cached EqualsAnyNode equalsNode + @Cached EqualsNode equalsNode ) { try { long selfSize = selfInterop.getArraySize(selfArray); @@ -429,7 +429,7 @@ boolean equalsHashMaps(Object selfHashMap, Object otherHashMap, @CachedLibrary("selfHashMap") InteropLibrary selfInterop, @CachedLibrary("otherHashMap") InteropLibrary otherInterop, @CachedLibrary(limit = "5") InteropLibrary entriesInterop, - @Cached EqualsAnyNode equalsNode) { + @Cached EqualsNode equalsNode) { try { int selfHashSize = (int) selfInterop.getHashSize(selfHashMap); int otherHashSize = (int) otherInterop.getHashSize(otherHashMap); @@ -466,13 +466,13 @@ boolean equalsAtomConstructors(AtomConstructor selfConstructor, AtomConstructor } /** - * How many {@link EqualsAnyNode} should be created for fields in specialization for atoms. + * How many {@link EqualsNode} should be created for fields in specialization for atoms. */ static final int equalsNodeCountForFields = 10; - static EqualsAnyNode[] createEqualsNodes(int size) { - EqualsAnyNode[] nodes = new EqualsAnyNode[size]; - Arrays.fill(nodes, EqualsAnyNode.build()); + static EqualsNode[] createEqualsNodes(int size) { + EqualsNode[] nodes = new EqualsNode[size]; + Arrays.fill(nodes, EqualsNode.build()); return nodes; } @@ -481,7 +481,7 @@ boolean equalsAtoms( Atom self, Atom other, @Cached LoopConditionProfile loopProfile, - @Cached(value = "createEqualsNodes(equalsNodeCountForFields)", allowUncached = true) EqualsAnyNode[] fieldEqualsNodes, + @Cached(value = "createEqualsNodes(equalsNodeCountForFields)", allowUncached = true) EqualsNode[] fieldEqualsNodes, @Cached ConditionProfile enoughEqualNodesForFieldsProfile, @Cached ConditionProfile constructorsNotEqualProfile, @CachedLibrary(limit = "3") StructsLibrary selfStructs, @@ -531,7 +531,7 @@ private static boolean equalsAtomsFieldsUncached(Object[] selfFields, Object[] o && atomOverridesEquals(selfFieldAtom)) { areFieldsSame = InvokeAnyEqualsNode.getUncached().execute(selfFieldAtom, otherFieldAtom); } else { - areFieldsSame = EqualsAnyNodeGen.getUncached().execute(selfFields[i], otherFields[i]); + areFieldsSame = EqualsNodeGen.getUncached().execute(selfFields[i], otherFields[i]); } if (!areFieldsSame) { return false; @@ -546,7 +546,7 @@ && atomOverridesEquals(selfFieldAtom)) { @GenerateUncached static abstract class InvokeAnyEqualsNode extends Node { static InvokeAnyEqualsNode getUncached() { - return EqualsAnyNodeGen.InvokeAnyEqualsNodeGen.getUncached(); + return EqualsNodeGen.InvokeAnyEqualsNodeGen.getUncached(); } abstract boolean execute(Atom selfAtom, Atom otherAtom); diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index e79ecb58617e..dbd13cf54115 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -45,7 +45,7 @@ *

Hashing contract:

* *
    - *
  • Whenever two objects are equal ({@code EqualsAnyNode} returns {@code true}), their hashcode + *
  • Whenever two objects are equal ({@code EqualsNode} returns {@code true}), their hashcode * should equal. More formally: {@code For all objects o1, o2: if o1 == o2 then hash(o1) == * hash(o2)} *
  • Whenever two hash codes are different, their associated objects are different: {@code For all objects diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java index 8c61c8990c69..3b8af79785db 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMap.java @@ -11,7 +11,7 @@ import com.oracle.truffle.api.library.ExportMessage; import com.oracle.truffle.api.profiles.ConditionProfile; import org.enso.interpreter.dsl.Builtin; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.data.Type; @@ -58,7 +58,7 @@ static EnsoHashMap createWithBuilder(EnsoHashMapBuilder mapBuilder, int snapshot return new EnsoHashMap(mapBuilder, snapshotSize); } - static EnsoHashMap createEmpty(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { + static EnsoHashMap createEmpty(HashCodeNode hashCodeNode, EqualsNode equalsNode) { return new EnsoHashMap(EnsoHashMapBuilder.create(hashCodeNode, equalsNode), 0); } @@ -100,7 +100,7 @@ public void setInsertCalled() { @Builtin.Method @Builtin.Specialize public static EnsoHashMap empty( - @Cached HashCodeNode hashCodeNode, @Cached EqualsAnyNode equalsNode) { + @Cached HashCodeNode hashCodeNode, @Cached EqualsNode equalsNode) { return createEmpty(hashCodeNode, equalsNode); } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java index 502a1370be01..eb77a438949a 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/EnsoHashMapBuilder.java @@ -3,7 +3,7 @@ import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import java.util.ArrayList; import java.util.List; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.graalvm.collections.EconomicMap; import org.graalvm.collections.Equivalence; @@ -19,10 +19,10 @@ public final class EnsoHashMapBuilder { private final List sequentialEntries; private final HashCodeNode hashCodeNode; - private final EqualsAnyNode equalsNode; + private final EqualsNode equalsNode; private int size; - private EnsoHashMapBuilder(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { + private EnsoHashMapBuilder(HashCodeNode hashCodeNode, EqualsNode equalsNode) { this.storage = EconomicMap.create(new StorageStrategy(equalsNode, hashCodeNode)); this.sequentialEntries = new ArrayList<>(); this.hashCodeNode = hashCodeNode; @@ -56,7 +56,7 @@ private EnsoHashMapBuilder(EnsoHashMapBuilder other) { * @param hashCodeNode Node that will be stored in the storage for invoking `hash_code` on keys. * @param equalsNode Node that will be stored in the storage for invoking `==` on keys. */ - public static EnsoHashMapBuilder create(HashCodeNode hashCodeNode, EqualsAnyNode equalsNode) { + public static EnsoHashMapBuilder create(HashCodeNode hashCodeNode, EqualsNode equalsNode) { return new EnsoHashMapBuilder(hashCodeNode, equalsNode); } @@ -164,13 +164,13 @@ record StorageEntry( /** * Custom {@link Equivalence} used for the {@link EconomicMap} that delegates {@code equals} to - * {@link EqualsAnyNode} and {@code hash_code} to {@link HashCodeNode}. + * {@link EqualsNode} and {@code hash_code} to {@link HashCodeNode}. */ private static final class StorageStrategy extends Equivalence { - private final EqualsAnyNode equalsNode; + private final EqualsNode equalsNode; private final HashCodeNode hashCodeNode; - private StorageStrategy(EqualsAnyNode equalsNode, HashCodeNode hashCodeNode) { + private StorageStrategy(EqualsNode equalsNode, HashCodeNode hashCodeNode) { this.equalsNode = equalsNode; this.hashCodeNode = hashCodeNode; } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java index 8e449fba4869..c33e1eb66d48 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapInsertNode.java @@ -10,7 +10,7 @@ import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.nodes.Node; import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; @BuiltinMethod( @@ -62,7 +62,7 @@ EnsoHashMap doForeign(Object foreignMap, Object keyToInsert, Object valueToInser @CachedLibrary("foreignMap") InteropLibrary mapInterop, @CachedLibrary(limit = "3") InteropLibrary iteratorInterop, @Cached HashCodeNode hashCodeNode, - @Cached EqualsAnyNode equalsNode) { + @Cached EqualsNode equalsNode) { var mapBuilder = EnsoHashMapBuilder.create(hashCodeNode, equalsNode); try { Object entriesIterator = mapInterop.getHashEntriesIterator(foreignMap); diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java index d3d773383f83..c7ce1b7c8b9c 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/hash/HashMapRemoveNode.java @@ -11,7 +11,7 @@ import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.nodes.Node; import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.enso.interpreter.runtime.error.DataflowError; @@ -50,10 +50,10 @@ EnsoHashMap removeFromEnsoMap(EnsoHashMap ensoMap, Object key) { EnsoHashMap removeFromInteropMap(Object map, Object keyToRemove, @CachedLibrary(limit = "5") InteropLibrary interop, @Cached HashCodeNode hashCodeNode, - @Cached EqualsAnyNode equalsNode) { + @Cached EqualsNode equalsNode) { // We cannot simply call interop.isHashEntryExisting, because it would, most likely // use the default `hashCode` and `equals` Java methods. But we need to use our - // EqualsAnyNode, so we do the check for non-existing key inside the while loop. + // EqualsNode, so we do the check for non-existing key inside the while loop. boolean keyToRemoveFound = false; var mapBuilder = EnsoHashMapBuilder.create(hashCodeNode, equalsNode); try { diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java index 7cce0da56e88..58e16c37b061 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java @@ -5,7 +5,7 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Value; import org.junit.AfterClass; @@ -19,7 +19,7 @@ @RunWith(Theories.class) public class EqualsTest extends TestBase { private static Context context; - private EqualsAnyNode equalsNode; + private EqualsNode equalsNode; @BeforeClass public static void initContextAndData() { @@ -32,7 +32,7 @@ public void initNodes() { executeInContext( context, () -> { - equalsNode = EqualsAnyNode.build(); + equalsNode = EqualsNode.build(); return null; }); } diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java index 00e31a5f8c5e..56773850253e 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java @@ -7,7 +7,7 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; -import org.enso.interpreter.node.expression.builtin.meta.EqualsAnyNode; +import org.enso.interpreter.node.expression.builtin.meta.EqualsNode; import org.enso.interpreter.node.expression.builtin.meta.HashCodeNode; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Value; @@ -25,7 +25,7 @@ public class HashCodeTest extends TestBase { private static final InteropLibrary interop = InteropLibrary.getUncached(); private HashCodeNode hashCodeNode; - private EqualsAnyNode equalsNode; + private EqualsNode equalsNode; @BeforeClass public static void initContextAndData() { @@ -38,7 +38,7 @@ public static void initContextAndData() { public void initNodes() { executeInContext(context, () -> { hashCodeNode = HashCodeNode.build(); - equalsNode = EqualsAnyNode.build(); + equalsNode = EqualsNode.build(); return null; }); } From 07e79d995e3cf79d9744a5d1005e53cf1959a023 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 09:05:15 +0100 Subject: [PATCH 20/60] Rename LessThanAnyNode to LessThanNode --- .../ordering/{LessThanAnyNode.java => LessThanNode.java} | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) rename engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/{LessThanAnyNode.java => LessThanNode.java} (98%) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java similarity index 98% rename from engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java rename to engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java index 38c256a66a36..cc167b33c5a3 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanAnyNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java @@ -29,10 +29,10 @@ """ ) @GenerateUncached -public abstract class LessThanAnyNode extends Node { +public abstract class LessThanNode extends Node { - public static LessThanAnyNode build() { - return LessThanAnyNodeGen.create(); + public static LessThanNode build() { + return LessThanNodeGen.create(); } public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object other); @@ -116,7 +116,7 @@ boolean lessDoubleBigInt(double self, EnsoBigInteger other) { boolean lessWithWarnings(Object selfWithWarnings, Object otherWithWarnings, @CachedLibrary("selfWithWarnings") WarningsLibrary selfWarnLib, @CachedLibrary("otherWithWarnings") WarningsLibrary otherWarnLib, - @Cached LessThanAnyNode lessThanNode + @Cached LessThanNode lessThanNode ) { try { Object self = From 5087323fffcf4e3262ec2aad2062efa7c1f9daa2 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 09:20:36 +0100 Subject: [PATCH 21/60] EqualsNode and LessThanNode is a static builtin method --- .../interpreter/node/expression/builtin/meta/EqualsNode.java | 3 ++- .../node/expression/builtin/ordering/LessThanNode.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index bd8eaee5e202..e7e647193fe3 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -65,7 +65,7 @@ public static EqualsNode build() { return EqualsNodeGen.create(); } - public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object right); + public abstract boolean execute(@AcceptsError Object left, @AcceptsError Object right); /** * Primitive values @@ -556,6 +556,7 @@ boolean invokeEqualsCachedAtomCtor(Atom selfAtom, Atom thatAtom, @Cached(value = "getAnyEqualsMethod()", allowUncached = true) Function anyEqualsFunc, @Cached(value = "buildInvokeFuncNodeForAnyEquals()", allowUncached = true) InvokeFunctionNode invokeAnyEqualsNode, @CachedLibrary(limit = "3") InteropLibrary interop) { + // TODO: Shouldn't Comparable type be the very first argument? (synthetic self)? Object ret = invokeAnyEqualsNode.execute( anyEqualsFunc, null, diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java index cc167b33c5a3..8f0c63f60170 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java @@ -35,7 +35,7 @@ public static LessThanNode build() { return LessThanNodeGen.create(); } - public abstract boolean execute(@AcceptsError Object self, @AcceptsError Object other); + public abstract boolean execute(@AcceptsError Object left, @AcceptsError Object other); @Specialization boolean lessIntegers(int i, int j) { From c1699ea051d47fcc0c3235e994b3827b466f8275 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 09:35:44 +0100 Subject: [PATCH 22/60] Handle cases when there is no conversion to Comparable in Any.== --- distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 9494aa7ecc0a..f735554b538b 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -5,8 +5,10 @@ import project.Data.Range.Extensions import project.Data.Text.Text import project.Error.Error import project.Error.Incomparable_Values.Incomparable_Values +import project.Error.Common.No_Such_Conversion import project.Nothing.Nothing import project.Meta +import project.Panic.Panic from project.Data.Boolean import Boolean, True, False @@ -104,8 +106,10 @@ type Any a == 147 == : Any -> Boolean == self that = - eq_self = Comparable.from self - eq_that = Comparable.from that + # If there is No_Such_Conversion, then `self` and `that` are probably + # host or polyglot values, so we just compare them with the default comparator. + eq_self = Panic.catch No_Such_Conversion (Comparable.from self) _-> Default_Unordered_Comparator + eq_that = Panic.catch No_Such_Conversion (Comparable.from that) _-> Default_Unordered_Comparator if eq_self.is_a Incomparable then False else # Comparable.equals_builtin is a hack how to directly access EqualsNode from the # engine, so that we don't end up in an infinite recursion here. From bd2a5ff525a2c978d22434cbbf68840ec621642c Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 18:56:55 +0100 Subject: [PATCH 23/60] Add specializations for types, files, modules and interop values with members to Eq/Hash nodes --- .../expression/builtin/meta/EqualsNode.java | 120 +++++++++++++++++- .../expression/builtin/meta/HashCodeNode.java | 115 ++++++++++++++++- 2 files changed, 229 insertions(+), 6 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index e7e647193fe3..a71509ce3a92 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -29,6 +29,7 @@ import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; import org.enso.interpreter.node.expression.builtin.ordering.HasCustomComparatorNode; import org.enso.interpreter.runtime.EnsoContext; +import org.enso.interpreter.runtime.Module; import org.enso.interpreter.runtime.callable.UnresolvedConversion; import org.enso.interpreter.runtime.callable.UnresolvedSymbol; import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; @@ -36,9 +37,13 @@ import org.enso.interpreter.runtime.callable.atom.AtomConstructor; import org.enso.interpreter.runtime.callable.atom.StructsLibrary; import org.enso.interpreter.runtime.callable.function.Function; +import org.enso.interpreter.runtime.data.EnsoFile; +import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.WarningsLibrary; +import org.enso.interpreter.runtime.library.dispatch.TypesLibrary; import org.enso.interpreter.runtime.number.EnsoBigInteger; +import org.enso.interpreter.runtime.scope.ModuleScope; import org.enso.interpreter.runtime.state.State; import org.enso.polyglot.MethodNames; @@ -152,6 +157,40 @@ boolean equalsUnresolvedConversion(UnresolvedConversion selfConversion, Unresolv return equalsNode.execute(selfConversion.getScope(), otherConversion.getScope()); } + @Specialization + boolean equalsModuleScopes(ModuleScope selfModuleScope, ModuleScope otherModuleScope, + @Cached EqualsNode equalsNode) { + return equalsNode.execute(selfModuleScope.getModule(), otherModuleScope.getModule()); + } + + @Specialization + @TruffleBoundary + boolean equalsModules(Module selfModule, Module otherModule, + @Cached EqualsNode equalsNode) { + return equalsNode.execute(selfModule.getName().toString(), otherModule.getName().toString()); + } + + @Specialization + boolean equalsFiles(EnsoFile selfFile, EnsoFile otherFile, + @CachedLibrary(limit = "5") InteropLibrary interop) { + return equalsStrings(selfFile.getPath(), otherFile.getPath(), interop, interop); + } + + /** + * There is no specialization for {@link TypesLibrary#hasType(Object)}, because also + * primitive values would fall into that specialization and it would be too complicated + * to make that specialization disjunctive. So we rather specialize directly for + * {@link Type types}. + */ + @Specialization + boolean equalsTypes(Type selfType, Type otherType, + @Cached EqualsNode equalsNode) { + return equalsNode.execute( + selfType.getQualifiedName().toString(), + otherType.getQualifiedName().toString() + ); + } + /** * If one of the objects has warnings attached, just treat it as an object without any * warnings. @@ -202,8 +241,10 @@ boolean equalsNull( } @Specialization(guards = { - "isHostObject(selfHostObject)", - "isHostObject(otherHostObject)", + // HostFunction is identified by a qualified name, it is not a lambda. + // It has well-defined equality based on the qualified name. + "isHostObject(selfHostObject) || isHostFunction(selfHostObject)", + "isHostObject(otherHostObject) || isHostFunction(otherHostObject)", }) boolean equalsHostObjects( Object selfHostObject, Object otherHostObject, @@ -458,6 +499,60 @@ boolean equalsHashMaps(Object selfHashMap, Object otherHashMap, } } + @Specialization(guards = { + "interop.hasMembers(selfObject)", + "interop.hasMembers(otherObject)", + // Objects with types are handled in `equalsTypes` specialization, so we have to + // negate the guards of that specialization here - to make the specializations + // disjunctive. + "!typesLib.hasType(selfObject)", + "!typesLib.hasType(otherObject)" + }) + boolean equalsInteropObjectWithMembers(Object selfObject, Object otherObject, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "5") TypesLibrary typesLib, + @Cached EqualsNode equalsNode) { + try { + Object selfMembers = interop.getMembers(selfObject); + Object otherMembers = interop.getMembers(otherObject); + assert interop.getArraySize(selfMembers) < Integer.MAX_VALUE : "Long array sizes not supported"; + int membersSize = (int) interop.getArraySize(selfMembers); + if (interop.getArraySize(otherMembers) != membersSize) { + return false; + } + + // Check member names + String[] memberNames = new String[membersSize]; + for (int i = 0; i < membersSize; i++) { + String selfMemberName = interop.asString(interop.readArrayElement(selfMembers, i)); + String otherMemberName = interop.asString(interop.readArrayElement(otherMembers, i)); + if (!equalsNode.execute(selfMemberName, otherMemberName)) { + return false; + } + memberNames[i] = selfMemberName; + } + + // Check member values + for (int i = 0; i < membersSize; i++) { + if (interop.isMemberReadable(selfObject, memberNames[i]) && + interop.isMemberReadable(otherObject, memberNames[i])) { + Object selfMember = interop.readMember(selfObject, memberNames[i]); + Object otherMember = interop.readMember(otherObject, memberNames[i]); + if (!equalsNode.execute(selfMember, otherMember)) { + return false; + } + } + } + return true; + } catch (UnsupportedMessageException | InvalidArrayIndexException | UnknownIdentifierException e) { + throw new IllegalStateException( + String.format("One of the interop objects has probably wrongly specified interop API " + + "for members. selfObject = %s ; otherObject = %s", selfObject, otherObject), + e + ); + } + } + /** Equals for Atoms and AtomConstructors */ @Specialization @@ -610,14 +705,31 @@ private static boolean atomOverridesEquals(Atom atom) { @Fallback @TruffleBoundary boolean equalsGeneric(Object left, Object right, - @CachedLibrary(limit = "5") InteropLibrary interop) { + @CachedLibrary(limit = "5") InteropLibrary interop, + @CachedLibrary(limit = "5") TypesLibrary typesLib) { return left == right || interop.isIdentical(left, right, interop) - || left.equals(right); + || left.equals(right) + || (isNullOrNothing(left, typesLib, interop) && isNullOrNothing(right, typesLib, interop)); + } + + private boolean isNullOrNothing(Object object, TypesLibrary typesLib, InteropLibrary interop) { + if (typesLib.hasType(object)) { + return typesLib.getType(object) == EnsoContext.get(this).getNothing(); + } else if (interop.isNull(object)) { + return true; + } else { + return object == null; + } } @TruffleBoundary boolean isHostObject(Object object) { return EnsoContext.get(this).getEnvironment().isHostObject(object); } + + @TruffleBoundary + boolean isHostFunction(Object object) { + return EnsoContext.get(this).getEnvironment().isHostFunction(object); + } } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index dbd13cf54115..1d1a5d8312d5 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -1,5 +1,6 @@ package org.enso.interpreter.node.expression.builtin.meta; +import com.google.common.base.Objects; import com.ibm.icu.text.Normalizer2; import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary; import com.oracle.truffle.api.dsl.Cached; @@ -24,18 +25,23 @@ import org.enso.interpreter.dsl.AcceptsError; import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; import org.enso.interpreter.node.expression.builtin.ordering.HasCustomComparatorNode; import org.enso.interpreter.node.expression.builtin.ordering.HashCallbackNode; import org.enso.interpreter.runtime.EnsoContext; +import org.enso.interpreter.runtime.Module; +import org.enso.interpreter.runtime.callable.UnresolvedConversion; +import org.enso.interpreter.runtime.callable.UnresolvedSymbol; import org.enso.interpreter.runtime.callable.atom.Atom; import org.enso.interpreter.runtime.callable.atom.AtomConstructor; import org.enso.interpreter.runtime.callable.atom.StructsLibrary; -import org.enso.interpreter.runtime.callable.function.Function; +import org.enso.interpreter.runtime.data.EnsoFile; +import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.WarningsLibrary; +import org.enso.interpreter.runtime.library.dispatch.TypesLibrary; import org.enso.interpreter.runtime.number.EnsoBigInteger; +import org.enso.interpreter.runtime.scope.ModuleScope; /** * Implements {@code hash_code} functionality. @@ -123,6 +129,56 @@ long hashCodeForAtomConstructor(AtomConstructor atomConstructor) { return System.identityHashCode(atomConstructor); } + @Specialization + long hashCodeForUnresolvedSymbol(UnresolvedSymbol unresolvedSymbol, + @Cached HashCodeNode hashCodeNode) { + long nameHash = hashCodeNode.execute(unresolvedSymbol.getName()); + long scopeHash = hashCodeNode.execute(unresolvedSymbol.getScope()); + return Objects.hashCode(nameHash, scopeHash); + } + + @Specialization + long hashCodeForUnresolvedConversion(UnresolvedConversion unresolvedConversion, + @CachedLibrary(limit = "5") InteropLibrary interop) { + return hashCodeForModuleScope(unresolvedConversion.getScope(), interop); + } + + @Specialization + long hashCodeForModuleScope(ModuleScope moduleScope, + @CachedLibrary(limit = "5") InteropLibrary interop) { + return hashCodeForModule(moduleScope.getModule(), interop); + } + + @Specialization + @TruffleBoundary + long hashCodeForModule(Module module, + @CachedLibrary(limit = "5") InteropLibrary interop) { + return hashCodeForString(module.toString(), interop); + } + + @Specialization + long hashCodeForFile(EnsoFile file, + @CachedLibrary(limit = "5") InteropLibrary interop) { + return hashCodeForString(file.getPath(), interop); + } + + /** + * There is no specialization for {@link TypesLibrary#hasType(Object)}, because also + * primitive values would fall into that specialization and it would be too complicated + * to make that specialization disjunctive. So we rather specialize directly for + * {@link Type}. + */ + @Specialization + long hashCodeForType(Type type, + @Cached HashCodeNode hashCodeNode) { + if (EnsoContext.get(this).getNothing() == type) { + // Nothing should be equal to `null` + return 0; + } else { + return hashCodeNode.execute(type.getQualifiedName().toString()); + } + } + /** How many {@link HashCodeNode} nodes should be created for fields in atoms. */ static final int hashCodeNodeCountForFields = 10; @@ -386,6 +442,44 @@ long hashCodeForMap( return Arrays.hashCode(new long[] {keysHashCode, valuesHashCode, mapSize}); } + @Specialization(guards = { + "interop.hasMembers(objectWithMembers)", + // Object with type is handled in `hashCodeForType` specialization, so we have to + // negate the guard of that specialization here - to make the specializations + // disjunctive. + "!typesLib.hasType(objectWithMembers)" + }) + long hashCodeForInteropObjectWithMembers(Object objectWithMembers, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "5") TypesLibrary typesLib, + @Cached HashCodeNode hashCodeNode) { + try { + Object members = interop.getMembers(objectWithMembers); + assert interop.getArraySize(members) < Integer.MAX_VALUE : "long array size not supported"; + int size = (int) interop.getArraySize(members); + // Final hash code will be put together from member names and member values. + long[] hashCodes = new long[size * 2]; + int hashCodesIdx = 0; + for (int i = 0; i < size; i++) { + String memberName = interop.asString(interop.readArrayElement(members, i)); + hashCodes[hashCodesIdx++] = hashCodeNode.execute(memberName); + if (interop.isMemberReadable(objectWithMembers, memberName)) { + Object member = interop.readMember(objectWithMembers, memberName); + hashCodes[hashCodesIdx++] = hashCodeNode.execute(member); + } else { + hashCodes[hashCodesIdx++] = 0; + } + } + return Arrays.hashCode(hashCodes); + } catch (UnsupportedMessageException | InvalidArrayIndexException | UnknownIdentifierException e) { + throw new IllegalStateException( + String.format("An interop object (%s) has probably wrongly specified interop API" + + " for members.", objectWithMembers), + e + ); + } + } + @Specialization( guards = {"interop.isNull(selfNull)"}, limit = "3") @@ -408,8 +502,25 @@ long hashCodeForHostObject( } } + /** + * Every host function has a unique fully qualified name, it is not a lambda. + * We get the hashcode from the qualified name. + */ + @TruffleBoundary + @Specialization(guards = "isHostFunction(hostFunction)") + long hashCodeForHostFunction(Object hostFunction, + @CachedLibrary(limit = "3") InteropLibrary interop, + @Cached HashCodeNode hashCodeNode) { + return hashCodeNode.execute(interop.toDisplayString(hostFunction)); + } + @TruffleBoundary boolean isHostObject(Object object) { return EnsoContext.get(this).getEnvironment().isHostObject(object); } + + @TruffleBoundary + boolean isHostFunction(Object object) { + return EnsoContext.get(this).getEnvironment().isHostFunction(object); + } } From f2937524d49f453d701bd23491017e7b21b0e389 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 18:57:48 +0100 Subject: [PATCH 24/60] Array.sort respect new comparator API --- .../Standard/Base/0.0.0-dev/src/Data/Array.enso | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso index 387cb58a4e37..85f4a37bd69b 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso @@ -137,7 +137,7 @@ type Array ## Sorts the Array. Arguments: - - comparator: A comparison function that takes two elements and returns + - compare_func: A comparison function that takes two elements and returns an Ordering that describes how the first element is ordered with respect to the second. @@ -146,8 +146,8 @@ type Array [3,2,1].to_array.sort sort : (Any -> Any -> Ordering) -> Array - sort self comparator=(_.compare_to _) = - self.sort_builtin comparator + sort self compare_func=(default_compare _ _) = + self.sort_builtin compare_func ## Identity. @@ -155,3 +155,14 @@ type Array primitive array protocol. to_array : Array to_array self = @Builtin_Method "Array.to_array" + + +## PRIVATE +## UNSTABLE + We call operators from `Any.<` which checks for ordered comparators. + TODO[PM]: This about adding comparator parameter to `Array.sort`. +default_compare x y = + if x < y then Ordering.Less else + if x == y then Ordering.Equal else + if x > y then Ordering.Greater else + Panic.throw "default_compare: Should not reach here" From 99c41cb8e36efedc4f2e93639f51bdb1e561c9de Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 18:58:18 +0100 Subject: [PATCH 25/60] Improve signature of operators on Any --- distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index f735554b538b..d44aea12918b 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -112,7 +112,8 @@ type Any eq_that = Panic.catch No_Such_Conversion (Comparable.from that) _-> Default_Unordered_Comparator if eq_self.is_a Incomparable then False else # Comparable.equals_builtin is a hack how to directly access EqualsNode from the - # engine, so that we don't end up in an infinite recursion here. + # engine, so that we don't end up in an infinite recursion here (which would happen + # if we would compare with `eq_self == eq_that`). similar_type = Comparable.equals_builtin eq_self eq_that if similar_type.not then False else hash_self = eq_self.hash self @@ -168,7 +169,7 @@ type Any example_greater = a = 7 * 28 a > 147 - > : Any -> Boolean + > : Any -> Boolean ! Incomparable_Values > self that = assert_ordered_comparators self that <| (Comparable.from self).compare self that == Ordering.Greater @@ -196,7 +197,7 @@ type Any example_greater_eq = a = 6 * 21 a >= 147 - >= : Any -> Boolean + >= : Any -> Boolean ! Incomparable_Values >= self that = assert_ordered_comparators self that <| case (Comparable.from self).compare self that of @@ -226,7 +227,7 @@ type Any example_less = a = 7 * 21 a < 147 - < : Any -> Boolean + < : Any -> Boolean ! Incomparable_Values < self that = assert_ordered_comparators self that <| (Comparable.from self).compare self that == Ordering.Less @@ -254,7 +255,7 @@ type Any example_less_eq = a = 7 * 21 a < 147 - <= : Any -> Boolean + <= : Any -> Boolean ! Incomparable_Values <= self that = assert_ordered_comparators self that <| case (Comparable.from self).compare self that of From c6d56280cd9d85c2a318d21a291eaee01d37b826 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 18:59:04 +0100 Subject: [PATCH 26/60] Fix some warnings --- .../lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso | 7 ++----- .../lib/Standard/Base/0.0.0-dev/src/Data/Text.enso | 2 +- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index fac3f834349a..dc53b434b2df 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -89,7 +89,7 @@ type Comparable has_custom_comparator : Atom -> Boolean has_custom_comparator atom = comp = Comparable.from atom - (comp.is_a Default_Unordered_Comparator).not && (comp.is_a Default_Unordered_Comparator).not + (comp.is_a Default_Unordered_Comparator).not && (comp.is_a Default_Ordered_Comparator).not ## Singleton denoting that values of certain type are not comparable. type Incomparable @@ -123,10 +123,7 @@ type Default_Ordered_Comparator hash x = Comparable.hash_builtin x -# By default, there is no conversion from Any to Default_Ordered_Comparator -# Note that we allow also conversion from types, e.g., `Comparable.from Integer` -# for convenience. -Comparable.from (that:Any) = Default_Unordered_Comparator +Comparable.from (_:Any) = Default_Unordered_Comparator ## Types representing the ordering of values. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index fd60f56200c2..8b000305cb72 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -136,4 +136,4 @@ type Text to_text : Text to_text self = self -Comparable.from (that:Text) = Default_Ordered_Comparator +Comparable.from (_:Text) = Default_Ordered_Comparator From 848a782da032abaa12a87f738c770b8baacdc5a3 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 27 Jan 2023 18:59:23 +0100 Subject: [PATCH 27/60] [WIP] Migrate Table_Spec to the new comparator API --- .../Table_Tests/src/In_Memory/Table_Spec.enso | 20 +++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/test/Table_Tests/src/In_Memory/Table_Spec.enso b/test/Table_Tests/src/In_Memory/Table_Spec.enso index f27d61d7654b..e9a7a124a496 100644 --- a/test/Table_Tests/src/In_Memory/Table_Spec.enso +++ b/test/Table_Tests/src/In_Memory/Table_Spec.enso @@ -23,15 +23,23 @@ from project.Util import all type My Data x y - == self that = case that of - My.Data x1 y1 -> (self.x + self.y) == (x1 + y1) - _ -> False - - compare_to self that = self.x+self.y . compare_to that.x+that.y - frobnicate self = case self of My.Data x1 y1 -> My.Data y1 x1 +type My_Comparator + is_ordered = True + + compare left right = + left_sum = left.x + left.y + right_sum = right.x + right.y + (Comparable.from left_sum) . compare left_sum right_sum + + hash my = + sum = my.x + my.y + Comparable.from sum . hash sum + +Comparable.from (_:My) = My_Comparator + spec = make_varied_type_table = strs = ["strs", ["a", "b", "c", Nothing]] From 46a441905b199fcbe5a6c6ebeac41c8f6da16ffd Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 30 Jan 2023 15:58:59 +0100 Subject: [PATCH 28/60] Fix some specializations of Eq/Hash nodes. --- .../expression/builtin/meta/EqualsNode.java | 35 ++++++++++++++----- .../expression/builtin/meta/HashCodeNode.java | 9 +++-- 2 files changed, 34 insertions(+), 10 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index a71509ce3a92..c989244203fe 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -241,10 +241,8 @@ boolean equalsNull( } @Specialization(guards = { - // HostFunction is identified by a qualified name, it is not a lambda. - // It has well-defined equality based on the qualified name. - "isHostObject(selfHostObject) || isHostFunction(selfHostObject)", - "isHostObject(otherHostObject) || isHostFunction(otherHostObject)", + "isHostObject(selfHostObject)", + "isHostObject(otherHostObject)" }) boolean equalsHostObjects( Object selfHostObject, Object otherHostObject, @@ -260,6 +258,21 @@ boolean equalsHostObjects( } } + + // HostFunction is identified by a qualified name, it is not a lambda. + // It has well-defined equality based on the qualified name. + @Specialization(guards = { + "isHostFunction(selfHostFunc)", + "isHostFunction(otherHostFunc)" + }) + boolean equalsHostFunctions(Object selfHostFunc, Object otherHostFunc, + @CachedLibrary(limit = "5") InteropLibrary interop, + @Cached EqualsNode equalsNode) { + Object selfFuncStrRepr = interop.toDisplayString(selfHostFunc); + Object otherFuncStrRepr = interop.toDisplayString(otherHostFunc); + return equalsNode.execute(selfFuncStrRepr, otherFuncStrRepr); + } + @Specialization(guards = { "selfInterop.isBoolean(selfBoolean)", "otherInterop.isBoolean(otherBoolean)" @@ -500,13 +513,15 @@ boolean equalsHashMaps(Object selfHashMap, Object otherHashMap, } @Specialization(guards = { - "interop.hasMembers(selfObject)", - "interop.hasMembers(otherObject)", + "!isAtom(selfObject)", + "!isAtom(otherObject)", // Objects with types are handled in `equalsTypes` specialization, so we have to // negate the guards of that specialization here - to make the specializations // disjunctive. "!typesLib.hasType(selfObject)", - "!typesLib.hasType(otherObject)" + "!typesLib.hasType(otherObject)", + "interop.hasMembers(selfObject)", + "interop.hasMembers(otherObject)", }) boolean equalsInteropObjectWithMembers(Object selfObject, Object otherObject, @CachedLibrary(limit = "10") InteropLibrary interop, @@ -636,7 +651,7 @@ && atomOverridesEquals(selfFieldAtom)) { } /** - * Helper node for invoking `==` method on atoms, that override this method. + * Helper node for invoking `Any.==` method. */ @GenerateUncached static abstract class InvokeAnyEqualsNode extends Node { @@ -723,6 +738,10 @@ private boolean isNullOrNothing(Object object, TypesLibrary typesLib, InteropLib } } + static boolean isAtom(Object object) { + return object instanceof Atom; + } + @TruffleBoundary boolean isHostObject(Object object) { return EnsoContext.get(this).getEnvironment().isHostObject(object); diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index 1d1a5d8312d5..7a1ed7ad88f0 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -443,11 +443,12 @@ long hashCodeForMap( } @Specialization(guards = { - "interop.hasMembers(objectWithMembers)", + "!isAtom(objectWithMembers)", // Object with type is handled in `hashCodeForType` specialization, so we have to // negate the guard of that specialization here - to make the specializations // disjunctive. - "!typesLib.hasType(objectWithMembers)" + "!typesLib.hasType(objectWithMembers)", + "interop.hasMembers(objectWithMembers)" }) long hashCodeForInteropObjectWithMembers(Object objectWithMembers, @CachedLibrary(limit = "10") InteropLibrary interop, @@ -514,6 +515,10 @@ long hashCodeForHostFunction(Object hostFunction, return hashCodeNode.execute(interop.toDisplayString(hostFunction)); } + static boolean isAtom(Object object) { + return object instanceof Atom; + } + @TruffleBoundary boolean isHostObject(Object object) { return EnsoContext.get(this).getEnvironment().isHostObject(object); From 6cbdabce5c4d8203e424035f01dccf0a92930b8f Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 30 Jan 2023 16:00:53 +0100 Subject: [PATCH 29/60] Replace compare_to with Comparators (Batch 1) --- .../Base/0.0.0-dev/src/Data/Boolean.enso | 13 ---- .../Base/0.0.0-dev/src/Data/Numbers.enso | 26 -------- .../Base/0.0.0-dev/src/Data/Statistics.enso | 5 +- .../Base/0.0.0-dev/src/Data/Text.enso | 17 ----- .../Base/0.0.0-dev/src/Data/Time/Date.enso | 27 +------- .../0.0.0-dev/src/Data/Time/Date_Time.enso | 26 +------- .../0.0.0-dev/src/Data/Time/Duration.enso | 24 ++----- .../Base/0.0.0-dev/src/Data/Time/Period.enso | 9 +-- .../0.0.0-dev/src/Data/Time/Time_Of_Day.enso | 24 +------ .../builtin/bool/CompareToNode.java | 38 ----------- .../number/bigInteger/CompareToNode.java | 51 --------------- .../builtin/number/decimal/CompareToNode.java | 60 ------------------ .../number/smallInteger/CompareToNode.java | 63 ------------------- .../runtime/data/EnsoDuration.java | 8 --- .../Tests/src/Data/Time/Time_Of_Day_Spec.enso | 2 - 15 files changed, 19 insertions(+), 374 deletions(-) delete mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/bool/CompareToNode.java delete mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/bigInteger/CompareToNode.java delete mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/decimal/CompareToNode.java delete mode 100644 engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/smallInteger/CompareToNode.java diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso index 124b3d392d06..f254fac3c5fa 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso @@ -55,19 +55,6 @@ type Boolean not : Boolean not self = @Builtin_Method "Boolean.not" - ## Compares the two operands to determine the ordering of this with - respect to that. - - Arguments: - - that: The operand to order this with respect to. - - > Example - Computing the ordering of True and False - - True.compare_to False - compare_to : Boolean -> Ordering - compare_to self that = @Builtin_Method "Boolean.compare_to" - ## The if-then-else control flow operator that executes one of two branches based on a conditional. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso index 7e09b68cd530..ccf7887e3a3a 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Numbers.enso @@ -531,19 +531,6 @@ type Decimal ceil : Integer ceil self = @Builtin_Method "Decimal.ceil" - ## Compares the two operands to determine the ordering of this with - respect to that. - - Arguments: - - that: The operand to order this with respect to. - - > Example - Computing the ordering of 1.732 and 4 (Less). - - 1.732.compare_to 4 - compare_to : Number -> Ordering - compare_to self that = @Builtin_Method "Decimal.compare_to" - ## Computes the nearest integer below this decimal. This method provides a means of converting a Decimal to an Integer. @@ -770,19 +757,6 @@ type Integer ceil : Integer ceil self = @Builtin_Method "Integer.ceil" - ## Compares the two operands to determine the ordering of this with - respect to that. - - Arguments: - - that: The operand to order this with respect to. - - > Example - Computing the ordering of 1 and 4 (Less). - - 1.compare_to 4 - compare_to : Number -> Ordering - compare_to self that = @Builtin_Method "Integer.compare_to" - ## Computes the integer division of this by that. Arguments: diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso index f13041f8df92..930d53b2cfd7 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso @@ -341,12 +341,13 @@ compute_fold counter current value = counter.increment if counter.comparatorError.not then + value_comparator = Comparable.from value if counter.minimum.is_nothing then counter.setMinimum value else - ordering = Incomparable_Values.handle_errors <| value.compare_to counter.minimum + ordering = Incomparable_Values.handle_errors <| value_comparator.compare value counter.minimum if ordering.is_error then counter.failComparator else if ordering == Ordering.Less then counter.setMinimum value if counter.maximum.is_nothing then counter.setMaximum value else - ordering = Incomparable_Values.handle_errors <| value.compare_to counter.maximum + ordering = Incomparable_Values.handle_errors <| value_comparator.compare value counter.maximum if ordering.is_error then counter.failComparator else if ordering == Ordering.Greater then counter.setMaximum value diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso index 8b000305cb72..3ad23693f36c 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text.enso @@ -34,23 +34,6 @@ type Text + : Text -> Text + self that = @Builtin_Method "Text.+" - ## Compare two texts to discover their ordering. - - Arguments: - - that: The text to order `self` with respect to. - - > Example - Checking how "a" orders in relation to "b". - - "a".compare_to "b" - compare_to : Text -> Ordering - compare_to self that = case that of - _ : Text -> - is_normalized = self.is_normalized && that.is_normalized - comparison_result = Text_Utils.compare self that is_normalized - Ordering.from_sign comparison_result - _ -> Error.throw (Type_Error.Error Text that "that") - ## Checks whether `self` is equal to `that`, ignoring the case of the texts. Arguments: diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso index a62c3cfa4b52..172f96f628f8 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date.enso @@ -3,6 +3,8 @@ import project.Data.Json.JS_Object import project.Data.Locale.Locale import project.Data.Numbers.Integer import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Text.Text import project.Data.Time.Date_Period.Date_Period import project.Data.Time.Date_Time.Date_Time @@ -589,26 +591,6 @@ type Date format : Text -> Text format self pattern = Time_Utils.local_date_format self pattern - # TODO: Remove and replace only with comparator - ## Compares `self` to `that` to produce an ordering. - - Arguments: - - that: The other `Date` to compare against. - - > Example - Compare two dates for their ordering. - - (Date.new 2000).compare_to (Date.new 2001) - compare_to : Date -> Ordering - compare_to self that = case that of - _ : Date -> - sign = Time_Utils.compare_to_localdate self that - Ordering.from_sign sign - _ -> Error.throw (Type_Error.Error Date that "that") - - comparator : Date_Comparator - comparator = Date_Comparator - ## PRIVATE week_days_between start end = @@ -647,7 +629,4 @@ fits_in_range start end date = (start <= date) && (date < end) -## PRIVATE -type Date_Comparator - compare self d1 d2 = d1.compare_to d2 - hash self _ = Error.throw "no hash for Date" +Comparable.from (_:Date) = Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso index f3d9884675d9..49088b2a8ebc 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Date_Time.enso @@ -3,6 +3,8 @@ import project.Data.Json.JS_Object import project.Data.Locale.Locale import project.Data.Numbers.Integer import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Text.Text import project.Data.Time.Date.Date import project.Data.Time.Date_Period.Date_Period @@ -686,27 +688,5 @@ type Date_Time format : Text -> Text format self pattern = @Builtin_Method "Date_Time.format" - ## Compares `self` to `that` to produce an ordering. - Arguments: - - that: The other `Date_Time` to compare against. - - > Example - Compare two times for their ordering. - - (Date_Time.new 2000).compare_to (Date_Time.new 2001) - compare_to : Date_Time -> Ordering - compare_to self that = case that of - _ : Date_Time -> - sign = Time_Utils.compare_to_zoneddatetime self that - Ordering.from_sign sign - _ -> Error.throw (Type_Error.Error Date_Time that "that") - - comparator : Date_Time_Comparator - comparator = Date_Time_Comparator - - -## PRIVATE -type Date_Time_Comparator - compare self d1 d2 = d1.compare_to d2 - hash self _ = Error.throw "no hash for Date_Time" +Comparable.from (_:Date_Time) = Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso index 1c7415dfa48d..8fad8637baba 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso @@ -2,7 +2,8 @@ import project.Any.Any import project.Data.Json.JS_Object import project.Data.Numbers.Decimal import project.Data.Numbers.Integer -import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Pair.Pair import project.Data.Time.Date_Time.Date_Time import project.Data.Time.Period.Period @@ -167,25 +168,6 @@ type Duration Panic.catch ArithmeticException (self.minus_builtin that) err-> Error.throw (Time_Error.Error err.payload.getMessage) - ## Compares `self` to `that` to produce an ordering. - - Arguments: - - that: The other `Duration` to compare against. - - > Example - Compare two durations for their ordering. - - import Standard.Base.Data.Time.Duration - - example_compare_to = - duration_1 = (Duration.new hour=1) - duration_2 = (Duration.new minutes=60) + (Duration.new minutes=5) - duration_1.compare_to duration_2 - compare_to : Duration -> Ordering - compare_to self that = case that of - _ : Duration -> Ordering.from_sign (self.compare_to_builtin that) - _ -> Error.throw (Type_Error.Error Duration that "that") - ## Get the portion of the duration expressed in nanoseconds. > Example @@ -312,3 +294,5 @@ type Duration example_is_empty = Duration.zero.is_empty is_empty : Boolean is_empty self = self.to_vector . all (==0) + +Comparable.from(_:Duration) = Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso index 35e8dbfd211b..a1263831abad 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso @@ -2,6 +2,8 @@ import project.Any.Any import project.Data.Numbers.Integer import project.Data.Time.Date.Date import project.Data.Time.Duration.Duration +import project.Data.Ordering.Comparable +import project.Data.Ordering.Incomparable import project.Data.Text.Text import project.Error.Error import project.Error.Illegal_Argument.Illegal_Argument @@ -129,10 +131,5 @@ type Period DateTimeException -> Error.throw Time_Error.Error "Period subtraction failed" ArithmeticException -> Error.throw Illegal_Argument.Error "Arithmetic error" - ## Just throws `Incomparable_Values`, because periods cannot be - compared without additional context. - To compare two Periods, use something like: - `(start_date + period1) .compare_to (start_date + period2)` - compare_to : Period -> Nothing ! Incomparable_Values - compare_to self _ = Error.throw Incomparable_Values +Comparable.from (_:Period) = Incomparable diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso index c137d93dc3f1..4b7c77f8384f 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso @@ -2,7 +2,8 @@ import project.Any.Any import project.Data.Json.JS_Object import project.Data.Locale.Locale import project.Data.Numbers.Integer -import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Text.Text import project.Data.Time.Date.Date import project.Data.Time.Date_Time.Date_Time @@ -357,23 +358,4 @@ type Time_Of_Day format : Text -> Text format self pattern = @Builtin_Method "Time_Of_Day.format" - ## Compares `self` to `that` to produce an ordering. - - Arguments: - - that: The other `Time_Of_Day` to compare against. - - > Example - Compare two times for their ordering. - - from Standard.Base import Time_Of_Day - - example_compare_to = - time_1 = Time_Of_Day.new hour=2 minute=30 - time_2 = Time_Of_Day.new minute=50 - time_1.compare_to time_2 - compare_to : Time_Of_Day -> Ordering - compare_to self that = case that of - _ : Time_Of_Day -> - sign = Time_Utils.compare_to_localtime self that - Ordering.from_sign sign - _ -> Error.throw (Type_Error.Error Time_Of_Day that "that") +Comparable.from(_:Time_Of_Day) = Default_Ordered_Comparator diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/bool/CompareToNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/bool/CompareToNode.java deleted file mode 100644 index ceeae5ddb658..000000000000 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/bool/CompareToNode.java +++ /dev/null @@ -1,38 +0,0 @@ -package org.enso.interpreter.node.expression.builtin.bool; - -import com.oracle.truffle.api.dsl.Fallback; -import com.oracle.truffle.api.dsl.Specialization; -import com.oracle.truffle.api.nodes.Node; -import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.ordering.Ordering; -import org.enso.interpreter.runtime.EnsoContext; -import org.enso.interpreter.runtime.callable.atom.Atom; -import org.enso.interpreter.runtime.error.DataflowError; - -@BuiltinMethod(type = "Boolean", name = "compare_to", description = "Comparison for Booleans.") -public abstract class CompareToNode extends Node { - static CompareToNode build() { - return CompareToNodeGen.create(); - } - - abstract Object execute(Boolean self, Object that); - - @Specialization - Atom doBoolean(Boolean self, Boolean that) { - Ordering ordering = EnsoContext.get(this).getBuiltins().ordering(); - if (self == that) { - return ordering.newEqual(); - } else if (self) { - return ordering.newGreater(); - } else { - return ordering.newLess(); - } - } - - @Fallback - DataflowError doOther(Boolean self, Object that) { - var builtins = EnsoContext.get(this).getBuiltins(); - var typeError = builtins.error().makeTypeError(builtins.bool().getType(), that, "that"); - return DataflowError.withoutTrace(typeError, this); - } -} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/bigInteger/CompareToNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/bigInteger/CompareToNode.java deleted file mode 100644 index e27aea359a34..000000000000 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/bigInteger/CompareToNode.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.enso.interpreter.node.expression.builtin.number.bigInteger; - -import com.oracle.truffle.api.dsl.Fallback; -import com.oracle.truffle.api.dsl.Specialization; -import com.oracle.truffle.api.nodes.Node; -import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; -import org.enso.interpreter.node.expression.builtin.ordering.Ordering; -import org.enso.interpreter.runtime.EnsoContext; -import org.enso.interpreter.runtime.callable.atom.Atom; -import org.enso.interpreter.runtime.error.DataflowError; -import org.enso.interpreter.runtime.number.EnsoBigInteger; - -@BuiltinMethod( - type = "Big_Integer", - name = "compare_to", - description = "Comparison for big integers.") -public abstract class CompareToNode extends Node { - - static CompareToNode build() { - return CompareToNodeGen.create(); - } - - abstract Object execute(EnsoBigInteger self, Object that); - - @Specialization - Atom doLong(EnsoBigInteger self, long that) { - return getOrdering().fromJava(BigIntegerOps.compareTo(self.getValue(), that)); - } - - @Specialization - Atom doBigInt(EnsoBigInteger self, EnsoBigInteger that) { - return getOrdering().fromJava(BigIntegerOps.compareTo(self.getValue(), that.getValue())); - } - - @Specialization - Atom doDecimal(EnsoBigInteger self, double that) { - return getOrdering().fromJava(BigIntegerOps.compareTo(self.getValue(), that)); - } - - @Fallback - DataflowError doOther(EnsoBigInteger self, Object that) { - var builtins = EnsoContext.get(this).getBuiltins(); - var typeError = builtins.error().makeTypeError(builtins.number().getNumber(), that, "that"); - return DataflowError.withoutTrace(typeError, this); - } - - Ordering getOrdering() { - return EnsoContext.get(this).getBuiltins().ordering(); - } -} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/decimal/CompareToNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/decimal/CompareToNode.java deleted file mode 100644 index 780103576547..000000000000 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/decimal/CompareToNode.java +++ /dev/null @@ -1,60 +0,0 @@ -package org.enso.interpreter.node.expression.builtin.number.decimal; - -import com.oracle.truffle.api.dsl.Fallback; -import com.oracle.truffle.api.dsl.Specialization; -import com.oracle.truffle.api.nodes.Node; -import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; -import org.enso.interpreter.node.expression.builtin.ordering.Ordering; -import org.enso.interpreter.runtime.EnsoContext; -import org.enso.interpreter.runtime.callable.atom.Atom; -import org.enso.interpreter.runtime.error.DataflowError; -import org.enso.interpreter.runtime.number.EnsoBigInteger; - -@BuiltinMethod(type = "Decimal", name = "compare_to", description = "Comparison for decimals.") -public abstract class CompareToNode extends Node { - - static CompareToNode build() { - return CompareToNodeGen.create(); - } - - abstract Object execute(double self, Object that); - - @Specialization - Atom doLong(double self, long that) { - if (self == that) { - return getOrdering().newEqual(); - } else if (self > that) { - return getOrdering().newGreater(); - } else { - return getOrdering().newLess(); - } - } - - @Specialization - Atom doBigInt(double self, EnsoBigInteger that) { - return getOrdering().fromJava(BigIntegerOps.compareTo(self, that.getValue())); - } - - @Specialization - Atom doDecimal(double self, double that) { - if (self == that) { - return getOrdering().newEqual(); - } else if (self > that) { - return getOrdering().newGreater(); - } else { - return getOrdering().newLess(); - } - } - - @Fallback - DataflowError doOther(double self, Object that) { - var builtins = EnsoContext.get(this).getBuiltins(); - var typeError = builtins.error().makeTypeError(builtins.number().getNumber(), that, "that"); - return DataflowError.withoutTrace(typeError, this); - } - - Ordering getOrdering() { - return EnsoContext.get(this).getBuiltins().ordering(); - } -} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/smallInteger/CompareToNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/smallInteger/CompareToNode.java deleted file mode 100644 index f43061a2d57d..000000000000 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/number/smallInteger/CompareToNode.java +++ /dev/null @@ -1,63 +0,0 @@ -package org.enso.interpreter.node.expression.builtin.number.smallInteger; - -import com.oracle.truffle.api.dsl.Fallback; -import com.oracle.truffle.api.dsl.Specialization; -import com.oracle.truffle.api.nodes.Node; -import org.enso.interpreter.dsl.BuiltinMethod; -import org.enso.interpreter.node.expression.builtin.number.utils.BigIntegerOps; -import org.enso.interpreter.node.expression.builtin.ordering.Ordering; -import org.enso.interpreter.runtime.EnsoContext; -import org.enso.interpreter.runtime.callable.atom.Atom; -import org.enso.interpreter.runtime.error.DataflowError; -import org.enso.interpreter.runtime.number.EnsoBigInteger; - -@BuiltinMethod( - type = "Small_Integer", - name = "compare_to", - description = "Comparison for small integers.") -public abstract class CompareToNode extends Node { - - static CompareToNode build() { - return CompareToNodeGen.create(); - } - - abstract Object execute(long self, Object that); - - @Specialization - Atom doLong(long self, long that) { - if (self == that) { - return getOrdering().newEqual(); - } else if (self > that) { - return getOrdering().newGreater(); - } else { - return getOrdering().newLess(); - } - } - - @Specialization - Atom doBigInt(long self, EnsoBigInteger that) { - return getOrdering().fromJava(BigIntegerOps.compareTo(self, that.getValue())); - } - - @Specialization - Atom doDecimal(long self, double that) { - if (self == that) { - return getOrdering().newEqual(); - } else if (self > that) { - return getOrdering().newGreater(); - } else { - return getOrdering().newLess(); - } - } - - @Fallback - DataflowError doOther(long self, Object that) { - var builtins = EnsoContext.get(this).getBuiltins(); - var typeError = builtins.error().makeTypeError(builtins.number().getNumber(), that, "that"); - return DataflowError.withoutTrace(typeError, this); - } - - Ordering getOrdering() { - return EnsoContext.get(this).getBuiltins().ordering(); - } -} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/EnsoDuration.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/EnsoDuration.java index d09e20d4886c..3d530f4e22ea 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/EnsoDuration.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/data/EnsoDuration.java @@ -172,14 +172,6 @@ public EnsoDuration minus(Object durationObject, InteropLibrary interop) return new EnsoDuration(duration.minus(interop.asDuration(durationObject))); } - @Builtin.Method(name = "compare_to_builtin", description = "Compares to other duration") - @Builtin.Specialize - @Builtin.WrapException(from = UnsupportedMessageException.class) - public long compareTo(Object durationObject, InteropLibrary interop) - throws UnsupportedMessageException { - return duration.compareTo(interop.asDuration(durationObject)); - } - @ExportMessage public boolean isDuration() { return true; diff --git a/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso b/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso index 9b1d75fb1604..68709b14187c 100644 --- a/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso +++ b/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso @@ -117,8 +117,6 @@ specWith name create_new_time parse_time = time_1>time_2 . should_be_true time_1 Date: Mon, 30 Jan 2023 16:01:23 +0100 Subject: [PATCH 30/60] Improve some docs --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 16 +--- .../Base/0.0.0-dev/src/Data/Ordering.enso | 87 ++++++++++++++----- 2 files changed, 68 insertions(+), 35 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index d44aea12918b..8eb391aabc23 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -154,12 +154,8 @@ type Any Arguments: - that: The value to compare `self` against. - To have `>` defined, a type must define `compare_to`, returning an Ordering. - - ! Implementing Greater Than - Many types can admit a definition of greater than that is more efficient - than the generic one given here. When implementing this for your own types - please ensure that it is semantically equivalent to using `.compare_to`. + To have `>` properly defined, a type must have an associated ordered comparator. + See `Ordering.enso` for information how comparators work. > Example Checking if the variable `a` is greater than `147`. @@ -212,12 +208,8 @@ type Any Arguments: - that: The value to compare `self` against. - To have `<` defined, a type must define `compare_to`, returning an Ordering. - - ! Implementing Less Than - Many types can admit a definition of less than that is more efficient than - the generic one given here. When implementing this for your own types - please ensure that it is semantically equivalent to using `.compare_to`. + To have `<` properly defined, a type must have an associated ordered comparator. + See `Ordering.enso` for information how comparators work. > Example Checking if the variable `a` is less than `147`. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index dc53b434b2df..9bdcde99da96 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -23,21 +23,72 @@ import project.Meta.Atom another `type` that satisfies either of the following two definitions: ``` - type Default_Ordered_Comparator T + type Ordered_Comparator T is_ordered = True compare : T -> T -> Ordering hash : T -> Integer - type Default_Unordered_Comparator T + type Unordered_Comparator T is_ordered = False equals : T -> T -> Boolean hash : T -> Integer ``` - There is an implicit conversion from any type to `Comparable` with `Comparable.from`. - But due to technical limitations, we cannot specify its signature in code. - The return type of `Comparable.from (_ : MyType)` is - `(Default_Ordered_Comparator|Default_Unordered_Comparator|Incomparable)`. + Or `Incomparable` in case that the type `T` should not be compared at all. + + Note that there has to be `is_ordered` method defined which returns a Boolean + indicating that the comparator is ordered. This is currently needed as there is + no way how to define interfaces in Enso. + + An _unordered comparator_ has to implement both `equals` and `hash` to define + a _total_ custom equality. By _total_, we mean that every instance of the type + has to be either equal or not equal, which is represented by the type signature + of `equals` - just `Boolean` is returned without any errors thrown. + + An _ordered comparator_ has `compare` method instead of `equals` method, that is + expected to return `Ordering` signaling that an instance of the type is either + less than, equal to, or greater than the other instance. This relation is also + _total_, meaning that all the instances of the type are comparable. + + The runtime expects the following semantics for all the comparators: + - Hash consistency: + - If x == y then hash(x) == hash(y) + - If hash(x) != hash(y) then x != y + - Consistency: if x == y then x == y for all the subsequent invocations. + - Symmetry: if x == y then y == x + - Reflexivity: x == x + - Transitivity: if x < y and y < z then x < z + - Antisymmetry (?): if x > y then y < x + + Users are responsible for the compliance to the aforementioned semantics. + Should the semantics be violated, an unexpected behavior may be encountered, e.g., + `Array.sort` may return unexpected results or fail with `Incomparable_Values`. + + + > Example + Comparator for an unordered Pair `UPair`. In this example, we can see an + implementation of the `hash` method that delegates to hash methods of + fields. + + ``` + type UPair + Value x y + + type UPair_Comparator + is_ordered = False + + equals pair1 pair2 = + if pair1.x == pair2.x && pair1.y == pair2.y then True else + if pair1.x == pair2.y && pair1.y == pair2.x then True else + False + + hash upair = + x_comp = Comparable.from upair.x + y_comp = Comparable.from upair.y + (x_comp.hash upair.x) + (y_comp.hash upair.y) + + Comparable.from (_ : UPair) = UPair_Comparator + ``` > Example Representation of _rational numbers_ as a pair of integers needs a @@ -48,13 +99,7 @@ import project.Meta.Atom Fraction (numerator:Integer) (denominator:Integer) Comparable.from (_:Rational) = Rational_Ordering - ``` - - The `comparator` definition overrides the extension function on - `Any` defined by `Ordering` module and returns reference to the following - type: - ``` type Rational_Ordering is_ordered = True compare self r1 r2 = @@ -127,12 +172,6 @@ Comparable.from (_:Any) = Default_Unordered_Comparator ## Types representing the ordering of values. - - These are intended to be returned from the `compare_to` function, that has a - type as follows for a type `A`: `A.compare_to : A -> Ordering`. - - The result should be returned in terms of how `self` orders in comparison to - `that`. So, if `self` is greater than `that`, you should return `Greater.` @Builtin_Type type Ordering ## A representation that the first value orders as less than the second. @@ -166,11 +205,6 @@ type Ordering Ordering.Equal -> other Ordering.Greater -> Ordering.Greater - compare_to : Ordering -> Ordering - compare_to self that = case that of - _ : Ordering -> self.to_sign.compare_to that.to_sign - _ -> Error.throw (Type_Error.Error Ordering that "that") - ## Converts a sign-based representation of ordering to Enso's native ordering. Arguments: @@ -183,3 +217,10 @@ type Ordering from_sign : Integer -> Ordering from_sign sign = if sign == 0 then Ordering.Equal else if sign > 0 then Ordering.Greater else Ordering.Less + +type Ordering_Comparator + is_ordered = True + compare x y = (Comparable.from x.to_sign).compare x.to_sign y.to_sign + hash x = x.to_sign + +Comparable.from (_:Ordering) = Ordering_Comparator From 548920b20a5f44d3951171c999a0f0e2c3f9adc0 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 31 Jan 2023 20:17:28 +0100 Subject: [PATCH 31/60] Replace compare_to with Comparators (Batch 2) --- .../Base/0.0.0-dev/src/Data/Array.enso | 13 +-- .../Base/0.0.0-dev/src/Data/Ordering.enso | 19 ++++- .../src/Data/Ordering/Natural_Order.enso | 8 +- .../Ordering/Vector_Lexicographic_Order.enso | 6 +- .../Base/0.0.0-dev/src/Data/Vector.enso | 5 +- .../Database/0.0.0-dev/src/Data/Table.enso | 2 +- .../Table/0.0.0-dev/src/Data/Column.enso | 8 +- .../Table/0.0.0-dev/src/Data/Table.enso | 3 +- .../Table/0.0.0-dev/src/Data/Value_Type.enso | 8 +- .../0.0.0-dev/src/Internal/Table_Helpers.enso | 2 +- test/Benchmarks/src/Table/Sorting.enso | 14 +++- test/Benchmarks/src/Text/Compare.enso | 2 +- test/Benchmarks/src/Vector/Sort.enso | 4 +- .../Join/Join_Spec.enso | 16 ++-- .../Table_Tests/src/In_Memory/Table_Spec.enso | 2 +- test/Tests/src/Data/Bool_Spec.enso | 8 +- test/Tests/src/Data/Map_Spec.enso | 2 +- test/Tests/src/Data/Numbers_Spec.enso | 46 +++++----- .../src/Data/Ordering/Comparator_Spec.enso | 10 ++- .../src/Data/Ordering/Natural_Order_Spec.enso | 2 +- .../Vector_Lexicographic_Order_Spec.enso | 4 +- test/Tests/src/Data/Ordering_Spec.enso | 83 ++++++++++++------- test/Tests/src/Data/Statistics_Spec.enso | 16 ++-- test/Tests/src/Data/Text_Spec.enso | 30 +++---- test/Tests/src/Data/Time/Date_Time_Spec.enso | 4 +- test/Tests/src/Data/Time/Duration_Spec.enso | 2 +- test/Tests/src/Data/Vector_Spec.enso | 22 ++--- 27 files changed, 200 insertions(+), 141 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso index 85f4a37bd69b..d8e52a3c4cbe 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso @@ -146,7 +146,7 @@ type Array [3,2,1].to_array.sort sort : (Any -> Any -> Ordering) -> Array - sort self compare_func=(default_compare _ _) = + sort self compare_func=(Ordering.compare _ _) = self.sort_builtin compare_func ## Identity. @@ -155,14 +155,3 @@ type Array primitive array protocol. to_array : Array to_array self = @Builtin_Method "Array.to_array" - - -## PRIVATE -## UNSTABLE - We call operators from `Any.<` which checks for ordered comparators. - TODO[PM]: This about adding comparator parameter to `Array.sort`. -default_compare x y = - if x < y then Ordering.Less else - if x == y then Ordering.Equal else - if x > y then Ordering.Greater else - Panic.throw "default_compare: Should not reach here" diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 9bdcde99da96..06423880ad28 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -3,6 +3,7 @@ import project.Data.Numbers.Decimal import project.Data.Numbers.Number import project.Error.Common.Type_Error import project.Error.Error +import project.Error.Incomparable_Values.Incomparable_Values import project.Error.Unimplemented.Unimplemented import project.Nothing import project.Any.Any @@ -131,6 +132,8 @@ type Comparable hash_callback atom = (Comparable.from atom).hash atom ## PRIVATE + A custom comparator is any comparator that is different than the two + default ones. has_custom_comparator : Atom -> Boolean has_custom_comparator atom = comp = Comparable.from atom @@ -140,7 +143,7 @@ type Comparable type Incomparable Singleton -## Default implementation of unordered comparator. Uses the builtin equals and hash_code. +## Default implementation of unordered comparator. @Builtin_Type type Default_Unordered_Comparator is_ordered = False @@ -152,12 +155,14 @@ type Default_Unordered_Comparator hash object = Comparable.hash_builtin object -## Default implementation of an ordered _comparator_ that forwards to `>`, `<` etc. - operators. +## Default implementation of an ordered _comparator_. Handles only primitive types, + does not handle atoms, or vectors. Any type that requires an ordering, must + define its own ordered comparator. @Builtin_Type type Default_Ordered_Comparator is_ordered = True + ## Handles only primitive types, not atoms or vectors. compare : Any -> Any -> Ordering compare x y = if Comparable.less_than_builtin x y then Ordering.Less else @@ -183,6 +188,14 @@ type Ordering ## A representation that the first value orders as greater than the second. Greater + ## Compares to values and returns an Ordering + compare : Any -> Any -> Ordering ! (Incomparable_Values | Type_Error) + compare x y = + if x < y then Ordering.Less else + if x == y then Ordering.Equal else + if x > y then Ordering.Greater else + Error.throw Incomparable_Values + ## Converts the ordering to the signed notion of ordering based on integers. > Example diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Natural_Order.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Natural_Order.enso index 341e10df0840..cb116aefcea4 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Natural_Order.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Natural_Order.enso @@ -23,8 +23,8 @@ polyglot java import com.ibm.icu.text.BreakIterator compare : Text -> Text -> Case_Sensitivity -> Ordering compare text1 text2 case_sensitivity=Case_Sensitivity.Sensitive = compare_text = case case_sensitivity of - Case_Sensitivity.Default -> _.compare_to _ - Case_Sensitivity.Sensitive -> _.compare_to _ + Case_Sensitivity.Default -> Ordering.compare _ _ + Case_Sensitivity.Sensitive -> Ordering.compare _ _ Case_Sensitivity.Insensitive locale -> a -> b -> a.compare_to_ignore_case b locale iter1 = BreakIterator.getCharacterInstance @@ -60,7 +60,7 @@ compare text1 text2 case_sensitivity=Case_Sensitivity.Sensitive = [substring, decimal, pair.first, next_index] - ## Loop to computer the ordering of text1 and text2. + ## Loop to compute the ordering of text1 and text2. Ordering: Nothing < Number < Text prev1 - index to start of current character in text1. next1 - index to start of next character (or -1 if finished) in text1. @@ -98,7 +98,7 @@ compare text1 text2 case_sensitivity=Case_Sensitivity.Sensitive = num_text2 = parsed2.at 0 value2 = parsed2.at 1 - value_comparison = value1.compare_to value2 + value_comparison = Ordering.compare value1 value2 if value_comparison != Ordering.Equal then value_comparison else text_comparison = compare_text num_text1 num_text2 if text_comparison != Ordering.Equal then text_comparison else diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Vector_Lexicographic_Order.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Vector_Lexicographic_Order.enso index 4b7c8ea72154..e6f0ab63b294 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Vector_Lexicographic_Order.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Vector_Lexicographic_Order.enso @@ -9,7 +9,7 @@ from project.Data.Boolean import True, False Arguments: - vector1: The first vector to compare. - vector2: The second vector to compare. - - element_comparator (optional): A custom comparator defining the order + - element_comparator (optional): A custom compare function defining the order between particular elements. Uses the default ordering by default. Returns whether `vector1` is less, equal or greater than `vector2` according @@ -30,7 +30,7 @@ from project.Data.Boolean import True, False Vector_Lexicographic_Order.compare [] [1] == Ordering.Less Vector_Lexicographic_Order.compare [1] [1] == Ordering.Equal compare : Vector -> Vector -> (Any -> Any -> Ordering) -> Ordering -compare vector1 vector2 (element_comparator = _.compare_to _) = +compare vector1 vector2 (element_comparator = Ordering.compare _ _) = is_index_contained_in_both ix = ix @@ -48,5 +48,5 @@ compare vector1 vector2 (element_comparator = _.compare_to _) = ## At least one of the vectors ran out of elements. In that case, the longer Vector is the greater one and if both have the same length that means they must have been equal. - vector1.length . compare_to vector2.length + Ordering.compare vector1.length vector2.length go 0 diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Vector.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Vector.enso index 0cfebc8da1ef..b449a0f0ed74 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Vector.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Vector.enso @@ -845,7 +845,8 @@ type Vector a elements, returning an Ordering to compare them. By default, elements are sorted in ascending order, using the comparator - `compare_to`. A custom comparator may be passed to the sort function. + acquired from each element. A custom compare function may be passed to + the sort method. This is a stable sort, meaning that items that compare the same will not have their order changed by the sorting process. @@ -877,7 +878,7 @@ type Vector a [Pair 1 2, Pair -1 8].sort Sort_Direction.Descending (_.first) sort : Sort_Direction -> (Any -> Any) -> (Any -> Any -> Ordering) -> Vector Any ! Incomparable_Values - sort self (order = Sort_Direction.Ascending) (on = x -> x) (by = (_.compare_to _)) = + sort self (order = Sort_Direction.Ascending) (on = x -> x) (by = (Ordering.compare _ _)) = comp_ascending l r = by (on l) (on r) comp_descending l r = by (on r) (on l) compare = if order == Sort_Direction.Ascending then comp_ascending else diff --git a/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso b/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso index 1151e3039012..5f915f73b4bc 100644 --- a/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso +++ b/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso @@ -290,7 +290,7 @@ type Table ## Returns a new table with the columns sorted by name according to the specified sort method. By default, sorting will be according to - case-sensitive ascending order based on the `Text.compare_to` operator. + case-sensitive ascending order based on the `Default_Ordered_Comparator`. Arguments: - order: Whether sorting should be in ascending or descending order. diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso index db682ee3969a..c3adced57d36 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso @@ -1095,7 +1095,7 @@ type Column this rule, ignoring the ascending / descending setting. - by: function taking two items in this column and returning an ordering. If specified, it is used instead of the natural - (`.compare_to`) ordering. + ordering as defined by `Default_Ordered_Comparator`. > Example Sorting a column in ascending order. @@ -1114,14 +1114,14 @@ type Column Examples.integer_column.sort Sort_Direction.Descending missing_last=False > Example - Sorting `column` in ascending order, using a custom comparator + Sorting `column` in ascending order, using a custom compare function. import Standard.Examples example_sort = - my_comparator a b = a.abs.compare_to b.abs - Examples.decimal_column.sort by=my_comparator + my_compare a b = Ordering.compare a.abs b.abs + Examples.decimal_column.sort by=my_compare sort : Sort_Direction -> Boolean -> (Any -> Any -> Ordering) | Nothing -> Column sort self order=Sort_Direction.Ascending missing_last=True by=Nothing = order_bool = case order of diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso index 40a736964737..af12939440d5 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso @@ -404,8 +404,7 @@ type Table ## Returns a new table with the columns sorted by name according to the specified sort method. By default, sorting will be according to - case-sensitive ascending order based on the `compare_to` operator for - `Text`. + case-sensitive ascending order based on the `Default_Ordered_Comparator`. Arguments: - order: Whether sorting should be in ascending or descending order. diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Value_Type.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Value_Type.enso index d9b52667598f..0d89f5efdcaa 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Value_Type.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Value_Type.enso @@ -22,8 +22,12 @@ type Bits Bits.Bits_32 -> 32 Bits.Bits_64 -> 64 - ## PRIVATE - compare_to self other = self.to_bits . compare_to other.to_bits +type Bits_Comparator + is_ordered = True + compare x y = Comparable.from x.to_bits . compare x.to_bits y.to_bits + hash x = Comparable.from x.to_bits . hash x.to_bits + +Comparable.from (_:Bits) = Bits_Comparator ## Represents the different possible types of values within RDBMS columns. type Value_Type diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Table_Helpers.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Table_Helpers.enso index 9dbde73e9db0..448f0abe564f 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Table_Helpers.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Table_Helpers.enso @@ -325,7 +325,7 @@ sort_columns internal_columns order text_ordering = col -> col.name.to_case_insensitive_key locale=locale comparator = case text_ordering.sort_digits_as_numbers of True -> Natural_Order.compare - False -> .compare_to + False -> Ordering.compare internal_columns.sort order=order on=mapper by=comparator ## PRIVATE diff --git a/test/Benchmarks/src/Table/Sorting.enso b/test/Benchmarks/src/Table/Sorting.enso index c85521292337..63b46c29a5fd 100644 --- a/test/Benchmarks/src/Table/Sorting.enso +++ b/test/Benchmarks/src/Table/Sorting.enso @@ -8,8 +8,18 @@ from Standard.Test import Bench type My Data x - compare_to self other = - other.x . compare_to self.x +type My_Comparator + is_ordered = True + + compare my_1 my_2 = + comparator = Comparable.from my_2.x + comparator.compare my_2.x my_1.x + + hash my = + comparator = Comparable.from my.x + comparator.hash my.x + +Comparable.from (_:My) = My_Comparator vector_size = 100000 iter_size = 20 diff --git a/test/Benchmarks/src/Text/Compare.enso b/test/Benchmarks/src/Text/Compare.enso index 110daac80497..d5be1f0ffc26 100644 --- a/test/Benchmarks/src/Text/Compare.enso +++ b/test/Benchmarks/src/Text/Compare.enso @@ -9,7 +9,7 @@ compare_all_adjacent text_vector = res bench = - ## The `Text.compare_to` benchmarks check both scenarios where the Texts are + ## The `Text` compare benchmarks check both scenarios where the Texts are short and very long - both checking the case where the difference appears early or late in the long string. This is to see well any overheads related to preprocessing the whole string and any possible early diff --git a/test/Benchmarks/src/Vector/Sort.enso b/test/Benchmarks/src/Vector/Sort.enso index f7ff2a3067cc..27a3ca85a4fa 100644 --- a/test/Benchmarks/src/Vector/Sort.enso +++ b/test/Benchmarks/src/Vector/Sort.enso @@ -57,7 +57,7 @@ bench = partially_sorted_vec = make_partially_sorted_vec vector_size random_vec = Utils.make_random_vec vector_size projection = x -> x % 10 - comparator = l -> r -> r.compare_to l + comparator = l -> r -> Ordering.compare l r Bench.measure (sorted_vec.sort) "Already Sorted" iter_size num_iterations Bench.measure (sorted_vec.sort Sort_Direction.Descending) "Sorted in Opposite Order" iter_size num_iterations @@ -66,6 +66,6 @@ bench = Bench.measure (random_vec.sort) "Random Elements Ascending" iter_size num_iterations Bench.measure (random_vec.sort Sort_Direction.Descending) "Random Elements Descending" iter_size num_iterations Bench.measure (random_vec.sort on=projection) "Sorting with a Custom Projection" iter_size num_iterations - Bench.measure (random_vec.sort by=comparator) "Sorting with a Custom Comparison" iter_size num_iterations + Bench.measure (random_vec.sort by=comparator) "Sorting with the Default_Ordered_Comparator" iter_size num_iterations main = bench diff --git a/test/Table_Tests/src/Common_Table_Operations/Join/Join_Spec.enso b/test/Table_Tests/src/Common_Table_Operations/Join/Join_Spec.enso index 47e055add234..d4e1069637c5 100644 --- a/test/Table_Tests/src/Common_Table_Operations/Join/Join_Spec.enso +++ b/test/Table_Tests/src/Common_Table_Operations/Join/Join_Spec.enso @@ -15,12 +15,16 @@ from project.Common_Table_Operations.Util import expect_column_names, run_defaul type My_Type Value x y - compare_to self other = case other of - My_Type.Value ox oy -> - self.x+self.y . compare_to ox+oy - _ -> Ordering.Less - - == self other = self.compare_to other == Ordering.Equal +type My_Type_Comparator + is_ordered = True + + compare my_1 my_2 = + comp = Comparable.from my_1.x + comp.compare (my_1.x + my_1.y) (my_2.x + my_2.y) + + hash my_type = Comparable.from my_type.x . hash (my_type.x + my_type.y) + +Comparable.from (_:My_Type) = My_Type_Comparator main = run_default_backend spec diff --git a/test/Table_Tests/src/In_Memory/Table_Spec.enso b/test/Table_Tests/src/In_Memory/Table_Spec.enso index c724ba946cf4..54f5bb063963 100644 --- a/test/Table_Tests/src/In_Memory/Table_Spec.enso +++ b/test/Table_Tests/src/In_Memory/Table_Spec.enso @@ -457,7 +457,7 @@ spec = Test.specify 'should allow passing a custom comparator' <| c = Column.from_vector 'foo' [My.Data 1 2, My.Data 2 5, My.Data 3 4, My.Data 6 3, Nothing, My.Data 1 0] - cmp a b = (a.x-a.y).abs . compare_to (b.x-b.y).abs + cmp a b = Ordering.compare (a.x-a.y).abs (b.x-b.y).abs r = c.sort by=cmp r.to_vector.should_equal [My.Data 1 2, My.Data 3 4, My.Data 1 0, My.Data 2 5, My.Data 6 3, Nothing] diff --git a/test/Tests/src/Data/Bool_Spec.enso b/test/Tests/src/Data/Bool_Spec.enso index f2adc9be4644..32db28161307 100644 --- a/test/Tests/src/Data/Bool_Spec.enso +++ b/test/Tests/src/Data/Bool_Spec.enso @@ -18,10 +18,10 @@ spec = False.to_text . should_equal "False" Test.specify "should allow for comparing Bools" <| - True.compare_to True . should_equal Ordering.Equal - False.compare_to False . should_equal Ordering.Equal - True.compare_to False . should_equal Ordering.Greater - False.compare_to True . should_equal Ordering.Less + True == True . should_be_true + False == False . should_be_true + True > False . should_be_true + False < True . should_be_true Test.specify "should allow == operator" <| True.should_equal True diff --git a/test/Tests/src/Data/Map_Spec.enso b/test/Tests/src/Data/Map_Spec.enso index ad9e7d246352..59d681952149 100644 --- a/test/Tests/src/Data/Map_Spec.enso +++ b/test/Tests/src/Data/Map_Spec.enso @@ -445,7 +445,7 @@ spec = map.to_vector.should_equal [["A", 1], ["B", 2], ["C", 3]] Test.specify "should treat Java Map as Enso map" <| - sort_by_keys vec = vec.sort by=x-> y-> x.first.compare_to y.first + sort_by_keys vec = vec.sort by=x-> y-> Ordering.compare x.first y.first jmap = JavaMap.of "A" 1 "B" 2 (sort_by_keys jmap.to_vector) . should_equal [["A", 1], ["B", 2]] (sort_by_keys (jmap.insert "C" 3 . to_vector)) . should_equal [["A", 1], ["B", 2], ["C", 3]] diff --git a/test/Tests/src/Data/Numbers_Spec.enso b/test/Tests/src/Data/Numbers_Spec.enso index 3935753c3cb0..947bb3f3a30f 100644 --- a/test/Tests/src/Data/Numbers_Spec.enso +++ b/test/Tests/src/Data/Numbers_Spec.enso @@ -385,29 +385,29 @@ spec = (very_negative >= hundred_factorial).should_be_false (very_negative >= Nothing).should_fail_with Type_Error.Error - Test.specify "should support compare_to" <| - (1.compare_to 2).should_equal Ordering.Less - (1.compare_to 1).should_equal Ordering.Equal - (1.compare_to 0).should_equal Ordering.Greater - (1.compare_to 1.01).should_equal Ordering.Less - (1.compare_to 0.99).should_equal Ordering.Greater - (3.compare_to hundred_factorial).should_equal Ordering.Less - (3.compare_to very_negative).should_equal Ordering.Greater - (3.compare_to Nothing).should_fail_with Type_Error.Error - (1.01.compare_to 0.99).should_equal Ordering.Greater - (1.01.compare_to 1.02).should_equal Ordering.Less - (1.01.compare_to 1).should_equal Ordering.Greater - (1.01.compare_to 2).should_equal Ordering.Less - (3.14.compare_to hundred_factorial).should_equal Ordering.Less - (3.14.compare_to very_negative).should_equal Ordering.Greater - (1.5.compare_to Nothing).should_fail_with Type_Error.Error - (hundred_factorial.compare_to 1).should_equal Ordering.Greater - (hundred_factorial.compare_to 1.5).should_equal Ordering.Greater - (very_negative.compare_to 1).should_equal Ordering.Less - (very_negative.compare_to 1.5).should_equal Ordering.Less - (hundred_factorial.compare_to very_negative).should_equal Ordering.Greater - (very_negative.compare_to hundred_factorial).should_equal Ordering.Less - (very_negative.compare_to Nothing).should_fail_with Type_Error.Error + Test.specify "should be ordered by Default_Ordered_Comparator" <| + Ordering.compare 1 2 . should_equal Ordering.Less + Ordering.compare 1 1 . should_equal Ordering.Equal + Ordering.compare 1 0 . should_equal Ordering.Greater + Ordering.compare 1 1.01 . should_equal Ordering.Less + Ordering.compare 1 0.99 . should_equal Ordering.Greater + Ordering.compare 3 hundred_factorial . should_equal Ordering.Less + Ordering.compare 3 very_negative . should_equal Ordering.Greater + Ordering.compare 3 Nothing . should_fail_with Type_Error.Error + Ordering.compare 1.01 0.99 . should_equal Ordering.Greater + Ordering.compare 1.01 1.02 . should_equal Ordering.Less + Ordering.compare 1.01 1 . should_equal Ordering.Greater + Ordering.compare 1.01 2 . should_equal Ordering.Less + Ordering.compare 3.14 hundred_factorial . should_equal Ordering.Less + Ordering.compare 3.14 very_negative . should_equal Ordering.Greater + Ordering.compare 1.5 Nothing . should_fail_with Type_Error.Error + Ordering.compare hundred_factorial 1 . should_equal Ordering.Greater + Ordering.compare hundred_factorial 1.5 . should_equal Ordering.Greater + Ordering.compare very_negative 1 . should_equal Ordering.Less + Ordering.compare very_negative 1.5 . should_equal Ordering.Less + Ordering.compare hundred_factorial very_negative . should_equal Ordering.Greater + Ordering.compare very_negative hundred_factorial . should_equal Ordering.Less + Ordering.compare very_negative Nothing . should_fail_with Type_Error.Error Test.specify "should expose exponentiation operations" <| (3.14 ^ 2.71).should_equal 22.216689546 epsilon=eps diff --git a/test/Tests/src/Data/Ordering/Comparator_Spec.enso b/test/Tests/src/Data/Ordering/Comparator_Spec.enso index 4f6d554914b1..e4153f4c63fd 100644 --- a/test/Tests/src/Data/Ordering/Comparator_Spec.enso +++ b/test/Tests/src/Data/Ordering/Comparator_Spec.enso @@ -13,12 +13,18 @@ import Standard.Test.Extensions type Ord Value number - compare_to : Ord -> Ordering - compare_to self that = that.number.compare_to self.number +type Ord_Comparator + is_ordered = True + compare x y = (Comparable.from x.number) . compare x.number y.number + hash x = (Comparable.from x.number) . hash x.number + +Comparable.from (_:Ord) = Ord_Comparator type No_Ord Value number +Comparable.from (_:No_Ord) = Incomparable + # Tests spec = Test.group "Object Comparator" <| diff --git a/test/Tests/src/Data/Ordering/Natural_Order_Spec.enso b/test/Tests/src/Data/Ordering/Natural_Order_Spec.enso index 0df23dfae79d..0ff14dbefcff 100644 --- a/test/Tests/src/Data/Ordering/Natural_Order_Spec.enso +++ b/test/Tests/src/Data/Ordering/Natural_Order_Spec.enso @@ -37,7 +37,7 @@ spec = Test.group "Natural Order" <| Natural_Order.compare "100-200.300" "1.2.3" . should_equal Ordering.Greater Natural_Order.compare "1.2.3" "4.5.6" . should_equal Ordering.Less - ".".compare_to "-" . should_equal Ordering.Greater + Ordering.compare "." "-" . should_equal Ordering.Greater Natural_Order.compare "4-5-6" "4.5.6" . should_equal Ordering.Less Natural_Order.compare "4-5-6" "100-200.300" . should_equal Ordering.Less diff --git a/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso b/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso index 4349cfcec0ff..423ec83d8ccb 100644 --- a/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso +++ b/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso @@ -15,8 +15,8 @@ spec = Test.group "Lexicographic Order on Vectors" <| Vector_Lexicographic_Order.compare [] [1] . should_equal Ordering.Less Vector_Lexicographic_Order.compare [1] [1] . should_equal Ordering.Equal - Test.specify "should work correctly with a custom comparator" <| - comparator = x-> y-> x.a.compare_to y.a + Test.specify "should work correctly with a custom compare function" <| + comparator = x-> y-> Ordering.compare x.a y.a Vector_Lexicographic_Order.compare [My_Type.Value "a" 1, My_Type.Value "b" 1, My_Type.Value "c" 1] [My_Type.Value "b" 1, My_Type.Value "a" 1, My_Type.Value "c" 1] element_comparator=comparator . should_equal Ordering.Less Vector_Lexicographic_Order.compare [My_Type.Value "a" 1, My_Type.Value "b" 1, My_Type.Value "c" 1] [My_Type.Value "a" 100, My_Type.Value "b" 2, My_Type.Value "c" 3] element_comparator=comparator . should_equal Ordering.Equal diff --git a/test/Tests/src/Data/Ordering_Spec.enso b/test/Tests/src/Data/Ordering_Spec.enso index 015c6357e6ba..ab2e080aac2d 100644 --- a/test/Tests/src/Data/Ordering_Spec.enso +++ b/test/Tests/src/Data/Ordering_Spec.enso @@ -9,30 +9,57 @@ import Standard.Test.Extensions type Ord Value number - compare_to : Ord -> Ordering - compare_to self that = if self.number == that.number then Ordering.Equal else - if self.number > that.number then Ordering.Greater else Ordering.Less +type Ord_Comparator + is_ordered = True + compare x y = (Comparable.from x.number) . compare x.number y.number + hash x = (Comparable.from x.number) . hash x.number + +Comparable.from (_:Ord) = Ord_Comparator + +## Unordered pair +type UPair + Value x y + +type UPair_Comparator + is_ordered = False + + equals pair1 pair2 = + if pair1.x == pair2.x && pair1.y == pair2.y then True else + if pair1.x == pair2.y && pair1.y == pair2.x then True else + False + + hash upair = + x_comp = Comparable.from upair.x + y_comp = Comparable.from upair.y + (x_comp.hash upair.x) + (y_comp.hash upair.y) + +Comparable.from (_ : UPair) = UPair_Comparator + +type Parent + Value child # === The Tests === spec = - Test.group "Ordering" <| + Test.group "Default ordered comparator" <| + Test.specify "should support custom ordered comparator" <| + Ordering.compare (Ord.Value 1) (Ord.Value 2) . should_equal Ordering.Less + Ordering.compare (Ord.Value 1) (Ord.Value 1) . should_equal Ordering.Equal + Ordering.compare (Ord.Value 20) (Ord.Value 1) . should_equal Ordering.Less - Test.specify "should allow comparing Less" <| - left = Ord.Value 1032 - right = Ord.Value 101111 - left.compare_to right . should_equal Ordering.Less + Test.specify "should support custom ordered comparator in atom field" <| + Ordering.compare (Parent.Value (Ord.Value 1)) (Parent.Value (Ord.Value 2)) . should_equal Ordering.Less + Ordering.compare (Parent.Value (Ord.Value 1)) (Parent.Value (Ord.Value 1)) . should_equal Ordering.Equal + Ordering.compare (Parent.Value (Ord.Value 20)) (Parent.Value (Ord.Value 1)) . should_equal Ordering.Less - Test.specify "should allow comparing Equal" <| - left = Ord.Value 1032 - right = Ord.Value 1032 - left.compare_to right . should_equal Ordering.Equal + Test.specify "should throw Incomparable_Values when comparing types with unordered comparator" <| + Ordering.compare (UPair.Value 1 2) (UPair.Value 2 1) . should_fail_with Incomparable_Values - Test.specify "should allow comparing Greater" <| - left = Ord.Value 1032 - right = Ord.Value -1 - left.compare_to right . should_equal Ordering.Greater + Test.specify "should throw Type_Error when comparing different types" <| + Ordering.compare (UPair.Value 1 2) (Ord.Value 2) . should_fail_with Type_Error.Error + Ordering.compare 1 Nothing . should_fail_with Type_Error.Error + Test.group "Ordering" <| Test.specify "should allow conversion to sign representation" <| Ordering.Less.to_sign . should_equal -1 Ordering.Equal.to_sign . should_equal 0 @@ -44,15 +71,15 @@ spec = Ordering.from_sign 1 . should_equal Ordering.Greater Test.specify "should be ordered itself" <| - Ordering.Less.compare_to Ordering.Less . should_equal Ordering.Equal - Ordering.Less.compare_to Ordering.Equal . should_equal Ordering.Less - Ordering.Less.compare_to Ordering.Greater . should_equal Ordering.Less - Ordering.Equal.compare_to Ordering.Less . should_equal Ordering.Greater - Ordering.Equal.compare_to Ordering.Equal . should_equal Ordering.Equal - Ordering.Equal.compare_to Ordering.Greater . should_equal Ordering.Less - Ordering.Greater.compare_to Ordering.Less . should_equal Ordering.Greater - Ordering.Greater.compare_to Ordering.Equal . should_equal Ordering.Greater - Ordering.Greater.compare_to Ordering.Greater . should_equal Ordering.Equal + Ordering.compare Ordering.Less Ordering.Less . should_equal Ordering.Equal + Ordering.compare Ordering.Less Ordering.Equal . should_equal Ordering.Less + Ordering.compare Ordering.Less Ordering.Greater . should_equal Ordering.Less + Ordering.compare Ordering.Equal Ordering.Less . should_equal Ordering.Greater + Ordering.compare Ordering.Equal Ordering.Equal . should_equal Ordering.Equal + Ordering.compare Ordering.Equal Ordering.Greater . should_equal Ordering.Less + Ordering.compare Ordering.Greater Ordering.Less . should_equal Ordering.Greater + Ordering.compare Ordering.Greater Ordering.Equal . should_equal Ordering.Greater + Ordering.compare Ordering.Greater Ordering.Greater . should_equal Ordering.Equal Test.specify "should allow lexicographical composition" <| Ordering.Less.and_then Ordering.Less . should_equal Ordering.Less @@ -66,8 +93,8 @@ spec = Ordering.Greater.and_then Ordering.Greater . should_equal Ordering.Greater Test.specify "should fail with Type_Error for wrong type of that" <| - Ordering.Less.compare_to 1 . should_fail_with Type_Error.Error - Ordering.Less.compare_to Nothing . should_fail_with Type_Error.Error - Ordering.Less.compare_to "Hello" . should_fail_with Type_Error.Error + Ordering.compare Ordering.Less 1 . should_fail_with Type_Error.Error + Ordering.compare Ordering.Less Nothing . should_fail_with Type_Error.Error + Ordering.compare Ordering.Less "Hello" . should_fail_with Type_Error.Error main = Test_Suite.run_main spec diff --git a/test/Tests/src/Data/Statistics_Spec.enso b/test/Tests/src/Data/Statistics_Spec.enso index 7ebdf0a40150..c1c759d5d8aa 100644 --- a/test/Tests/src/Data/Statistics_Spec.enso +++ b/test/Tests/src/Data/Statistics_Spec.enso @@ -11,12 +11,18 @@ import Standard.Test.Extensions type Ord Value number -Ord.compare_to : Ord -> Ordering -Ord.compare_to self that = that.number.compare_to self.number +type Ord_Comparator + is_ordered = True + compare x y = (Comparable.from x.number) . compare x.number y.number + hash x = (Comparable.from x.number) . hash x.number + +Comparable.from (_:Ord) = Ord_Comparator type No_Ord Value number +Comparable.from (_:No_Ord) = Incomparable + # Tests spec = @@ -155,12 +161,12 @@ spec = text_set.compute Statistic.Kurtosis . should_fail_with Illegal_Argument.Error text_set.running Statistic.Sum . should_fail_with Illegal_Argument.Error - Test.specify "should be able to do Count, Minimum and Maximum on custom type with compare_to" <| + Test.specify "should be able to do Count, Minimum and Maximum on custom type with custom ordered comparator" <| ord_set.compute . should_equal 3 ord_set.compute Statistic.Minimum . should_equal (Ord.Value 10) ord_set.compute Statistic.Maximum . should_equal (Ord.Value 2) - Test.specify "should fail with Incomparable_Values on custom type without compare_to" <| + Test.specify "should fail with Incomparable_Values on custom incomparable type" <| no_ord_set.compute . should_equal 3 no_ord_set.compute Statistic.Minimum . should_fail_with Incomparable_Values no_ord_set.compute Statistic.Maximum . should_fail_with Incomparable_Values @@ -189,7 +195,7 @@ spec = values = ["G", "AA", "B", "G", "D"] Statistic.rank_data values . should_equal [1.5, 5, 4, 1.5, 3] - Test.specify "should fail with Incomparable_Values on custom type without compare_to" <| + Test.specify "should fail with Incomparable_Values on custom incomparable type" <| values = [No_Ord.Value 10, No_Ord.Value 2, No_Ord.Value 9] Statistic.rank_data values . should_fail_with Incomparable_Values diff --git a/test/Tests/src/Data/Text_Spec.enso b/test/Tests/src/Data/Text_Spec.enso index 0a0b04875c1a..56c5ce3a82fa 100644 --- a/test/Tests/src/Data/Text_Spec.enso +++ b/test/Tests/src/Data/Text_Spec.enso @@ -91,39 +91,39 @@ spec = complex_letter_1 . should_equal complex_letter_2 complex_letter_1 . should_equal complex_letter_3 complex_letter_3 . should_equal complex_letter_2 - common_prefix+complex_letter_1+complex_letter_2+complex_letter_3 . compare_to common_prefix+complex_letter_3+complex_letter_1+complex_letter_2 . should_equal Ordering.Equal + Ordering.compare (common_prefix+complex_letter_1+complex_letter_2+complex_letter_3) (common_prefix+complex_letter_3+complex_letter_1+complex_letter_2) . should_equal Ordering.Equal 'e\u{301}'=='e\u{302}' . should_be_false 'a\u0321\u0302'=='a\u0302\u0321' . should_be_true 'a\u0321\u0302'=='A\u0302\u0321' . should_be_false - accent_1+"a" . compare_to accent_2+"a" . should_equal Ordering.Equal - accent_1+"A" . compare_to accent_2+"a" . should_equal Ordering.Less + Ordering.compare accent_1+"a" accent_2+"a" . should_equal Ordering.Equal + Ordering.compare accent_1+"A" accent_2+"a" . should_equal Ordering.Less accent_1+"A" . compare_to_ignore_case accent_2+"a" . should_equal Ordering.Equal - accent_1+"a" . compare_to accent_2+"b" . should_equal Ordering.Less + Ordering.compare accent_1+"a" accent_2+"b" . should_equal Ordering.Less accent_1+"a" . compare_to_ignore_case accent_2+"B" . should_equal Ordering.Less - accent_2+"a" . compare_to accent_1+"b" . should_equal Ordering.Less - accent_1+"a" . compare_to accent_2+"B" . should_equal Ordering.Greater + Ordering.compare accent_2+"a" accent_1+"b" . should_equal Ordering.Less + Ordering.compare accent_1+"a" accent_2+"B" . should_equal Ordering.Greater accent_1+"a" . compare_to_ignore_case accent_2+"B" . should_equal Ordering.Less - accent_1+"b" . compare_to accent_2+"a" . should_equal Ordering.Greater - accent_2+"b" . compare_to accent_1+"a" . should_equal Ordering.Greater + Ordering.compare accent_1+"b" accent_2+"a" . should_equal Ordering.Greater + Ordering.compare accent_2+"b" accent_1+"a" . should_equal Ordering.Greater # Handling of Nothing (accent_1 == Nothing) . should_be_false (accent_1 != Nothing) . should_be_true - accent_1 . compare_to Nothing . should_fail_with Type_Error.Error + Ordering.compare accent_1 Nothing . should_fail_with Type_Error.Error (accent_1 > Nothing) . should_fail_with Type_Error.Error accent_1 . compare_to_ignore_case Nothing . should_fail_with Type_Error.Error earlier_suffix = "aooooz" later_suffix = "bo" - common_prefix+complex_letter_1+earlier_suffix . compare_to common_prefix+complex_letter_2+later_suffix . should_equal Ordering.Less - common_prefix+complex_letter_2+earlier_suffix . compare_to common_prefix+complex_letter_1+later_suffix . should_equal Ordering.Less - common_prefix+complex_letter_2+earlier_suffix . compare_to common_prefix+complex_letter_3+later_suffix . should_equal Ordering.Less - common_prefix+complex_letter_3+earlier_suffix . compare_to common_prefix+complex_letter_1+later_suffix . should_equal Ordering.Less - common_prefix+complex_letter_3+later_suffix . compare_to common_prefix+complex_letter_1+earlier_suffix . should_equal Ordering.Greater - common_prefix+complex_letter_1+later_suffix . compare_to common_prefix+complex_letter_2+earlier_suffix . should_equal Ordering.Greater + Ordering.compare common_prefix+complex_letter_1+earlier_suffix common_prefix+complex_letter_2+later_suffix . should_equal Ordering.Less + Ordering.compare common_prefix+complex_letter_2+earlier_suffix common_prefix+complex_letter_1+later_suffix . should_equal Ordering.Less + Ordering.compare common_prefix+complex_letter_2+earlier_suffix common_prefix+complex_letter_3+later_suffix . should_equal Ordering.Less + Ordering.compare common_prefix+complex_letter_3+earlier_suffix common_prefix+complex_letter_1+later_suffix . should_equal Ordering.Less + Ordering.compare common_prefix+complex_letter_3+later_suffix common_prefix+complex_letter_1+earlier_suffix . should_equal Ordering.Greater + Ordering.compare common_prefix+complex_letter_1+later_suffix common_prefix+complex_letter_2+earlier_suffix . should_equal Ordering.Greater Test.specify "should correctly handle case-insensitive equality" <| "aBc" . equals_ignore_case "Abc" . should_be_true diff --git a/test/Tests/src/Data/Time/Date_Time_Spec.enso b/test/Tests/src/Data/Time/Date_Time_Spec.enso index 18424843e05c..d8edaa1997e2 100644 --- a/test/Tests/src/Data/Time/Date_Time_Spec.enso +++ b/test/Tests/src/Data/Time/Date_Time_Spec.enso @@ -324,12 +324,12 @@ spec_with name create_new_datetime parse_datetime nanoseconds_loss_in_precision= time_1duration_2 . should_be_true diff --git a/test/Tests/src/Data/Vector_Spec.enso b/test/Tests/src/Data/Vector_Spec.enso index 3519ddf936a9..f448e53c8dfd 100644 --- a/test/Tests/src/Data/Vector_Spec.enso +++ b/test/Tests/src/Data/Vector_Spec.enso @@ -16,10 +16,10 @@ import Standard.Test.Extensions type T Value a b - == self that = self.a == that.a - - compare_to self that = if self == that then Ordering.Equal else - if self.a > that.a then Ordering.Greater else Ordering.Less +type T_Comparator + is_ordered = True + compare t1 t2 = Comparable.from t1.a . compare t1.a t2.a + hash t = Comparable.from t.a . has t.a type My_Error Value a @@ -28,10 +28,10 @@ type Foo Value vec compare_tco a b = case a.vec.length == b.vec.length of - False -> a.vec.length . compare_to b.vec.length + False -> Ordering.compare a.vec.length b.vec.length True -> go ix = if ix > a.vec.length then Ordering.Equal else - cmp = (a.vec.at ix) . compare_to (b.vec.at ix) + cmp = Ordering.compare (a.vec.at ix) (b.vec.at ix) case cmp of Ordering.Equal -> @Tail_Call go ix+1 _ -> cmp @@ -567,20 +567,20 @@ spec = Test.group "Vectors" <| small_expected = [T.Value -20 0, T.Value 4 0, T.Value -1 1, T.Value 1 3, T.Value 1 8, T.Value -1 10] small_vec.sort (on = _.b) . should_equal small_expected - Test.specify "should be able to use a custom comparator" <| + Test.specify "should be able to use a custom compare function" <| small_vec = [2, 7, -3, 383, -392, 28, -90] small_expected = [383, 28, 7, 2, -3, -90, -392] - small_vec.sort (by = l -> r -> r.compare_to l) . should_equal small_expected + small_vec.sort (by = l -> r -> Ordering.compare r l) . should_equal small_expected Test.specify "should allow tail-recursive comparators in sort" <| v = [Foo.Value [4,2,2], Foo.Value [1,2,3], Foo.Value [1,2,4]] r = [Foo.Value [1,2,3], Foo.Value [1,2,4], Foo.Value [4,2,2]] v.sort by=compare_tco . should_equal r - Test.specify "should be able to use a custom comparator and projection" <| + Test.specify "should be able to use a custom compare function and projection" <| small_vec = [T.Value 1 8, T.Value 1 3, T.Value -20 0, T.Value -1 1, T.Value -1 10, T.Value 4 0] small_expected = [T.Value -1 10, T.Value 1 8, T.Value 1 3, T.Value -1 1, T.Value -20 0, T.Value 4 0] - small_vec.sort (on = _.b) (by = l -> r -> r.compare_to l) . should_equal small_expected + small_vec.sort (on = _.b) (by = l -> r -> Ordering.compare r l) . should_equal small_expected Test.specify "should be able to sort in descending order" <| small_vec = [2, 7, -3, 383, -392, 28, -90] @@ -641,7 +641,7 @@ spec = Test.group "Vectors" <| [1, 1.0, 2, 2.0].distinct . should_equal [1, 2] [].distinct . should_equal [] - Test.specify "should correctly handle distinct with custom types like Atoms that implement compare_to" <| + Test.specify "should correctly handle distinct with types that have custom comparators" <| [T.Value 1 2, T.Value 3 3, T.Value 1 2].distinct . should_equal [T.Value 1 2, T.Value 3 3] Test.specify "should return a vector containing only unique elements up to some criteria" <| From 641c9c883b7c7502ac23970ae895922a50e047f0 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 2 Feb 2023 16:32:53 +0100 Subject: [PATCH 32/60] Replace compare_to with Comparators (Batch 3) --- .../lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso | 5 +++++ .../Standard/Base/0.0.0-dev/src/Data/Statistics.enso | 1 + .../Standard/Base/0.0.0-dev/src/Data/Time/Period.enso | 3 --- test/Tests/src/Data/Bool_Spec.enso | 8 ++++---- test/Tests/src/Data/Ordering_Spec.enso | 10 +++++----- test/Tests/src/Data/Time/Date_Spec.enso | 2 +- test/Tests/src/Semantic/Equals_Spec.enso | 7 ++++++- 7 files changed, 22 insertions(+), 14 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso index f254fac3c5fa..75e050eb608d 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Boolean.enso @@ -1,5 +1,7 @@ import project.Any.Any import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable +import project.Data.Ordering.Default_Ordered_Comparator import project.Nothing.Nothing from project.Data.Boolean.Boolean import True, False @@ -87,3 +89,6 @@ type Boolean if (27 % 3) == 0 then IO.println "Fizz" if_then : Any -> Any | Nothing if_then self ~on_true = @Builtin_Method "Boolean.if_then" + + +Comparable.from (_:Boolean) = Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso index 930d53b2cfd7..7431b9f843aa 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Statistics.enso @@ -5,6 +5,7 @@ import project.Data.Numbers.Integer import project.Data.Numbers.Number import project.Data.Ordering.Comparator import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable import project.Data.Range.Extensions import project.Data.Vector.Vector import project.Error.Error diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso index a1263831abad..c38cf9e03f32 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Period.enso @@ -130,6 +130,3 @@ type Period case err of DateTimeException -> Error.throw Time_Error.Error "Period subtraction failed" ArithmeticException -> Error.throw Illegal_Argument.Error "Arithmetic error" - - -Comparable.from (_:Period) = Incomparable diff --git a/test/Tests/src/Data/Bool_Spec.enso b/test/Tests/src/Data/Bool_Spec.enso index 32db28161307..b03df1d3a011 100644 --- a/test/Tests/src/Data/Bool_Spec.enso +++ b/test/Tests/src/Data/Bool_Spec.enso @@ -18,10 +18,10 @@ spec = False.to_text . should_equal "False" Test.specify "should allow for comparing Bools" <| - True == True . should_be_true - False == False . should_be_true - True > False . should_be_true - False < True . should_be_true + (True == True) . should_be_true + (False == False) . should_be_true + (True > False) . should_be_true + (False < True) . should_be_true Test.specify "should allow == operator" <| True.should_equal True diff --git a/test/Tests/src/Data/Ordering_Spec.enso b/test/Tests/src/Data/Ordering_Spec.enso index ab2e080aac2d..ebd76b1f1f6c 100644 --- a/test/Tests/src/Data/Ordering_Spec.enso +++ b/test/Tests/src/Data/Ordering_Spec.enso @@ -1,5 +1,6 @@ from Standard.Base import all import Standard.Base.Error.Common.Type_Error +import Standard.Base.Error.Incomparable_Values.Incomparable_Values from Standard.Test import Test, Test_Suite import Standard.Test.Extensions @@ -45,12 +46,11 @@ spec = Test.specify "should support custom ordered comparator" <| Ordering.compare (Ord.Value 1) (Ord.Value 2) . should_equal Ordering.Less Ordering.compare (Ord.Value 1) (Ord.Value 1) . should_equal Ordering.Equal - Ordering.compare (Ord.Value 20) (Ord.Value 1) . should_equal Ordering.Less + Ordering.compare (Ord.Value 20) (Ord.Value 1) . should_equal Ordering.Greater - Test.specify "should support custom ordered comparator in atom field" <| - Ordering.compare (Parent.Value (Ord.Value 1)) (Parent.Value (Ord.Value 2)) . should_equal Ordering.Less - Ordering.compare (Parent.Value (Ord.Value 1)) (Parent.Value (Ord.Value 1)) . should_equal Ordering.Equal - Ordering.compare (Parent.Value (Ord.Value 20)) (Parent.Value (Ord.Value 1)) . should_equal Ordering.Less + Test.specify "should support equality for custom ordered comparators in atom field" <| + ((Parent.Value (Ord.Value 1)) == (Parent.Value (Ord.Value 1))) . should_be_true + ((Parent.Value (Ord.Value 1)) == (Parent.Value (Ord.Value 22))) . should_be_false Test.specify "should throw Incomparable_Values when comparing types with unordered comparator" <| Ordering.compare (UPair.Value 1 2) (UPair.Value 2 1) . should_fail_with Incomparable_Values diff --git a/test/Tests/src/Data/Time/Date_Spec.enso b/test/Tests/src/Data/Time/Date_Spec.enso index d609129c13af..5943ab568199 100644 --- a/test/Tests/src/Data/Time/Date_Spec.enso +++ b/test/Tests/src/Data/Time/Date_Spec.enso @@ -132,7 +132,7 @@ spec_with name create_new_date parse_date = date_1=datetime . should_fail_with Type_Error.Error date_1==datetime . should_be_false diff --git a/test/Tests/src/Semantic/Equals_Spec.enso b/test/Tests/src/Semantic/Equals_Spec.enso index 400cd6d082ff..d54f9ac99381 100644 --- a/test/Tests/src/Semantic/Equals_Spec.enso +++ b/test/Tests/src/Semantic/Equals_Spec.enso @@ -134,12 +134,17 @@ spec = (grand_parent1 == grand_parent2).should_be_true - Test.specify "should handle `==` on types with many fields" <| + Test.specify "should handle `==` on types with many fields with custom comparator" <| many_fields1 = ManyFieldType.Value (Child.Value 1) (Child.Value 2) (Child.Value 3) (Child.Value 4) (Child.Value 5) (Child.Value 6) (Child.Value 7) (Child.Value 8) (Child.Value 9) (Child.Value 10) (Child.Value 11) (Child.Value 12) (Child.Value 13) (Child.Value 14) (Child.Value 15) many_fields2 = ManyFieldType.Value (Child.Value 101) (Child.Value 102) (Child.Value 103) (Child.Value 104) (Child.Value 105) (Child.Value 106) (Child.Value 107) (Child.Value 108) (Child.Value 109) (Child.Value 110) (Child.Value 111) (Child.Value 112) (Child.Value 113) (Child.Value 114) (Child.Value 115) (many_fields1 == many_fields2).should_be_true + Test.specify "should handle `==` on atoms with fields with mixed comparators" <| + obj_1 = FourFieldType.Value (Child.Value 1) 42 (Child.Value 2) 83 + obj_2 = FourFieldType.Value (Child.Value 101) 42 (Child.Value 102) 83 + (obj_1 == obj_2).should_be_true + Test.specify "should be able to compare atoms with different constructors" <| ((CustomEqType.C1 10) == (CustomEqType.C2 7 3)).should_be_true ((CustomEqType.C1 0) == (CustomEqType.C2 7 3)).should_be_false From 1bb1d9b62771284106ee9782126f3c1146a7d4cf Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 2 Feb 2023 16:36:28 +0100 Subject: [PATCH 33/60] Fix infinite recursion of Any.== Builtin nodes dispatch to custom comparators for fields or elements rather than directly on the atom --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 22 ++++++----- .../expression/builtin/meta/EqualsNode.java | 39 ++++++++++++------- .../expression/builtin/meta/HashCodeNode.java | 28 +++++++++---- .../ordering/HasCustomComparatorNode.java | 5 +++ .../builtin/ordering/HashCallbackNode.java | 10 +++-- 5 files changed, 71 insertions(+), 33 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 8eb391aabc23..b5aad7f3d3b7 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -6,6 +6,7 @@ import project.Data.Text.Text import project.Error.Error import project.Error.Incomparable_Values.Incomparable_Values import project.Error.Common.No_Such_Conversion +import project.Error.Common.Type_Error import project.Nothing.Nothing import project.Meta import project.Panic.Panic @@ -110,7 +111,7 @@ type Any # host or polyglot values, so we just compare them with the default comparator. eq_self = Panic.catch No_Such_Conversion (Comparable.from self) _-> Default_Unordered_Comparator eq_that = Panic.catch No_Such_Conversion (Comparable.from that) _-> Default_Unordered_Comparator - if eq_self.is_a Incomparable then False else + if Comparable.equals_builtin eq_self Incomparable then False else # Comparable.equals_builtin is a hack how to directly access EqualsNode from the # engine, so that we don't end up in an infinite recursion here (which would happen # if we would compare with `eq_self == eq_that`). @@ -168,7 +169,9 @@ type Any > : Any -> Boolean ! Incomparable_Values > self that = assert_ordered_comparators self that <| - (Comparable.from self).compare self that == Ordering.Greater + case (Comparable.from self).compare self that of + Ordering.Greater -> True + _ -> False ## ALIAS Greater Than or Equal @@ -222,7 +225,9 @@ type Any < : Any -> Boolean ! Incomparable_Values < self that = assert_ordered_comparators self that <| - (Comparable.from self).compare self that == Ordering.Less + case (Comparable.from self).compare self that of + Ordering.Less -> True + _ -> False ## ALIAS Less Than or Equal @@ -425,13 +430,12 @@ type Any Checks if both comparators of the given objects are both of same type and ordered. If they are not of same type, a `Type_Error` is thrown. If the comparators are either `Incomparable`, or unordered, `False` is returned. -assert_ordered_comparators : Any -> (Any -> Any) -> Any +assert_ordered_comparators : Any -> (Any -> Any) -> Any ! (Type_Error | Incomparable_Values) assert_ordered_comparators this that ~action = comp_this = Comparable.from this comp_that = Comparable.from that - case Meta.type_of comp_this == Meta.type_of comp_that of - False -> - Error.throw Incomparable_Values - True -> - if comp_this.is_a Incomparable || comp_this.is_ordered.not then False else action + if (Comparable.equals_builtin comp_this comp_that).not then Error.throw (Type_Error.Error (Meta.type_of comp_this) comp_that "comp_that") else + if Comparable.equals_builtin comp_this Incomparable || comp_this.is_ordered.not then Error.throw Incomparable_Values else + action + diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index c989244203fe..da43f8ceb385 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -455,7 +455,9 @@ boolean equalsStrings(Object selfString, Object otherString, boolean equalsArrays(Object selfArray, Object otherArray, @CachedLibrary("selfArray") InteropLibrary selfInterop, @CachedLibrary("otherArray") InteropLibrary otherInterop, - @Cached EqualsNode equalsNode + @Cached EqualsNode equalsNode, + @Cached HasCustomComparatorNode hasCustomComparatorNode, + @Cached InvokeAnyEqualsNode invokeAnyEqualsNode ) { try { long selfSize = selfInterop.getArraySize(selfArray); @@ -465,7 +467,15 @@ boolean equalsArrays(Object selfArray, Object otherArray, for (long i = 0; i < selfSize; i++) { Object selfElem = selfInterop.readArrayElement(selfArray, i); Object otherElem = otherInterop.readArrayElement(otherArray, i); - if (!equalsNode.execute(selfElem, otherElem)) { + boolean elemsAreEqual; + if (selfElem instanceof Atom selfAtomElem + && otherElem instanceof Atom otherAtomElem + && hasCustomComparatorNode.execute(selfAtomElem)) { + elemsAreEqual = invokeAnyEqualsNode.execute(selfAtomElem, otherAtomElem); + } else { + elemsAreEqual = equalsNode.execute(selfElem, otherElem); + } + if (!elemsAreEqual) { return false; } } @@ -599,12 +609,6 @@ boolean equalsAtoms( @Cached HasCustomComparatorNode hasCustomComparatorNode, @Cached InvokeAnyEqualsNode invokeAnyEqualsNode ) { - if (hasCustomComparatorNode.execute(self)) { - // We don't check whether `other` has the same type of comparator, that is checked in - // `Any.==` that we invoke here anyway. - return invokeAnyEqualsNode.execute(self, other); - } - if (constructorsNotEqualProfile.profile( self.getConstructor() != other.getConstructor() )) { @@ -618,10 +622,19 @@ boolean equalsAtoms( if (enoughEqualNodesForFieldsProfile.profile(fieldsSize <= equalsNodeCountForFields)) { loopProfile.profileCounted(fieldsSize); for (int i = 0; loopProfile.inject(i < fieldsSize); i++) { - if (!fieldEqualsNodes[i].execute( - selfFields[i], - otherFields[i] - )) { + boolean fieldsAreEqual; + // We don't check whether `other` has the same type of comparator, that is checked in + // `Any.==` that we invoke here anyway. + if (selfFields[i] instanceof Atom selfAtomField + && otherFields[i] instanceof Atom otherAtomField + && hasCustomComparatorNode.execute(selfAtomField)) { + // If selfFields[i] has a custom comparator, we delegate to `Any.==` that deals with + // custom comparators. EqualsNode cannot deal with custom comparators. + fieldsAreEqual = invokeAnyEqualsNode.execute(selfAtomField, otherAtomField); + } else { + fieldsAreEqual = fieldEqualsNodes[i].execute(selfFields[i], otherFields[i]); + } + if (!fieldsAreEqual) { return false; } } @@ -638,7 +651,7 @@ private static boolean equalsAtomsFieldsUncached(Object[] selfFields, Object[] o boolean areFieldsSame; if (selfFields[i] instanceof Atom selfFieldAtom && otherFields[i] instanceof Atom otherFieldAtom - && atomOverridesEquals(selfFieldAtom)) { + && HasCustomComparatorNode.getUncached().execute(selfFieldAtom)) { areFieldsSame = InvokeAnyEqualsNode.getUncached().execute(selfFieldAtom, otherFieldAtom); } else { areFieldsSame = EqualsNodeGen.getUncached().execute(selfFields[i], otherFields[i]); diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index 7a1ed7ad88f0..aec74bf60c93 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -203,10 +203,6 @@ long hashCodeForAtom( return atom.getHashCode(); } - if (hasCustomComparatorNode.execute(atom)) { - return hashCallbackNode.execute(atom); - } - Object[] fields = structs.getFields(atom); int fieldsCount = fields.length; @@ -215,7 +211,11 @@ long hashCodeForAtom( if (enoughHashCodeNodesForFields.profile(fieldsCount <= hashCodeNodeCountForFields)) { loopProfile.profileCounted(fieldsCount); for (int i = 0; loopProfile.inject(i < fieldsCount); i++) { - hashes[i] = (int) fieldHashCodeNodes[i].execute(fields[i]); + if (fields[i] instanceof Atom atomField && hasCustomComparatorNode.execute(atomField)) { + hashes[i] = (int) hashCallbackNode.execute(atomField); + } else { + hashes[i] = (int) fieldHashCodeNodes[i].execute(fields[i]); + } } } else { hashCodeForAtomFieldsUncached(fields, hashes); @@ -232,7 +232,12 @@ long hashCodeForAtom( @TruffleBoundary private void hashCodeForAtomFieldsUncached(Object[] fields, int[] fieldHashes) { for (int i = 0; i < fields.length; i++) { - fieldHashes[i] = (int) HashCodeNodeGen.getUncached().execute(fields[i]); + if (fields[i] instanceof Atom atomField + && HasCustomComparatorNode.getUncached().execute(atomField)) { + fieldHashes[i] = (int) HashCallbackNode.getUncached().execute(atomField); + } else { + fieldHashes[i] = (int) HashCodeNodeGen.getUncached().execute(fields[i]); + } } } @@ -397,14 +402,21 @@ long hashCodeForArray( Object selfArray, @CachedLibrary("selfArray") InteropLibrary interop, @Cached HashCodeNode hashCodeNode, - @Cached("createCountingProfile()") LoopConditionProfile loopProfile) { + @Cached("createCountingProfile()") LoopConditionProfile loopProfile, + @Cached HashCallbackNode hashCallbackNode, + @Cached HasCustomComparatorNode hasCustomComparatorNode) { try { long arraySize = interop.getArraySize(selfArray); loopProfile.profileCounted(arraySize); int[] elemHashCodes = new int[(int) arraySize]; for (int i = 0; loopProfile.inject(i < arraySize); i++) { if (interop.isArrayElementReadable(selfArray, i)) { - elemHashCodes[i] = (int) hashCodeNode.execute(interop.readArrayElement(selfArray, i)); + Object elem = interop.readArrayElement(selfArray, i); + if (elem instanceof Atom atomElem && hasCustomComparatorNode.execute(atomElem)) { + elemHashCodes[i] = (int) hashCallbackNode.execute(atomElem); + } else { + elemHashCodes[i] = (int) hashCodeNode.execute(elem); + } } } return Arrays.hashCode(elemHashCodes); diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java index dc5ea75ecab4..8072bf4abdea 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java @@ -24,6 +24,11 @@ */ @GenerateUncached public abstract class HasCustomComparatorNode extends Node { + + public static HasCustomComparatorNode getUncached() { + return HasCustomComparatorNodeGen.getUncached(); + } + /** * Returns true if the given atom has a custom comparator, that is a comparator that is different * than the default (internal) ones. The default comparators are {@code Default_Unordered_Comparator} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java index 5049a34eaaa1..47d83b9a6e09 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java @@ -24,6 +24,11 @@ */ @GenerateUncached public abstract class HashCallbackNode extends Node { + + public static HashCallbackNode getUncached() { + return HashCallbackNodeGen.getUncached(); + } + /** * Dispatches to the appropriate comparator for the given atom and calls {@code hash} * method on it. Returns the value from that method. @@ -41,18 +46,17 @@ public abstract class HashCallbackNode extends Node { long hashCallbackCached( Atom atom, @Cached(value = "getHashCallbackFunction()", allowUncached = true) Function hashCallbackFunc, - @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hasCustomComparatorInvokeNode, + @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hashCallbackInvokeNode, @CachedLibrary(limit = "5") InteropLibrary interop ) { var ctx = EnsoContext.get(this); var comparableType = ctx.getBuiltins().comparable().getType(); - Object res = hasCustomComparatorInvokeNode.execute( + Object res = hashCallbackInvokeNode.execute( hashCallbackFunc, null, State.create(ctx), new Object[]{comparableType, atom} ); - assert interop.fitsInLong(res); try { return interop.asLong(res); } catch (UnsupportedMessageException e) { From 92ae88e4beb0da90a584805ddf375c99051edc6a Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 2 Feb 2023 16:37:11 +0100 Subject: [PATCH 34/60] LessThanNode fallback returns Type_Error --- .../expression/builtin/ordering/LessThanNode.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java index 8f0c63f60170..b1490075dcf4 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/LessThanNode.java @@ -15,6 +15,7 @@ import java.time.ZonedDateTime; import org.enso.interpreter.dsl.AcceptsError; import org.enso.interpreter.dsl.BuiltinMethod; +import org.enso.interpreter.runtime.EnsoContext; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.DataflowError; import org.enso.interpreter.runtime.error.WarningsLibrary; @@ -35,7 +36,7 @@ public static LessThanNode build() { return LessThanNodeGen.create(); } - public abstract boolean execute(@AcceptsError Object left, @AcceptsError Object other); + public abstract Object execute(@AcceptsError Object left, @AcceptsError Object other); @Specialization boolean lessIntegers(int i, int j) { @@ -113,7 +114,7 @@ boolean lessDoubleBigInt(double self, EnsoBigInteger other) { @Specialization(guards = { "selfWarnLib.hasWarnings(selfWithWarnings) || otherWarnLib.hasWarnings(otherWithWarnings)" }, limit = "3") - boolean lessWithWarnings(Object selfWithWarnings, Object otherWithWarnings, + Object lessWithWarnings(Object selfWithWarnings, Object otherWithWarnings, @CachedLibrary("selfWithWarnings") WarningsLibrary selfWarnLib, @CachedLibrary("otherWithWarnings") WarningsLibrary otherWarnLib, @Cached LessThanNode lessThanNode @@ -297,8 +298,8 @@ boolean lessInteropDuration(Object selfDuration, Object otherDuration, } @Fallback - boolean fallBack(Object self, Object other) { - // Will be 'converted' to Incomparable_Values_Error - throw DataflowError.withoutTrace("Incomparable values: " + self + " and " + other, null); + Object fallback(Object left, Object right) { + var typeError = EnsoContext.get(this).getBuiltins().error().makeTypeError(left, right, "right"); + return DataflowError.withoutTrace(typeError, this); } } From bc0c1554e04b6a3968acde0bb7d38cae444c949b Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 2 Feb 2023 16:38:20 +0100 Subject: [PATCH 35/60] Fix conversion method dispatch on polyglot values https://www.pivotaltracker.com/story/show/184380208 --- .../node/callable/InvokeConversionNode.java | 103 ++++++++++++++++++ .../test/semantic/ConversionMethodsTest.scala | 46 +++++++- 2 files changed, 148 insertions(+), 1 deletion(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java index dfe580bdb90c..9cbbaa62460e 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java @@ -8,6 +8,8 @@ import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.nodes.Node; import com.oracle.truffle.api.source.SourceSection; +import java.time.LocalDate; +import java.time.ZonedDateTime; import org.enso.interpreter.node.BaseNode; import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; import org.enso.interpreter.node.callable.resolver.ConversionResolverNode; @@ -16,6 +18,8 @@ import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; import org.enso.interpreter.runtime.callable.function.Function; import org.enso.interpreter.runtime.data.ArrayRope; +import org.enso.interpreter.runtime.data.EnsoDate; +import org.enso.interpreter.runtime.data.EnsoDateTime; import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.*; @@ -63,6 +67,13 @@ public void setTailStatus(TailStatus tailStatus) { this.invokeFunctionNode.setTailStatus(tailStatus); } + /** + * @param self A target of the conversion. Should be a {@link Type} on which the {@code from} + * method is defined. If it is not a {@link Type}, + * "Invalid conversion target" panic is thrown. + * @param that Source of the conversion. Can be arbitrary object, including polyglot values. + * @param arguments Additional arguments passed to the conversion function. + */ public abstract Object execute( VirtualFrame frame, State state, @@ -196,6 +207,98 @@ Object doConvertText( } } + @Specialization(guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isDate(that)", + "!interop.isTime(that)" + }) + Object doConvertDate( + VirtualFrame frame, + State state, + UnresolvedConversion conversion, + Object self, + Object that, + Object[] arguments, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "10") TypesLibrary typesLib, + @Cached ConversionResolverNode conversionResolverNode) { + try { + LocalDate date = interop.asDate(that); + var ensoDate = new EnsoDate(date); + Function function = + conversionResolverNode.expectNonNull( + ensoDate, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().date(), + conversion); + arguments[0] = ensoDate; + return invokeFunctionNode.execute(function, frame, state, arguments); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException("Impossible, that is guaranteed to be a date."); + } + } + + @Specialization(guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isDate(that)", + "interop.isTime(that)", + "interop.isTimeZone(that)" + }) + Object doConvertZonedDateTime( + VirtualFrame frame, + State state, + UnresolvedConversion conversion, + Object self, + Object that, + Object[] arguments, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "10") TypesLibrary typesLib, + @Cached ConversionResolverNode conversionResolverNode) { + try { + var date = interop.asDate(that); + var time = interop.asTime(that); + var timeZone = interop.asTimeZone(that); + var ensoDateTime = new EnsoDateTime(ZonedDateTime.of(date, time, timeZone)); + Function function = + conversionResolverNode.expectNonNull( + ensoDateTime, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().dateTime(), + conversion); + arguments[0] = ensoDateTime; + return invokeFunctionNode.execute(function, frame, state, arguments); + } catch (UnsupportedMessageException e) { + throw new IllegalStateException("Impossible, that is guaranteed to be a zoned date time."); + } + } + + @Specialization(guards = { + "!typesLib.hasType(thatMap)", + "!typesLib.hasSpecialDispatch(thatMap)", + "interop.hasHashEntries(thatMap)", + }) + Object doConvertMap( + VirtualFrame frame, + State state, + UnresolvedConversion conversion, + Object self, + Object thatMap, + Object[] arguments, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "10") TypesLibrary typesLib, + @Cached ConversionResolverNode conversionResolverNode) { + Function function = + conversionResolverNode.expectNonNull( + thatMap, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().map(), + conversion); + arguments[0] = thatMap; + return invokeFunctionNode.execute(function, frame, state, arguments); + } + @Specialization( guards = { "!methods.hasType(that)", diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala index 7f2d46ad4fa2..66322d44fe0d 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala @@ -1,9 +1,17 @@ package org.enso.interpreter.test.semantic import org.enso.interpreter.test.{InterpreterContext, InterpreterTest} +import org.enso.polyglot.RuntimeOptions +import org.graalvm.polyglot.Context class ConversionMethodsTest extends InterpreterTest { - override def subject: String = "Methods" + override def subject: String = "Conversion methods" + + + override def contextModifiers: Option[Context#Builder => Context#Builder] = + Some(_ + .option(RuntimeOptions.LANGUAGE_HOME_OVERRIDE, "../../distribution/component") + ) override def specify(implicit interpreterContext: InterpreterContext @@ -25,5 +33,41 @@ class ConversionMethodsTest extends InterpreterTest { |""".stripMargin eval(code) shouldEqual 30 } + + "dispatch on polyglot map value" in { + val code = + """ + |polyglot java import java.util.Map as Java_Map + |import Standard.Base.Data.Map.Map + | + |type Foo + | Mk_Foo map + | + |Foo.from (that:Map) = Foo.Mk_Foo that + | + |main = + | m = Java_Map.of "A" 1 "B" 2 + | Foo.from m . map . size + |""".stripMargin + eval(code) shouldEqual 2 + } + + "dispatch on polyglot date value" in { + val code = + """ + |polyglot java import java.time.LocalDate as Java_Date + |import Standard.Base.Data.Time.Date.Date + | + |type Foo + | Mk_Foo date + | + |Foo.from (that:Date) = Foo.Mk_Foo that + | + |main = + | jdate = Java_Date.of 2023 2 2 + | Foo.from jdate . date . quarter + |""".stripMargin + eval(code) shouldEqual 1 + } } } From 37a37446aaf9d7fd46cf9eb7b38323ffa6dd4113 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 3 Feb 2023 13:59:28 +0100 Subject: [PATCH 36/60] Add tests for comparable conversion for polyglot objects --- test/Tests/src/Data/Map_Spec.enso | 5 +++++ test/Tests/src/Data/Time/Date_Spec.enso | 3 +++ test/Tests/src/Data/Time/Date_Time_Spec.enso | 3 +++ 3 files changed, 11 insertions(+) diff --git a/test/Tests/src/Data/Map_Spec.enso b/test/Tests/src/Data/Map_Spec.enso index 59d681952149..254123a365c0 100644 --- a/test/Tests/src/Data/Map_Spec.enso +++ b/test/Tests/src/Data/Map_Spec.enso @@ -74,6 +74,11 @@ spec = empty_map.is_empty . should_be_true non_empty.is_empty . should_be_false + Test.specify "should get default unordered comparator for polyglot maps" <| + Comparable.from (Map.empty) . should_equal Default_Unordered_Comparator + Comparable.from (js_empty_dict) . should_equal Default_Unordered_Comparator + Comparable.from (JavaMap.of "A" 1 "B" 2) . should_equal Default_Unordered_Comparator + Test.specify "should compare two hash maps" <| (Map.singleton "a" 1).should_equal (Map.singleton "a" 1) (Map.singleton "b" 2).should_not_equal (Map.singleton "a" 1) diff --git a/test/Tests/src/Data/Time/Date_Spec.enso b/test/Tests/src/Data/Time/Date_Spec.enso index 5943ab568199..5fa87af88cc7 100644 --- a/test/Tests/src/Data/Time/Date_Spec.enso +++ b/test/Tests/src/Data/Time/Date_Spec.enso @@ -122,6 +122,9 @@ spec_with name create_new_date parse_date = result -> Test.fail ("Unexpected result: " + result.to_text) + Test.specify "should get default ordered comparator for dates" <| + Comparable.from (create_new_date 2023 2 3) . should_equal Default_Ordered_Comparator + Test.specify "should be comparable" <| date_1 = parse_date "2021-01-02" date_2 = parse_date "2021-01-01" diff --git a/test/Tests/src/Data/Time/Date_Time_Spec.enso b/test/Tests/src/Data/Time/Date_Time_Spec.enso index d8edaa1997e2..dff748ab63de 100644 --- a/test/Tests/src/Data/Time/Date_Time_Spec.enso +++ b/test/Tests/src/Data/Time/Date_Time_Spec.enso @@ -314,6 +314,9 @@ spec_with name create_new_datetime parse_datetime nanoseconds_loss_in_precision= time . nanosecond . should_equal 0 time . zone . zone_id . should_equal Time_Zone.utc.zone_id + Test.specify "should get default ordered comparator for datetimes" <| + Comparable.from (create_new_datetime 2023 2 3 23 59) . should_equal Default_Ordered_Comparator + Test.specify "should be comparable" <| time_1 = parse_datetime "2021-01-01T00:30:12.7102[UTC]" time_2 = parse_datetime "2021-01-01T04:00:10.0+04:00" From 8637de04a6348cb6c96f43bebeedf9425e0a4f05 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 3 Feb 2023 19:26:55 +0100 Subject: [PATCH 37/60] Add some specializations to InvokeConversionNode --- .../node/callable/InvokeConversionNode.java | 91 ++++++++++++------- 1 file changed, 59 insertions(+), 32 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java index 9cbbaa62460e..59aaecde83f0 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java @@ -8,8 +8,6 @@ import com.oracle.truffle.api.library.CachedLibrary; import com.oracle.truffle.api.nodes.Node; import com.oracle.truffle.api.source.SourceSection; -import java.time.LocalDate; -import java.time.ZonedDateTime; import org.enso.interpreter.node.BaseNode; import org.enso.interpreter.node.callable.dispatch.InvokeFunctionNode; import org.enso.interpreter.node.callable.resolver.ConversionResolverNode; @@ -18,8 +16,6 @@ import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo; import org.enso.interpreter.runtime.callable.function.Function; import org.enso.interpreter.runtime.data.ArrayRope; -import org.enso.interpreter.runtime.data.EnsoDate; -import org.enso.interpreter.runtime.data.EnsoDateTime; import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.data.text.Text; import org.enso.interpreter.runtime.error.*; @@ -210,8 +206,8 @@ Object doConvertText( @Specialization(guards = { "!typesLib.hasType(that)", "!typesLib.hasSpecialDispatch(that)", + "!interop.isTime(that)", "interop.isDate(that)", - "!interop.isTime(that)" }) Object doConvertDate( VirtualFrame frame, @@ -223,30 +219,47 @@ Object doConvertDate( @CachedLibrary(limit = "10") InteropLibrary interop, @CachedLibrary(limit = "10") TypesLibrary typesLib, @Cached ConversionResolverNode conversionResolverNode) { - try { - LocalDate date = interop.asDate(that); - var ensoDate = new EnsoDate(date); - Function function = + Function function = + conversionResolverNode.expectNonNull( + that, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().date(), + conversion); + return invokeFunctionNode.execute(function, frame, state, arguments); + } + + @Specialization(guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isTime(that)", + "!interop.isDate(that)", + }) + Object doConvertTime( + VirtualFrame frame, + State state, + UnresolvedConversion conversion, + Object self, + Object that, + Object[] arguments, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "10") TypesLibrary typesLib, + @Cached ConversionResolverNode conversionResolverNode) { + Function function = conversionResolverNode.expectNonNull( - ensoDate, + that, extractConstructor(self), - EnsoContext.get(this).getBuiltins().date(), + EnsoContext.get(this).getBuiltins().timeOfDay(), conversion); - arguments[0] = ensoDate; - return invokeFunctionNode.execute(function, frame, state, arguments); - } catch (UnsupportedMessageException e) { - throw new IllegalStateException("Impossible, that is guaranteed to be a date."); - } + return invokeFunctionNode.execute(function, frame, state, arguments); } @Specialization(guards = { "!typesLib.hasType(that)", "!typesLib.hasSpecialDispatch(that)", - "interop.isDate(that)", "interop.isTime(that)", - "interop.isTimeZone(that)" + "interop.isDate(that)", }) - Object doConvertZonedDateTime( + Object doConvertDateTime( VirtualFrame frame, State state, UnresolvedConversion conversion, @@ -256,22 +269,37 @@ Object doConvertZonedDateTime( @CachedLibrary(limit = "10") InteropLibrary interop, @CachedLibrary(limit = "10") TypesLibrary typesLib, @Cached ConversionResolverNode conversionResolverNode) { - try { - var date = interop.asDate(that); - var time = interop.asTime(that); - var timeZone = interop.asTimeZone(that); - var ensoDateTime = new EnsoDateTime(ZonedDateTime.of(date, time, timeZone)); - Function function = + Function function = conversionResolverNode.expectNonNull( - ensoDateTime, + that, extractConstructor(self), EnsoContext.get(this).getBuiltins().dateTime(), conversion); - arguments[0] = ensoDateTime; - return invokeFunctionNode.execute(function, frame, state, arguments); - } catch (UnsupportedMessageException e) { - throw new IllegalStateException("Impossible, that is guaranteed to be a zoned date time."); - } + return invokeFunctionNode.execute(function, frame, state, arguments); + } + + @Specialization(guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isDuration(that)", + }) + Object doConvertDuration( + VirtualFrame frame, + State state, + UnresolvedConversion conversion, + Object self, + Object that, + Object[] arguments, + @CachedLibrary(limit = "10") InteropLibrary interop, + @CachedLibrary(limit = "10") TypesLibrary typesLib, + @Cached ConversionResolverNode conversionResolverNode) { + Function function = + conversionResolverNode.expectNonNull( + that, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().duration(), + conversion); + return invokeFunctionNode.execute(function, frame, state, arguments); } @Specialization(guards = { @@ -295,7 +323,6 @@ Object doConvertMap( extractConstructor(self), EnsoContext.get(this).getBuiltins().map(), conversion); - arguments[0] = thatMap; return invokeFunctionNode.execute(function, frame, state, arguments); } From 3bf87387f79faf0dfd00c819e2ba3758935d3efe Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 3 Feb 2023 19:28:30 +0100 Subject: [PATCH 38/60] Some test fixes --- .../node/expression/builtin/io/PrintlnNode.java | 2 +- .../test/semantic/ConversionMethodsTest.scala | 17 +++++++++++++++++ test/Tests/src/Data/Statistics_Spec.enso | 4 ++-- test/Tests/src/Data/Time/Date_Time_Spec.enso | 2 ++ test/Tests/src/Data/Vector_Spec.enso | 2 +- 5 files changed, 23 insertions(+), 4 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/io/PrintlnNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/io/PrintlnNode.java index 71eb22991523..f2f0eb2b798c 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/io/PrintlnNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/io/PrintlnNode.java @@ -43,7 +43,7 @@ Object doPrintText( try { print(ctx.getOut(), strings.asString(message)); } catch (UnsupportedMessageException e) { - throw new IllegalStateException("Impossible. self is guaranteed to be a string"); + throw new IllegalStateException("Impossible. `message` is guaranteed to be a string"); } return ctx.getNothing(); } diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala index 66322d44fe0d..003cfb2a2455 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala @@ -11,6 +11,7 @@ class ConversionMethodsTest extends InterpreterTest { override def contextModifiers: Option[Context#Builder => Context#Builder] = Some(_ .option(RuntimeOptions.LANGUAGE_HOME_OVERRIDE, "../../distribution/component") + .option(RuntimeOptions.DISABLE_IR_CACHES, "false") ) override def specify(implicit @@ -69,5 +70,21 @@ class ConversionMethodsTest extends InterpreterTest { |""".stripMargin eval(code) shouldEqual 1 } + + "dispatch on polyglot time value" in { + val code = + """ + |polyglot java import java.time.LocalTime as Java_Time + |import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day + | + |type Foo + | Mk_Foo foo + | + |Foo.from (that:Time_Of_Day) = Foo.Mk_Foo that + | + |main = Foo.from (Java_Time.of 23 59) . foo . minute + |""".stripMargin + eval(code) shouldEqual 59 + } } } diff --git a/test/Tests/src/Data/Statistics_Spec.enso b/test/Tests/src/Data/Statistics_Spec.enso index c1c759d5d8aa..ba8e0b727604 100644 --- a/test/Tests/src/Data/Statistics_Spec.enso +++ b/test/Tests/src/Data/Statistics_Spec.enso @@ -163,8 +163,8 @@ spec = Test.specify "should be able to do Count, Minimum and Maximum on custom type with custom ordered comparator" <| ord_set.compute . should_equal 3 - ord_set.compute Statistic.Minimum . should_equal (Ord.Value 10) - ord_set.compute Statistic.Maximum . should_equal (Ord.Value 2) + ord_set.compute Statistic.Minimum . should_equal (Ord.Value 2) + ord_set.compute Statistic.Maximum . should_equal (Ord.Value 10) Test.specify "should fail with Incomparable_Values on custom incomparable type" <| no_ord_set.compute . should_equal 3 diff --git a/test/Tests/src/Data/Time/Date_Time_Spec.enso b/test/Tests/src/Data/Time/Date_Time_Spec.enso index dff748ab63de..6232bfa77c2d 100644 --- a/test/Tests/src/Data/Time/Date_Time_Spec.enso +++ b/test/Tests/src/Data/Time/Date_Time_Spec.enso @@ -316,6 +316,8 @@ spec_with name create_new_datetime parse_datetime nanoseconds_loss_in_precision= Test.specify "should get default ordered comparator for datetimes" <| Comparable.from (create_new_datetime 2023 2 3 23 59) . should_equal Default_Ordered_Comparator + Comparable.from (parse_datetime "2021-01-01T00:30:12.7102[UTC]") . should_equal Default_Ordered_Comparator + Comparable.from (create_new_datetime 2022 10 31 2 30 55 1234) . should_equal Default_Ordered_Comparator Test.specify "should be comparable" <| time_1 = parse_datetime "2021-01-01T00:30:12.7102[UTC]" diff --git a/test/Tests/src/Data/Vector_Spec.enso b/test/Tests/src/Data/Vector_Spec.enso index f448e53c8dfd..4eb16ca0adc5 100644 --- a/test/Tests/src/Data/Vector_Spec.enso +++ b/test/Tests/src/Data/Vector_Spec.enso @@ -19,7 +19,7 @@ type T type T_Comparator is_ordered = True compare t1 t2 = Comparable.from t1.a . compare t1.a t2.a - hash t = Comparable.from t.a . has t.a + hash t = Comparable.from t.a . hash t.a type My_Error Value a From e06b12d03174cdc75d8a63f9eb211f02758e14cf Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Fri, 3 Feb 2023 19:28:54 +0100 Subject: [PATCH 39/60] Add Java zoned date time to ValuesGenerator --- .../test/java/org/enso/interpreter/test/ValuesGenerator.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java b/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java index 9e87dab411d6..70821fd32bdb 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java @@ -10,6 +10,7 @@ import java.time.Period; import java.time.ZoneId; import java.time.ZoneOffset; +import java.time.ZonedDateTime; import java.util.ArrayList; import java.util.Arrays; import java.util.EnumSet; @@ -325,6 +326,7 @@ public List timesAndDates() { if (languages.contains(Language.ENSO)) { collect.add(v(null, "import Standard.Base.Data.Time.Date.Date", "Date.now").type()); collect.add(v(null, "import Standard.Base.Data.Time.Date_Time.Date_Time", "Date_Time.now").type()); + collect.add(v(null, "import Standard.Base.Data.Time.Date_Time.Date_Time", "Date_Time.parse '2021-01-01T00:30:12.7102[UTC]'").type()); collect.add(v(null, "import Standard.Base.Data.Time.Time_Zone.Time_Zone", "Time_Zone.new").type()); collect.add(v(null, "import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day", "Time_Of_Day.now").type()); collect.add(v(null, "import Standard.Base.Data.Time.Duration.Duration", "Duration.new").type()); @@ -339,6 +341,7 @@ public List timesAndDates() { if (languages.contains(Language.JAVA)) { collect.add(ctx.asValue(LocalDate.of(2022, 12, 10))); collect.add(ctx.asValue(LocalTime.of(12, 35))); + collect.add(ctx.asValue(ZonedDateTime.of(2021, 1, 1, 0, 30, 12, 710200000, ZoneId.of("Z")))); } return collect; From 897118c7b888dccf4a85117d401bb06415f9c799 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Mon, 6 Feb 2023 19:41:39 +0100 Subject: [PATCH 40/60] Use Meta.is_same_object for equality of types in Any methods --- distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index b5aad7f3d3b7..8c9cee7c144f 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -111,11 +111,11 @@ type Any # host or polyglot values, so we just compare them with the default comparator. eq_self = Panic.catch No_Such_Conversion (Comparable.from self) _-> Default_Unordered_Comparator eq_that = Panic.catch No_Such_Conversion (Comparable.from that) _-> Default_Unordered_Comparator - if Comparable.equals_builtin eq_self Incomparable then False else + if Meta.is_same_object eq_self Incomparable then False else # Comparable.equals_builtin is a hack how to directly access EqualsNode from the # engine, so that we don't end up in an infinite recursion here (which would happen # if we would compare with `eq_self == eq_that`). - similar_type = Comparable.equals_builtin eq_self eq_that + similar_type = Meta.is_same_object eq_self eq_that if similar_type.not then False else hash_self = eq_self.hash self hash_that = eq_that.hash that @@ -434,8 +434,8 @@ assert_ordered_comparators : Any -> (Any -> Any) -> Any ! (Type_Error | Incompar assert_ordered_comparators this that ~action = comp_this = Comparable.from this comp_that = Comparable.from that - if (Comparable.equals_builtin comp_this comp_that).not then Error.throw (Type_Error.Error (Meta.type_of comp_this) comp_that "comp_that") else - if Comparable.equals_builtin comp_this Incomparable || comp_this.is_ordered.not then Error.throw Incomparable_Values else + if (Meta.is_same_object comp_this comp_that).not then Error.throw (Type_Error.Error (Meta.type_of comp_this) comp_that "comp_that") else + if Meta.is_same_object comp_this Incomparable || comp_this.is_ordered.not then Error.throw Incomparable_Values else action From 9c0ac8431e12c38b3ea74b11a70cb61fa0600ff7 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 13:08:04 +0100 Subject: [PATCH 41/60] Move ConversionMethodTests to runtime-polyglot --- .../test/ConversionMethodTests.java | 101 ++++++++++++++++++ .../org/enso/interpreter/test/TestBase.java | 41 ++++++- .../test/semantic/ConversionMethodsTest.scala | 90 ---------------- 3 files changed, 140 insertions(+), 92 deletions(-) create mode 100644 engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java delete mode 100644 engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala diff --git a/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java b/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java new file mode 100644 index 000000000000..7f213542dfd2 --- /dev/null +++ b/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java @@ -0,0 +1,101 @@ +package org.enso.interpreter.test; + +import static org.junit.Assert.assertEquals; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.Value; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +public class ConversionMethodTests extends TestBase { + private static Context ctx; + + @BeforeClass + public static void initCtx() { + ctx = createDefaultContext(); + } + + @AfterClass + public static void disposeCtx() { + ctx.close(); + } + + @Test + public void testSimpleConversion() { + String src = """ + type Foo + Mk_Foo foo + type Bar + Mk_Bar bar + type Baz + Mk_Baz baz + + Foo.from (that:Bar) = Foo.Mk_Foo that.bar + Foo.from (that:Baz) = Foo.Mk_Foo that.baz + + main = (Foo.from (Baz.Mk_Baz 10)).foo + (Foo.from (Bar.Mk_Bar 20)).foo + """; + Value res = evalModule(ctx, src); + assertEquals(30, res.asInt()); + } + + @Test + public void testDispatchOnHostMap() { + String src = """ + polyglot java import java.util.Map as Java_Map + import Standard.Base.Data.Map.Map + + type Foo + Mk_Foo data + + Foo.from (that:Map) = Foo.Mk_Foo that + + main = + jmap = Java_Map.of "A" 1 "B" 2 "C" 3 + Foo.from jmap . data . size + """; + Value res = evalModule(ctx, src); + assertEquals(3, res.asInt()); + } + + @Test + public void testDispatchOnJSMap() { + String src = """ + import Standard.Base.Data.Map.Map + + foreign js js_map = ''' + return {"A": 1, "B": 2}; + + type Foo + Mk_Foo data + + Foo.from (that:Map) = Foo.Mk_Foo that + + main = + Foo.from js_map . data . size + """; + Value res = evalModule(ctx, src); + assertEquals(2, res.asInt()); + } + + @Test + public void testDispatchOnJSDate() { + String src = """ + import Standard.Base.Data.Time.Date.Date + + foreign js js_date year month day hour minute second nanosecond = ''' + return new Date(year, month - 1, day, hour, minute, second, nanosecond / 1000000); + + type Foo + Mk_Foo data + + Foo.from (that:Date) = Foo.Mk_Foo that + + main = + Foo.from (js_date 2023 2 7 23 59 0 10) . data . day + """; + Value res = evalModule(ctx, src); + assertEquals(7, res.asInt()); + } +} diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java b/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java index 0d117b445f2d..327456df16d7 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java @@ -14,6 +14,7 @@ import java.util.Map; import java.util.concurrent.Callable; import org.enso.interpreter.EnsoLanguage; +import org.enso.polyglot.MethodNames.Module; import org.enso.polyglot.RuntimeOptions; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Language; @@ -24,7 +25,7 @@ public abstract class TestBase { protected static Context createDefaultContext() { var context = - Context.newBuilder("enso") + Context.newBuilder() .allowExperimentalOptions(true) .allowIO(true) .allowAllAccess(true) @@ -63,7 +64,9 @@ protected static Value executeInContext(Context ctx, Callable callable) /** * Unwraps the `receiver` field from the Value. This is a hack to allow us to test execute methods - * of artificially created ASTs, e.g., single nodes. + * of artificially created ASTs, e.g., single nodes. More specifically, only unwrapped values are + * eligible to be passed to node's execute methods, we cannot pass {@link Value} directly to the + * node's execute methods. * *

    Does something similar to what {@link * com.oracle.truffle.tck.DebuggerTester#getSourceImpl(Source)} does, but uses a different hack @@ -77,6 +80,40 @@ protected static Object unwrapValue(Context ctx, Value value) { return unwrapper.args[0]; } + /** + * Creates an Enso value from the given source. + * @param src One-line assignment into a variable + * @param imports Imports, may be empty. + */ + protected static Value createValue(Context ctx, String src, String imports) { + if (src.lines().count() > 1 || imports == null) { + throw new IllegalArgumentException("src should have one line, imports must not be null"); + } + var sb = new StringBuilder(); + sb.append(imports); + sb.append(System.lineSeparator()); + sb.append("my_var = ").append(src); + sb.append(System.lineSeparator()); + Value tmpModule = ctx.eval("enso", sb.toString()); + return tmpModule.invokeMember(Module.EVAL_EXPRESSION, "my_var"); + } + + protected static Value createValue(Context ctx, String src) { + return createValue(ctx, src, ""); + } + + /** + * Evaluates the given source as if it was in an unnamed module. + * @param src The source code of the module + * @return The value returned from the main method of the unnamed module. + */ + protected static Value evalModule(Context ctx, String src) { + Value module = ctx.eval(Source.create("enso", src)); + Value assocType = module.invokeMember(Module.GET_ASSOCIATED_TYPE); + Value mainMethod = module.invokeMember(Module.GET_METHOD, assocType, "main"); + return mainMethod.execute(); + } + /** * An artificial RootNode. Used for tests of nodes that need to be adopted. Just create this root * node inside a context, all the other nodes, and insert them via {@link diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala deleted file mode 100644 index 003cfb2a2455..000000000000 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConversionMethodsTest.scala +++ /dev/null @@ -1,90 +0,0 @@ -package org.enso.interpreter.test.semantic - -import org.enso.interpreter.test.{InterpreterContext, InterpreterTest} -import org.enso.polyglot.RuntimeOptions -import org.graalvm.polyglot.Context - -class ConversionMethodsTest extends InterpreterTest { - override def subject: String = "Conversion methods" - - - override def contextModifiers: Option[Context#Builder => Context#Builder] = - Some(_ - .option(RuntimeOptions.LANGUAGE_HOME_OVERRIDE, "../../distribution/component") - .option(RuntimeOptions.DISABLE_IR_CACHES, "false") - ) - - override def specify(implicit - interpreterContext: InterpreterContext - ): Unit = { - "be defined in the global scope and dispatched to" in { - val code = - """ - |type Foo - | Mk_Foo foo - |type Bar - | Mk_Bar bar - |type Baz - | Mk_Baz baz - | - |Foo.from (that:Bar) = Foo.Mk_Foo that.bar - |Foo.from (that:Baz) = Foo.Mk_Foo that.baz - | - |main = (Foo.from (Baz.Mk_Baz 10)).foo + (Foo.from (Bar.Mk_Bar 20)).foo - |""".stripMargin - eval(code) shouldEqual 30 - } - - "dispatch on polyglot map value" in { - val code = - """ - |polyglot java import java.util.Map as Java_Map - |import Standard.Base.Data.Map.Map - | - |type Foo - | Mk_Foo map - | - |Foo.from (that:Map) = Foo.Mk_Foo that - | - |main = - | m = Java_Map.of "A" 1 "B" 2 - | Foo.from m . map . size - |""".stripMargin - eval(code) shouldEqual 2 - } - - "dispatch on polyglot date value" in { - val code = - """ - |polyglot java import java.time.LocalDate as Java_Date - |import Standard.Base.Data.Time.Date.Date - | - |type Foo - | Mk_Foo date - | - |Foo.from (that:Date) = Foo.Mk_Foo that - | - |main = - | jdate = Java_Date.of 2023 2 2 - | Foo.from jdate . date . quarter - |""".stripMargin - eval(code) shouldEqual 1 - } - - "dispatch on polyglot time value" in { - val code = - """ - |polyglot java import java.time.LocalTime as Java_Time - |import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day - | - |type Foo - | Mk_Foo foo - | - |Foo.from (that:Time_Of_Day) = Foo.Mk_Foo that - | - |main = Foo.from (Java_Time.of 23 59) . foo . minute - |""".stripMargin - eval(code) shouldEqual 59 - } - } -} From ed01a1b01745edeaac016accbcc247bd306e1936 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:50:23 +0100 Subject: [PATCH 42/60] Add Any.== to micro-distribution --- .../enso/interpreter/test/semantic/CodeLocationsTest.scala | 5 +++-- .../enso/interpreter/test/semantic/ConstructorsTest.scala | 2 ++ .../scala/org/enso/interpreter/test/semantic/EvalTest.scala | 2 ++ .../org/enso/interpreter/test/semantic/GlobalScopeTest.scala | 1 + .../org/enso/interpreter/test/semantic/GroupingTest.scala | 2 ++ .../interpreter/test/semantic/LambdaShorthandArgsTest.scala | 1 + .../org/enso/interpreter/test/semantic/LambdaTest.scala | 3 +++ .../enso/interpreter/test/semantic/NamedArgumentsTest.scala | 5 +++++ .../interpreter/test/semantic/SuspendedArgumentsTest.scala | 4 ++++ .../src/test/scala/org/enso/std/test/BooleanTest.scala | 1 + .../src/test/scala/org/enso/std/test/NumberTest.scala | 3 +++ .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 5 +++++ 12 files changed, 32 insertions(+), 2 deletions(-) diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/CodeLocationsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/CodeLocationsTest.scala index 121967c44d07..f753eef70eb6 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/CodeLocationsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/CodeLocationsTest.scala @@ -55,11 +55,12 @@ class CodeLocationsTest extends InterpreterTest { withLocationsInstrumenter { instrumenter => val code = """import Standard.Base.Data.List.List + |import Standard.Base.Any.Any | |main = (2-2 == 0).if_then_else (List.Cons 5 6) 0 |""".stripMargin.linesIterator.mkString("\n") - instrumenter.assertNodeExists(44, 41, classOf[ApplicationNode]) - instrumenter.assertNodeExists(69, 13, classOf[ApplicationNode]) + instrumenter.assertNodeExists(73, 41, classOf[ApplicationNode]) + instrumenter.assertNodeExists(98, 13, classOf[ApplicationNode]) eval(code) () } diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConstructorsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConstructorsTest.scala index 1514c84a2bb7..6b88aca14363 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConstructorsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/ConstructorsTest.scala @@ -29,6 +29,7 @@ class ConstructorsTest extends InterpreterTest { "work with recursion" in { val testCode = """import Standard.Base.Data.List.List + |import Standard.Base.Any.Any | |main = | genList = i -> if i == 0 then List.Nil else List.Cons i (genList (i - 1)) @@ -86,6 +87,7 @@ class ConstructorsTest extends InterpreterTest { "be usable in code, with arbitrary definition order" in { val testCode = """import Standard.Base.Nothing.Nothing + |import Standard.Base.Any.Any | |type C2 | Cons2 a b diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/EvalTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/EvalTest.scala index bb8361d37a70..07a568a09505 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/EvalTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/EvalTest.scala @@ -70,6 +70,7 @@ class EvalTest extends InterpreterTest { "work in a recursive setting" in { val code = """import Standard.Base.Runtime.Debug + |import Standard.Base.Any.Any | |main = | fn = sumTo -> @@ -84,6 +85,7 @@ class EvalTest extends InterpreterTest { "work inside a thunk passed to another function" in { val code = """import Standard.Base.Runtime.Debug + |import Standard.Base.Any.Any | |main = | fn = sumTo -> diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GlobalScopeTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GlobalScopeTest.scala index 29f1942cdd8a..2cb48a892e42 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GlobalScopeTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GlobalScopeTest.scala @@ -59,6 +59,7 @@ class GlobalScopeTest extends InterpreterTest { "be able to mutually recurse in the global scope" in { val code = """import Standard.Base.Nothing + |import Standard.Base.Any.Any | |Nothing.decrementCall = number -> | res = number - 1 diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GroupingTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GroupingTest.scala index 84dc4c14f966..d8a05feadef4 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GroupingTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/GroupingTest.scala @@ -32,6 +32,8 @@ class GroupingTest extends InterpreterTest { "work with forced terms and lazy arguments" in { val code = """ + |import Standard.Base.Any.Any + | |main = | ifTest = c -> (~ifT) -> ~ifF -> if c == 0 then ifT else ifF | sum = c -> acc -> ifTest c acc (@Tail_Call sum c-1 acc+c) diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaShorthandArgsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaShorthandArgsTest.scala index 14f7bf08cbec..602acfd627bd 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaShorthandArgsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaShorthandArgsTest.scala @@ -51,6 +51,7 @@ class LambdaShorthandArgsTest extends InterpreterTest { "work with mixfix functions" in { val code = """from Standard.Base.Data.Numbers import all + |import Standard.Base.Any.Any | |Number.if_then_else self = ~t -> ~f -> if self == 0 then t else f | diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaTest.scala index fede714582c6..674a832657b6 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/LambdaTest.scala @@ -43,6 +43,7 @@ class LambdaTest extends InterpreterTest { "work with recursion" in { val code = """ + |import Standard.Base.Any.Any |main = | sumTo = x -> if x == 0 then 0 else x + (sumTo (x-1)) | sumTo 10 @@ -105,6 +106,7 @@ class LambdaTest extends InterpreterTest { "recurse with closing over lexical scope" in { val code = """ + |import Standard.Base.Any.Any |main = | summator = current -> | if current == 0 then 0 else (x -> summator (current - 1)) 0 @@ -135,6 +137,7 @@ class LambdaTest extends InterpreterTest { "call fully saturated lambdas returned with TCO" in { val code = """from Standard.Base.Data.Numbers import Number + |import Standard.Base.Any.Any | |Number.if_then_else self = ~t -> ~f -> if self == 0 then t else f | diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/NamedArgumentsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/NamedArgumentsTest.scala index 7adf2215d844..315f37a34c8d 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/NamedArgumentsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/NamedArgumentsTest.scala @@ -128,6 +128,7 @@ class NamedArgumentsTest extends InterpreterTest { "work in a recursive context" in { val code = """import Standard.Base.Nothing + |import Standard.Base.Any.Any | |Nothing.summer = sumTo -> | summator = (acc = 0) -> current -> @@ -194,6 +195,8 @@ class NamedArgumentsTest extends InterpreterTest { "be usable with constructors" in { val code = """ + |import Standard.Base.Any.Any + | |type C2 | Cons2 head rest |type Nil2 @@ -214,6 +217,8 @@ class NamedArgumentsTest extends InterpreterTest { "be usable and overridable in constructors" in { val code = """ + |import Standard.Base.Any.Any + | |type Nil2 |type C2 | Cons2 head (rest = Nil2) diff --git a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/SuspendedArgumentsTest.scala b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/SuspendedArgumentsTest.scala index 8574abee620b..aaef667c24e5 100644 --- a/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/SuspendedArgumentsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/SuspendedArgumentsTest.scala @@ -24,6 +24,7 @@ class SuspendedArgumentsTest extends InterpreterTest { "not get executed upfront" in { val code = """import Standard.Base.IO + |import Standard.Base.Any.Any | |main = | foo = i -> ~x -> ~y -> if i == 0 then x else y @@ -36,6 +37,8 @@ class SuspendedArgumentsTest extends InterpreterTest { "work well with tail recursion" in { val code = """ + |import Standard.Base.Any.Any + | |main = | ifTest = c -> ~ifT -> ~ifF -> if c == 0 then ifT else ifF | sum = c -> acc -> ifTest c acc (@Tail_Call sum c-1 acc+c) @@ -78,6 +81,7 @@ class SuspendedArgumentsTest extends InterpreterTest { "work properly with oversaturated arguments" in { val code = """import Standard.Base.IO + |import Standard.Base.Any.Any | |main = | ifTest = c -> ~ifT -> ~ifF -> if c == 0 then ifT else ifF diff --git a/engine/runtime/src/test/scala/org/enso/std/test/BooleanTest.scala b/engine/runtime/src/test/scala/org/enso/std/test/BooleanTest.scala index aa5f3cd5ec12..251edd6e86e3 100644 --- a/engine/runtime/src/test/scala/org/enso/std/test/BooleanTest.scala +++ b/engine/runtime/src/test/scala/org/enso/std/test/BooleanTest.scala @@ -26,6 +26,7 @@ class BooleanTest extends InterpreterTest { val code = """from Standard.Base.Data.Boolean import all |import Standard.Base.IO + |import Standard.Base.Any.Any | |Boolean.isTrue self = self | diff --git a/engine/runtime/src/test/scala/org/enso/std/test/NumberTest.scala b/engine/runtime/src/test/scala/org/enso/std/test/NumberTest.scala index e73ea1dedb63..bbc4ed58868e 100644 --- a/engine/runtime/src/test/scala/org/enso/std/test/NumberTest.scala +++ b/engine/runtime/src/test/scala/org/enso/std/test/NumberTest.scala @@ -11,6 +11,7 @@ class NumberTest extends InterpreterTest { "support equality comparisons" in { val code = """import Standard.Base.IO + |import Standard.Base.Any.Any | |main = | IO.println 7==5 @@ -23,6 +24,8 @@ class NumberTest extends InterpreterTest { "support a recursive sum case" in { val code = """ + |import Standard.Base.Any.Any + | |main = sumTo -> | summator = acc -> current -> | if current == 0 then acc else summator acc+current current-1 diff --git a/test/micro-distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/test/micro-distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index ad1a79197e46..93f4db8155c4 100644 --- a/test/micro-distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/test/micro-distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -3,3 +3,8 @@ type Any catch_primitive handler = @Builtin_Method "Any.catch_primitive" to_text self = @Builtin_Method "Any.to_text" to_display_text self = @Builtin_Method "Any.to_display_text" + # Access EqualsNode directly + == self other = Comparable.equals_builtin self other + +@Builtin_Type +type Comparable From d470317ecdb2564c65db21ad4d5453b152b52164 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:54:31 +0100 Subject: [PATCH 43/60] Fix ParseStdLibTests --- .../lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso | 2 +- .../lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso index 8fad8637baba..da9c4e59c6e3 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Duration.enso @@ -295,4 +295,4 @@ type Duration is_empty : Boolean is_empty self = self.to_vector . all (==0) -Comparable.from(_:Duration) = Default_Ordered_Comparator +Comparable.from (_:Duration) = Default_Ordered_Comparator diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso index 4b7c77f8384f..9a1374932a11 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Time/Time_Of_Day.enso @@ -358,4 +358,4 @@ type Time_Of_Day format : Text -> Text format self pattern = @Builtin_Method "Time_Of_Day.format" -Comparable.from(_:Time_Of_Day) = Default_Ordered_Comparator +Comparable.from (_:Time_Of_Day) = Default_Ordered_Comparator From 6344a8c84acbdf0dda518344478ae899252be0a1 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:55:09 +0100 Subject: [PATCH 44/60] Add JS_Object_Comparator --- .../Base/0.0.0-dev/src/Data/Json.enso | 38 ++++++++++++------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso index 3acf4b694cb6..89a29e3ea037 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso @@ -19,6 +19,9 @@ import project.Nothing.Nothing import project.Panic.Panic import project.Warning.Warning +# We need to import conversion methods from Ordering, therefore, we import all +from project.Data.Ordering import all + from project.Data.Boolean import Boolean, True, False ## Methods for serializing from and to JSON. @@ -168,19 +171,6 @@ type JS_Object to_json : Text to_json self = self.to_text - ## Checks if this JS_Object is equal to another JS_Object. - - Arguments: - - that: The map to compare `self` to. - == : JS_Object -> Boolean - == self that = case that of - _ : JS_Object -> - self_keys = self.field_names - that_keys = that.field_names - self_keys.length == that_keys.length && self_keys.all key-> - (self.get key == that.at key).catch No_Such_Key.Error _->False - _ -> False - ## UNSTABLE Transform the vector into text for displaying as part of its default @@ -189,6 +179,28 @@ type JS_Object to_default_visualization_data self = render self +type JS_Object_Comparator + is_ordered : Boolean + is_ordered = False + + equals : JS_Object -> JS_Object -> Boolean + equals obj1 obj2 = + obj1_keys = obj1.field_names + obj2_keys = obj2.field_names + obj1_keys.length == obj2_keys.length && obj1_keys.all key-> + (obj1.get key == obj2.at key).catch No_Such_Key.Error _->False + + hash : JS_Object -> Integer + hash obj = + values_hashes = obj.field_names.map field_name-> + val = obj.get field_name + Comparable.from val . hash val + # Return sum, as we don't care about ordering of field names + values_hashes.fold 0 (+) + +Comparable.from (_:JS_Object) = JS_Object_Comparator + + ## PRIVATE Render the JS_Object to Text with truncated depth. render object depth=0 max_depth=5 max_length=100 = case object of From 6dbbf670cef6acfe74a7eb51b2fc38b571655939 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:55:59 +0100 Subject: [PATCH 45/60] Fix some std lib tests --- .../Base/0.0.0-dev/src/Data/Ordering/Comparator.enso | 10 ++++++---- .../enso/interpreter/test/ConversionMethodTests.java | 11 +++++++---- test/Tests/src/Data/Ordering/Comparator_Spec.enso | 3 ++- test/Tests/src/Semantic/Equals_Spec.enso | 6 ++---- 4 files changed, 17 insertions(+), 13 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Comparator.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Comparator.enso index 4dc584aaabd0..db8a07af7b87 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Comparator.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering/Comparator.enso @@ -1,6 +1,7 @@ import project.Any.Any import project.Data.Ordering.Natural_Order import project.Data.Ordering.Ordering +import project.Data.Ordering.Comparable import project.Data.Text.Case_Sensitivity.Case_Sensitivity import project.Data.Text.Text_Ordering.Text_Ordering import project.Error.Incomparable_Values.Incomparable_Values @@ -11,18 +12,19 @@ from project.Data.Boolean import True, False polyglot java import org.enso.base.ObjectComparator ## ADVANCED - Creates a Java Comparator object which can call Enso compare_to + Creates a Java Comparator object which can call back to Enso for comparison + of non-primitive types. Arguments: - custom_comparator: - If `Nothing` will get a singleton instance for `.compare_to`. - Otherwise can support a custom fallback comparator. + If `Nothing` will get an ordered comparator from each element. + Otherwise can support a custom fallback compare function. new : Nothing | (Any -> Any -> Ordering) -> ObjectComparator new custom_comparator=Nothing = comparator_to_java cmp x y = Incomparable_Values.handle_errors (cmp x y . to_sign) case custom_comparator of - Nothing -> ObjectComparator.getInstance (comparator_to_java .compare_to) + Nothing -> ObjectComparator.getInstance (comparator_to_java Ordering.compare) _ -> ObjectComparator.new (comparator_to_java custom_comparator) ## ADVANCED diff --git a/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java b/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java index 7f213542dfd2..8a1f1deb4624 100644 --- a/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java +++ b/engine/runtime-with-polyglot/src/test/java/org/enso/interpreter/test/ConversionMethodTests.java @@ -65,7 +65,10 @@ public void testDispatchOnJSMap() { import Standard.Base.Data.Map.Map foreign js js_map = ''' - return {"A": 1, "B": 2}; + let m = new Map() + m.set("A", 1) + m.set("B", 2) + return m type Foo Mk_Foo data @@ -80,9 +83,9 @@ public void testDispatchOnJSMap() { } @Test - public void testDispatchOnJSDate() { + public void testDispatchOnJSDateTime() { String src = """ - import Standard.Base.Data.Time.Date.Date + import Standard.Base.Data.Time.Date_Time.Date_Time foreign js js_date year month day hour minute second nanosecond = ''' return new Date(year, month - 1, day, hour, minute, second, nanosecond / 1000000); @@ -90,7 +93,7 @@ public void testDispatchOnJSDate() { type Foo Mk_Foo data - Foo.from (that:Date) = Foo.Mk_Foo that + Foo.from (that:Date_Time) = Foo.Mk_Foo that main = Foo.from (js_date 2023 2 7 23 59 0 10) . data . day diff --git a/test/Tests/src/Data/Ordering/Comparator_Spec.enso b/test/Tests/src/Data/Ordering/Comparator_Spec.enso index e4153f4c63fd..726bbe52ae87 100644 --- a/test/Tests/src/Data/Ordering/Comparator_Spec.enso +++ b/test/Tests/src/Data/Ordering/Comparator_Spec.enso @@ -13,9 +13,10 @@ import Standard.Test.Extensions type Ord Value number +# The comparison is reverted, i.e., `x < y` gives result for `y.number < x.number`. type Ord_Comparator is_ordered = True - compare x y = (Comparable.from x.number) . compare x.number y.number + compare x y = (Comparable.from y.number) . compare y.number x.number hash x = (Comparable.from x.number) . hash x.number Comparable.from (_:Ord) = Ord_Comparator diff --git a/test/Tests/src/Semantic/Equals_Spec.enso b/test/Tests/src/Semantic/Equals_Spec.enso index d54f9ac99381..18ed63527168 100644 --- a/test/Tests/src/Semantic/Equals_Spec.enso +++ b/test/Tests/src/Semantic/Equals_Spec.enso @@ -31,7 +31,7 @@ type Child_Comparator equals child1 child2 = child1.number % 100 == child2.number % 100 hash child = comp = Comparable.from child.number - (comp.hash child.number) % 100 + comp.hash (child.number % 100) Comparable.from (_:Child) = Child_Comparator @@ -161,12 +161,10 @@ spec = four_field = FourFieldType.Value 1 2 3 4 (rect == four_field).should_be_false - Test.specify "should handle `==` on types" pending="Blocked by https://www.pivotaltracker.com/story/show/184092284" <| + Test.specify "should handle `==` on types" <| (Child == Child).should_be_true (Child == Point).should_be_false (Point == Child).should_be_false - (JavaPath == Child).should_be_false - (Child == JavaPath).should_be_false (Boolean == Any).should_be_false (Any == Boolean).should_be_false (Any == Any).should_be_true From bf069163631413508a3a1a968c6feda043e4dc73 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:56:43 +0100 Subject: [PATCH 46/60] Make nodes in tests static --- .../org/enso/interpreter/test/EqualsTest.java | 63 +++++++++++++++++-- .../enso/interpreter/test/HashCodeTest.java | 10 +-- 2 files changed, 60 insertions(+), 13 deletions(-) diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java index b27d4f60dcca..337874ec76ce 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java @@ -1,7 +1,13 @@ package org.enso.interpreter.test; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; @@ -11,6 +17,7 @@ import org.junit.AfterClass; import org.junit.Before; import org.junit.BeforeClass; +import org.junit.Test; import org.junit.experimental.theories.DataPoints; import org.junit.experimental.theories.Theories; import org.junit.experimental.theories.Theory; @@ -19,17 +26,13 @@ @RunWith(Theories.class) public class EqualsTest extends TestBase { private static Context context; - private EqualsNode equalsNode; - private TestRootNode testRootNode; + private static EqualsNode equalsNode; + private static TestRootNode testRootNode; @BeforeClass public static void initContextAndData() { context = createDefaultContext(); unwrappedValues = fetchAllUnwrappedValues(); - } - - @Before - public void initNodes() { executeInContext( context, () -> { @@ -101,4 +104,52 @@ public void equalsOperatorShouldBeConsistent(Object value) { return null; }); } + + /** + * Test for some specific values, for which we know that they are equal. + */ + @Test + public void testDateEquality() { + Object ensoDate = unwrapValue(context, createValue(context, "(Date.new 1999 3 23)", "import Standard.Base.Data.Time.Date.Date")); + Object javaDate = unwrapValue(context, context.asValue(LocalDate.of(1999, 3, 23))); + executeInContext(context, + () -> { + assertTrue(equalsNode.execute(ensoDate, javaDate)); + return null; + }); + } + + @Test + public void testTimeEquality() { + Object ensoTime = unwrapValue(context, createValue(context, "Time_Of_Day.new 23 59", "import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day")); + Object javaDate = unwrapValue(context, context.asValue(LocalTime.of(23, 59))); + executeInContext(context, + () -> { + assertTrue(equalsNode.execute(ensoTime, javaDate)); + return null; + }); + } + + @Test + public void testDateTimeEquality() { + Object ensoDateTime = unwrapValue(context, createValue(context, "(Date_Time.new 1999 3 1 23 59)", "import Standard.Base.Data.Time.Date_Time.Date_Time")); + Object javaDateTime = unwrapValue(context, context.asValue( + ZonedDateTime.of(LocalDate.of(1999, 3, 1), LocalTime.of(23, 59), ZoneId.systemDefault()) + )); + executeInContext(context, + () -> { + assertTrue(equalsNode.execute(ensoDateTime, javaDateTime)); + return null; + }); + } + + @Test + public void testVectorsEquality() { + Object ensoVector = unwrapValue(context, createValue(context, "[1,2,3]", "from Standard.Base.import all")); + Object javaVector = unwrapValue(context, context.asValue(List.of(1, 2, 3))); + executeInContext(context, () -> { + assertTrue(equalsNode.execute(ensoVector, javaVector)); + return null; + }); + } } diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java index f776b2e1bdda..09ed164afad6 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java @@ -24,19 +24,15 @@ public class HashCodeTest extends TestBase { private static Context context; private static final InteropLibrary interop = InteropLibrary.getUncached(); - private HashCodeNode hashCodeNode; - private EqualsNode equalsNode; - private TestRootNode testRootNode; + private static HashCodeNode hashCodeNode; + private static EqualsNode equalsNode; + private static TestRootNode testRootNode; @BeforeClass public static void initContextAndData() { context = createDefaultContext(); // Initialize datapoints here, to make sure that it is initialized just once. unwrappedValues = fetchAllUnwrappedValues(); - } - - @Before - public void initNodes() { executeInContext(context, () -> { hashCodeNode = HashCodeNode.build(); equalsNode = EqualsNode.build(); From 90212ba1a37697d163ca813848a06b05fbc827d8 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:56:55 +0100 Subject: [PATCH 47/60] Add some date values to ValuesGenerator --- .../test/java/org/enso/interpreter/test/ValuesGenerator.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java b/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java index 70821fd32bdb..e8ca263b8ad3 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/ValuesGenerator.java @@ -325,9 +325,9 @@ public List timesAndDates() { var collect = new ArrayList(); if (languages.contains(Language.ENSO)) { collect.add(v(null, "import Standard.Base.Data.Time.Date.Date", "Date.now").type()); + collect.add(v(null, "import Standard.Base.Data.Time.Date.Date", "Date.new 1999 3 23").type()); collect.add(v(null, "import Standard.Base.Data.Time.Date_Time.Date_Time", "Date_Time.now").type()); collect.add(v(null, "import Standard.Base.Data.Time.Date_Time.Date_Time", "Date_Time.parse '2021-01-01T00:30:12.7102[UTC]'").type()); - collect.add(v(null, "import Standard.Base.Data.Time.Time_Zone.Time_Zone", "Time_Zone.new").type()); collect.add(v(null, "import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day", "Time_Of_Day.now").type()); collect.add(v(null, "import Standard.Base.Data.Time.Duration.Duration", "Duration.new").type()); for (var v : collect) { @@ -340,6 +340,7 @@ public List timesAndDates() { if (languages.contains(Language.JAVA)) { collect.add(ctx.asValue(LocalDate.of(2022, 12, 10))); + collect.add(ctx.asValue(LocalDate.of(1999, 3, 23))); collect.add(ctx.asValue(LocalTime.of(12, 35))); collect.add(ctx.asValue(ZonedDateTime.of(2021, 1, 1, 0, 30, 12, 710200000, ZoneId.of("Z")))); } From 67267e4ac610aa35d3c0b4cb85f04cf3409739ad Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:57:54 +0100 Subject: [PATCH 48/60] Fix some specs in EqualsNode and HashCodeNode --- .../expression/builtin/meta/EqualsNode.java | 192 +++++++++--------- .../expression/builtin/meta/HashCodeNode.java | 43 ++-- 2 files changed, 122 insertions(+), 113 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java index da43f8ceb385..c3be97e8d4b6 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/EqualsNode.java @@ -82,6 +82,11 @@ boolean equalsBoolean(boolean self, boolean other) { return self == other; } + @Specialization + boolean equalsBytes(byte self, byte other) { + return self == other; + } + @Specialization boolean equalsLong(long self, long other) { return self == other; @@ -182,9 +187,13 @@ boolean equalsFiles(EnsoFile selfFile, EnsoFile otherFile, * to make that specialization disjunctive. So we rather specialize directly for * {@link Type types}. */ - @Specialization + @Specialization(guards = { + "typesLib.hasType(selfType)", + "typesLib.hasType(otherType)" + }) boolean equalsTypes(Type selfType, Type otherType, - @Cached EqualsNode equalsNode) { + @Cached EqualsNode equalsNode, + @CachedLibrary(limit = "5") TypesLibrary typesLib) { return equalsNode.execute( selfType.getQualifiedName().toString(), otherType.getQualifiedName().toString() @@ -240,38 +249,6 @@ boolean equalsNull( return selfInterop.isNull(selfNull) && otherInterop.isNull(otherNull); } - @Specialization(guards = { - "isHostObject(selfHostObject)", - "isHostObject(otherHostObject)" - }) - boolean equalsHostObjects( - Object selfHostObject, Object otherHostObject, - @CachedLibrary(limit = "5") InteropLibrary interop - ) { - try { - return interop.asBoolean( - interop.invokeMember(selfHostObject, "equals", otherHostObject) - ); - } catch (UnsupportedMessageException | ArityException | UnknownIdentifierException | - UnsupportedTypeException e) { - throw new IllegalStateException(e); - } - } - - - // HostFunction is identified by a qualified name, it is not a lambda. - // It has well-defined equality based on the qualified name. - @Specialization(guards = { - "isHostFunction(selfHostFunc)", - "isHostFunction(otherHostFunc)" - }) - boolean equalsHostFunctions(Object selfHostFunc, Object otherHostFunc, - @CachedLibrary(limit = "5") InteropLibrary interop, - @Cached EqualsNode equalsNode) { - Object selfFuncStrRepr = interop.toDisplayString(selfHostFunc); - Object otherFuncStrRepr = interop.toDisplayString(otherHostFunc); - return equalsNode.execute(selfFuncStrRepr, otherFuncStrRepr); - } @Specialization(guards = { "selfInterop.isBoolean(selfBoolean)", @@ -333,7 +310,8 @@ boolean equalsZonedDateTimes(Object selfZonedDateTime, Object otherZonedDateTime otherInterop.asTime(otherZonedDateTime), otherInterop.asTimeZone(otherZonedDateTime) ); - return self.isEqual(other); + // We cannot use self.isEqual(other), because that does not include timezone. + return self.compareTo(other) == 0; } catch (UnsupportedMessageException e) { throw new IllegalStateException(e); } @@ -450,7 +428,9 @@ boolean equalsStrings(Object selfString, Object otherString, @Specialization(guards = { "selfInterop.hasArrayElements(selfArray)", - "otherInterop.hasArrayElements(otherArray)" + "otherInterop.hasArrayElements(otherArray)", + "!selfInterop.hasHashEntries(selfArray)", + "!otherInterop.hasHashEntries(otherArray)", }, limit = "3") boolean equalsArrays(Object selfArray, Object otherArray, @CachedLibrary("selfArray") InteropLibrary selfInterop, @@ -487,7 +467,9 @@ boolean equalsArrays(Object selfArray, Object otherArray, @Specialization(guards = { "selfInterop.hasHashEntries(selfHashMap)", - "otherInterop.hasHashEntries(otherHashMap)" + "otherInterop.hasHashEntries(otherHashMap)", + "!selfInterop.hasArrayElements(selfHashMap)", + "!otherInterop.hasArrayElements(otherHashMap)" }, limit = "3") boolean equalsHashMaps(Object selfHashMap, Object otherHashMap, @CachedLibrary("selfHashMap") InteropLibrary selfInterop, @@ -525,13 +507,19 @@ boolean equalsHashMaps(Object selfHashMap, Object otherHashMap, @Specialization(guards = { "!isAtom(selfObject)", "!isAtom(otherObject)", + "!isHostObject(selfObject)", + "!isHostObject(otherObject)", + "interop.hasMembers(selfObject)", + "interop.hasMembers(otherObject)", + "!interop.isDate(selfObject)", + "!interop.isDate(otherObject)", + "!interop.isTime(selfObject)", + "!interop.isTime(otherObject)", // Objects with types are handled in `equalsTypes` specialization, so we have to // negate the guards of that specialization here - to make the specializations // disjunctive. "!typesLib.hasType(selfObject)", "!typesLib.hasType(otherObject)", - "interop.hasMembers(selfObject)", - "interop.hasMembers(otherObject)", }) boolean equalsInteropObjectWithMembers(Object selfObject, Object otherObject, @CachedLibrary(limit = "10") InteropLibrary interop, @@ -663,6 +651,73 @@ private static boolean equalsAtomsFieldsUncached(Object[] selfFields, Object[] o return true; } + @Specialization(guards = { + "isHostObject(selfHostObject)", + "isHostObject(otherHostObject)" + }) + boolean equalsHostObjects( + Object selfHostObject, Object otherHostObject, + @CachedLibrary(limit = "5") InteropLibrary interop + ) { + try { + return interop.asBoolean( + interop.invokeMember(selfHostObject, "equals", otherHostObject) + ); + } catch (UnsupportedMessageException | ArityException | UnknownIdentifierException | + UnsupportedTypeException e) { + throw new IllegalStateException(e); + } + } + + // HostFunction is identified by a qualified name, it is not a lambda. + // It has well-defined equality based on the qualified name. + @Specialization(guards = { + "isHostFunction(selfHostFunc)", + "isHostFunction(otherHostFunc)" + }) + boolean equalsHostFunctions(Object selfHostFunc, Object otherHostFunc, + @CachedLibrary(limit = "5") InteropLibrary interop, + @Cached EqualsNode equalsNode) { + Object selfFuncStrRepr = interop.toDisplayString(selfHostFunc); + Object otherFuncStrRepr = interop.toDisplayString(otherHostFunc); + return equalsNode.execute(selfFuncStrRepr, otherFuncStrRepr); + } + + @Fallback + @TruffleBoundary + boolean equalsGeneric(Object left, Object right, + @CachedLibrary(limit = "5") InteropLibrary interop, + @CachedLibrary(limit = "5") TypesLibrary typesLib) { + return left == right + || interop.isIdentical(left, right, interop) + || left.equals(right) + || (isNullOrNothing(left, typesLib, interop) && isNullOrNothing(right, typesLib, interop)); + } + + private boolean isNullOrNothing(Object object, TypesLibrary typesLib, InteropLibrary interop) { + if (typesLib.hasType(object)) { + return typesLib.getType(object) == EnsoContext.get(this).getNothing(); + } else if (interop.isNull(object)) { + return true; + } else { + return object == null; + } + } + + static boolean isAtom(Object object) { + return object instanceof Atom; + } + + @TruffleBoundary + boolean isHostObject(Object object) { + return EnsoContext.get(this).getEnvironment().isHostObject(object); + } + + @TruffleBoundary + boolean isHostFunction(Object object) { + return EnsoContext.get(this).getEnvironment().isHostFunction(object); + } + /** * Helper node for invoking `Any.==` method. */ @@ -676,9 +731,9 @@ static InvokeAnyEqualsNode getUncached() { @Specialization boolean invokeEqualsCachedAtomCtor(Atom selfAtom, Atom thatAtom, - @Cached(value = "getAnyEqualsMethod()", allowUncached = true) Function anyEqualsFunc, - @Cached(value = "buildInvokeFuncNodeForAnyEquals()", allowUncached = true) InvokeFunctionNode invokeAnyEqualsNode, - @CachedLibrary(limit = "3") InteropLibrary interop) { + @Cached(value = "getAnyEqualsMethod()", allowUncached = true) Function anyEqualsFunc, + @Cached(value = "buildInvokeFuncNodeForAnyEquals()", allowUncached = true) InvokeFunctionNode invokeAnyEqualsNode, + @CachedLibrary(limit = "3") InteropLibrary interop) { // TODO: Shouldn't Comparable type be the very first argument? (synthetic self)? Object ret = invokeAnyEqualsNode.execute( anyEqualsFunc, @@ -711,57 +766,4 @@ InvokeFunctionNode buildInvokeFuncNodeForAnyEquals() { ); } } - - /** - * Returns true if the given atom overrides `==` operator. - */ - @TruffleBoundary - private static boolean atomOverridesEquals(Atom atom) { - var atomType = atom.getConstructor().getType(); - Map methodsOnType = atom - .getConstructor() - .getDefinitionScope() - .getMethods() - .get(atomType); - if (methodsOnType != null) { - return methodsOnType.containsKey("=="); - } else { - return false; - } - } - - @Fallback - @TruffleBoundary - boolean equalsGeneric(Object left, Object right, - @CachedLibrary(limit = "5") InteropLibrary interop, - @CachedLibrary(limit = "5") TypesLibrary typesLib) { - return left == right - || interop.isIdentical(left, right, interop) - || left.equals(right) - || (isNullOrNothing(left, typesLib, interop) && isNullOrNothing(right, typesLib, interop)); - } - - private boolean isNullOrNothing(Object object, TypesLibrary typesLib, InteropLibrary interop) { - if (typesLib.hasType(object)) { - return typesLib.getType(object) == EnsoContext.get(this).getNothing(); - } else if (interop.isNull(object)) { - return true; - } else { - return object == null; - } - } - - static boolean isAtom(Object object) { - return object instanceof Atom; - } - - @TruffleBoundary - boolean isHostObject(Object object) { - return EnsoContext.get(this).getEnvironment().isHostObject(object); - } - - @TruffleBoundary - boolean isHostFunction(Object object) { - return EnsoContext.get(this).getEnvironment().isHostFunction(object); - } } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java index aec74bf60c93..ac6dac78c4ab 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/HashCodeNode.java @@ -87,12 +87,13 @@ long hashCodeForByte(byte b) { @Specialization long hashCodeForLong(long l) { - return Long.hashCode(l); + // By casting long to double, we lose some precision on purpose + return hashCodeForDouble((double) l); } @Specialization long hashCodeForInt(int i) { - return i; + return hashCodeForLong(i); } @Specialization @@ -101,20 +102,20 @@ long hashCodeForFloat(float f) { } @Specialization - @TruffleBoundary long hashCodeForDouble(double d) { - if (d % 1.0 != 0.0) { + if (d % 1.0 != 0 || BigIntegerOps.fitsInLong(d)) { return Double.hashCode(d); } else { - if (BigIntegerOps.fitsInLong(d)) { - return hashCodeForLong(Double.valueOf(d).longValue()); - } else { - try { - return BigDecimal.valueOf(d).toBigIntegerExact().hashCode(); - } catch (ArithmeticException e) { - throw new IllegalStateException(e); - } - } + return bigDoubleHash(d); + } + } + + @TruffleBoundary + private static long bigDoubleHash(double d) { + try { + return BigDecimal.valueOf(d).toBigIntegerExact().hashCode(); + } catch (ArithmeticException e) { + throw new IllegalStateException(e); } } @@ -130,6 +131,7 @@ long hashCodeForAtomConstructor(AtomConstructor atomConstructor) { } @Specialization + @TruffleBoundary long hashCodeForUnresolvedSymbol(UnresolvedSymbol unresolvedSymbol, @Cached HashCodeNode hashCodeNode) { long nameHash = hashCodeNode.execute(unresolvedSymbol.getName()); @@ -396,7 +398,10 @@ long hashCodeForString(Object selfStr, @CachedLibrary("selfStr") InteropLibrary } @Specialization( - guards = {"interop.hasArrayElements(selfArray)"}, + guards = { + "interop.hasArrayElements(selfArray)", + "!interop.hasHashEntries(selfArray)" + }, limit = "3") long hashCodeForArray( Object selfArray, @@ -456,11 +461,13 @@ long hashCodeForMap( @Specialization(guards = { "!isAtom(objectWithMembers)", - // Object with type is handled in `hashCodeForType` specialization, so we have to - // negate the guard of that specialization here - to make the specializations - // disjunctive. + "!isHostObject(objectWithMembers)", + "interop.hasMembers(objectWithMembers)", + "!interop.hasArrayElements(objectWithMembers)", + "!interop.isTime(objectWithMembers)", + "!interop.isDate(objectWithMembers)", + "!interop.isTimeZone(objectWithMembers)", "!typesLib.hasType(objectWithMembers)", - "interop.hasMembers(objectWithMembers)" }) long hashCodeForInteropObjectWithMembers(Object objectWithMembers, @CachedLibrary(limit = "10") InteropLibrary interop, From e181336a7fef0388c1c10ae8e6d2d67a670aee1a Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Tue, 7 Feb 2023 19:59:56 +0100 Subject: [PATCH 49/60] fmt --- .../epb/runtime/PolyglotProxy.java | 1 - .../node/callable/InvokeConversionNode.java | 100 +++++++++--------- .../builtin/ordering/Comparable.java | 13 +-- .../ordering/DefaultOrderedComparator.java | 4 +- .../ordering/DefaultUnorderedComparator.java | 5 +- .../ordering/HasCustomComparatorNode.java | 42 ++++---- .../builtin/ordering/HashCallbackNode.java | 41 ++++--- .../org/enso/interpreter/test/EqualsTest.java | 57 +++++++--- .../org/enso/interpreter/test/TestBase.java | 2 + 9 files changed, 139 insertions(+), 126 deletions(-) diff --git a/engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/runtime/PolyglotProxy.java b/engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/runtime/PolyglotProxy.java index 3c259ddf7fad..bbd931cfb27e 100644 --- a/engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/runtime/PolyglotProxy.java +++ b/engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/runtime/PolyglotProxy.java @@ -1,7 +1,6 @@ package org.enso.interpreter.epb.runtime; import com.oracle.truffle.api.dsl.Cached; -import com.oracle.truffle.api.dsl.Cached.Exclusive; import com.oracle.truffle.api.exception.AbstractTruffleException; import com.oracle.truffle.api.interop.ArityException; import com.oracle.truffle.api.interop.ExceptionType; diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java index 59aaecde83f0..03757b1555b3 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/callable/InvokeConversionNode.java @@ -65,8 +65,8 @@ public void setTailStatus(TailStatus tailStatus) { /** * @param self A target of the conversion. Should be a {@link Type} on which the {@code from} - * method is defined. If it is not a {@link Type}, - * "Invalid conversion target" panic is thrown. + * method is defined. If it is not a {@link Type}, "Invalid conversion target" panic is + * thrown. * @param that Source of the conversion. Can be arbitrary object, including polyglot values. * @param arguments Additional arguments passed to the conversion function. */ @@ -203,12 +203,13 @@ Object doConvertText( } } - @Specialization(guards = { - "!typesLib.hasType(that)", - "!typesLib.hasSpecialDispatch(that)", - "!interop.isTime(that)", - "interop.isDate(that)", - }) + @Specialization( + guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "!interop.isTime(that)", + "interop.isDate(that)", + }) Object doConvertDate( VirtualFrame frame, State state, @@ -221,19 +222,17 @@ Object doConvertDate( @Cached ConversionResolverNode conversionResolverNode) { Function function = conversionResolverNode.expectNonNull( - that, - extractConstructor(self), - EnsoContext.get(this).getBuiltins().date(), - conversion); + that, extractConstructor(self), EnsoContext.get(this).getBuiltins().date(), conversion); return invokeFunctionNode.execute(function, frame, state, arguments); } - @Specialization(guards = { - "!typesLib.hasType(that)", - "!typesLib.hasSpecialDispatch(that)", - "interop.isTime(that)", - "!interop.isDate(that)", - }) + @Specialization( + guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isTime(that)", + "!interop.isDate(that)", + }) Object doConvertTime( VirtualFrame frame, State state, @@ -245,20 +244,21 @@ Object doConvertTime( @CachedLibrary(limit = "10") TypesLibrary typesLib, @Cached ConversionResolverNode conversionResolverNode) { Function function = - conversionResolverNode.expectNonNull( - that, - extractConstructor(self), - EnsoContext.get(this).getBuiltins().timeOfDay(), - conversion); + conversionResolverNode.expectNonNull( + that, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().timeOfDay(), + conversion); return invokeFunctionNode.execute(function, frame, state, arguments); } - @Specialization(guards = { - "!typesLib.hasType(that)", - "!typesLib.hasSpecialDispatch(that)", - "interop.isTime(that)", - "interop.isDate(that)", - }) + @Specialization( + guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isTime(that)", + "interop.isDate(that)", + }) Object doConvertDateTime( VirtualFrame frame, State state, @@ -270,19 +270,20 @@ Object doConvertDateTime( @CachedLibrary(limit = "10") TypesLibrary typesLib, @Cached ConversionResolverNode conversionResolverNode) { Function function = - conversionResolverNode.expectNonNull( - that, - extractConstructor(self), - EnsoContext.get(this).getBuiltins().dateTime(), - conversion); + conversionResolverNode.expectNonNull( + that, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().dateTime(), + conversion); return invokeFunctionNode.execute(function, frame, state, arguments); } - @Specialization(guards = { - "!typesLib.hasType(that)", - "!typesLib.hasSpecialDispatch(that)", - "interop.isDuration(that)", - }) + @Specialization( + guards = { + "!typesLib.hasType(that)", + "!typesLib.hasSpecialDispatch(that)", + "interop.isDuration(that)", + }) Object doConvertDuration( VirtualFrame frame, State state, @@ -302,11 +303,12 @@ Object doConvertDuration( return invokeFunctionNode.execute(function, frame, state, arguments); } - @Specialization(guards = { - "!typesLib.hasType(thatMap)", - "!typesLib.hasSpecialDispatch(thatMap)", - "interop.hasHashEntries(thatMap)", - }) + @Specialization( + guards = { + "!typesLib.hasType(thatMap)", + "!typesLib.hasSpecialDispatch(thatMap)", + "interop.hasHashEntries(thatMap)", + }) Object doConvertMap( VirtualFrame frame, State state, @@ -318,11 +320,11 @@ Object doConvertMap( @CachedLibrary(limit = "10") TypesLibrary typesLib, @Cached ConversionResolverNode conversionResolverNode) { Function function = - conversionResolverNode.expectNonNull( - thatMap, - extractConstructor(self), - EnsoContext.get(this).getBuiltins().map(), - conversion); + conversionResolverNode.expectNonNull( + thatMap, + extractConstructor(self), + EnsoContext.get(this).getBuiltins().map(), + conversion); return invokeFunctionNode.execute(function, frame, state, arguments); } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java index 5062313b1368..f5ea1e89d13b 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java @@ -3,13 +3,6 @@ import org.enso.interpreter.dsl.BuiltinType; import org.enso.interpreter.node.expression.builtin.Builtin; - -/** - * A hidden builtin. Only conversions with target type of Comparable are visible. - */ -@BuiltinType( - name = "Standard.Base.Data.Ordering.Comparable" -) -public class Comparable extends Builtin { - -} +/** A hidden builtin. Only conversions with target type of Comparable are visible. */ +@BuiltinType(name = "Standard.Base.Data.Ordering.Comparable") +public class Comparable extends Builtin {} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java index 0e47ac05f5dd..863a1efb1fdf 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java @@ -4,6 +4,4 @@ import org.enso.interpreter.node.expression.builtin.Builtin; @BuiltinType(name = "Standard.Base.Data.Ordering.Default_Ordered_Comparator") -public class DefaultOrderedComparator extends Builtin { - -} +public class DefaultOrderedComparator extends Builtin {} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java index 252975a9b71a..7fba407b64b5 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java @@ -4,7 +4,4 @@ import org.enso.interpreter.node.expression.builtin.Builtin; @BuiltinType(name = "Standard.Base.Data.Ordering.Default_Unordered_Comparator") -public class DefaultUnorderedComparator extends Builtin { - -} - +public class DefaultUnorderedComparator extends Builtin {} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java index 8072bf4abdea..47a7e72ee062 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HasCustomComparatorNode.java @@ -18,9 +18,9 @@ import org.enso.interpreter.runtime.state.State; /** - * Helper node for invocation of {@code Comparable.has_custom_comparator atom}. - * Note that emulating the semantics of that function in Java code would be too complicated, - * so we rather implemented it in Enso and just call it from this node. + * Helper node for invocation of {@code Comparable.has_custom_comparator atom}. Note that emulating + * the semantics of that function in Java code would be too complicated, so we rather implemented it + * in Enso and just call it from this node. */ @GenerateUncached public abstract class HasCustomComparatorNode extends Node { @@ -31,8 +31,8 @@ public static HasCustomComparatorNode getUncached() { /** * Returns true if the given atom has a custom comparator, that is a comparator that is different - * than the default (internal) ones. The default comparators are {@code Default_Unordered_Comparator} - * and {@code Default_Ordered_Comparator}. + * than the default (internal) ones. The default comparators are {@code + * Default_Unordered_Comparator} and {@code Default_Ordered_Comparator}. * * @param atom Atom for which we check whether it has custom comparator * @return true iff the given atom has a custom comparator @@ -42,23 +42,22 @@ public static HasCustomComparatorNode getUncached() { @Specialization boolean hasCustomComparatorCached( Atom atom, - @Cached(value = "getHasCustomComparatorFunction()", allowUncached = true) Function hasCustomComparatorFunc, - @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hasCustomComparatorInvokeNode, - @CachedLibrary(limit = "5") InteropLibrary interop - ) { + @Cached(value = "getHasCustomComparatorFunction()", allowUncached = true) + Function hasCustomComparatorFunc, + @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) + InvokeFunctionNode hasCustomComparatorInvokeNode, + @CachedLibrary(limit = "5") InteropLibrary interop) { var ctx = EnsoContext.get(this); var comparableType = ctx.getBuiltins().comparable().getType(); - Object res = hasCustomComparatorInvokeNode.execute( - hasCustomComparatorFunc, - null, - State.create(ctx), - new Object[]{comparableType, atom} - ); + Object res = + hasCustomComparatorInvokeNode.execute( + hasCustomComparatorFunc, null, State.create(ctx), new Object[] {comparableType, atom}); assert interop.isBoolean(res); try { return interop.asBoolean(res); } catch (UnsupportedMessageException e) { - throw new IllegalStateException("Return type from Comparable.has_custom_comparator should be Boolean", e); + throw new IllegalStateException( + "Return type from Comparable.has_custom_comparator should be Boolean", e); } } @@ -67,17 +66,20 @@ boolean hasCustomComparatorCached( */ static InvokeFunctionNode buildInvokeNodeWithAtomArgument() { return InvokeFunctionNode.build( - new CallArgumentInfo[]{new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, + new CallArgumentInfo[] {new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, DefaultsExecutionMode.EXECUTE, - ArgumentsExecutionMode.EXECUTE - ); + ArgumentsExecutionMode.EXECUTE); } @TruffleBoundary Function getHasCustomComparatorFunction() { var comparableType = EnsoContext.get(this).getBuiltins().comparable().getType(); Function hasCustomComparatorFunc = - comparableType.getDefinitionScope().getMethods().get(comparableType).get("has_custom_comparator"); + comparableType + .getDefinitionScope() + .getMethods() + .get(comparableType) + .get("has_custom_comparator"); assert hasCustomComparatorFunc != null : "Comparable.has_custom_comparator function must exist"; return hasCustomComparatorFunc; } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java index 47d83b9a6e09..ad5f104b8009 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/HashCallbackNode.java @@ -18,9 +18,9 @@ import org.enso.interpreter.runtime.state.State; /** - * Helper node for invocation of {@code Comparable.hash_callback atom}. - * Note that emulating the semantics of that function in Java code would be too complicated, - * so we rather implemented it in Enso and just call it from this node. + * Helper node for invocation of {@code Comparable.hash_callback atom}. Note that emulating the + * semantics of that function in Java code would be too complicated, so we rather implemented it in + * Enso and just call it from this node. */ @GenerateUncached public abstract class HashCallbackNode extends Node { @@ -30,14 +30,14 @@ public static HashCallbackNode getUncached() { } /** - * Dispatches to the appropriate comparator for the given atom and calls {@code hash} - * method on it. Returns the value from that method. + * Dispatches to the appropriate comparator for the given atom and calls {@code hash} method on + * it. Returns the value from that method. * - * Note that the given atom should have a custom comparator, otherwise it could be - * handled by {@link org.enso.interpreter.node.expression.builtin.meta.HashCodeNode}. + *

    Note that the given atom should have a custom comparator, otherwise it could be handled by + * {@link org.enso.interpreter.node.expression.builtin.meta.HashCodeNode}. * - * @param atom Atom, preferably with a custom comparator, for which we get the custom - * comparator and call {@code hash} method on the comparator. + * @param atom Atom, preferably with a custom comparator, for which we get the custom comparator + * and call {@code hash} method on the comparator. * @return Hash code for the atom, as returned by the custom comparator. */ public abstract long execute(Atom atom); @@ -46,21 +46,19 @@ public static HashCallbackNode getUncached() { long hashCallbackCached( Atom atom, @Cached(value = "getHashCallbackFunction()", allowUncached = true) Function hashCallbackFunc, - @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) InvokeFunctionNode hashCallbackInvokeNode, - @CachedLibrary(limit = "5") InteropLibrary interop - ) { + @Cached(value = "buildInvokeNodeWithAtomArgument()", allowUncached = true) + InvokeFunctionNode hashCallbackInvokeNode, + @CachedLibrary(limit = "5") InteropLibrary interop) { var ctx = EnsoContext.get(this); var comparableType = ctx.getBuiltins().comparable().getType(); - Object res = hashCallbackInvokeNode.execute( - hashCallbackFunc, - null, - State.create(ctx), - new Object[]{comparableType, atom} - ); + Object res = + hashCallbackInvokeNode.execute( + hashCallbackFunc, null, State.create(ctx), new Object[] {comparableType, atom}); try { return interop.asLong(res); } catch (UnsupportedMessageException e) { - throw new IllegalStateException("Return type from Comparable.hash_callback should be Long", e); + throw new IllegalStateException( + "Return type from Comparable.hash_callback should be Long", e); } } @@ -69,10 +67,9 @@ long hashCallbackCached( */ static InvokeFunctionNode buildInvokeNodeWithAtomArgument() { return InvokeFunctionNode.build( - new CallArgumentInfo[]{new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, + new CallArgumentInfo[] {new CallArgumentInfo("self"), new CallArgumentInfo("atom")}, DefaultsExecutionMode.EXECUTE, - ArgumentsExecutionMode.EXECUTE - ); + ArgumentsExecutionMode.EXECUTE); } @TruffleBoundary diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java index 337874ec76ce..464f746f3e22 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java @@ -105,14 +105,17 @@ public void equalsOperatorShouldBeConsistent(Object value) { }); } - /** - * Test for some specific values, for which we know that they are equal. - */ + /** Test for some specific values, for which we know that they are equal. */ @Test public void testDateEquality() { - Object ensoDate = unwrapValue(context, createValue(context, "(Date.new 1999 3 23)", "import Standard.Base.Data.Time.Date.Date")); + Object ensoDate = + unwrapValue( + context, + createValue( + context, "(Date.new 1999 3 23)", "import Standard.Base.Data.Time.Date.Date")); Object javaDate = unwrapValue(context, context.asValue(LocalDate.of(1999, 3, 23))); - executeInContext(context, + executeInContext( + context, () -> { assertTrue(equalsNode.execute(ensoDate, javaDate)); return null; @@ -121,9 +124,16 @@ public void testDateEquality() { @Test public void testTimeEquality() { - Object ensoTime = unwrapValue(context, createValue(context, "Time_Of_Day.new 23 59", "import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day")); + Object ensoTime = + unwrapValue( + context, + createValue( + context, + "Time_Of_Day.new 23 59", + "import Standard.Base.Data.Time.Time_Of_Day.Time_Of_Day")); Object javaDate = unwrapValue(context, context.asValue(LocalTime.of(23, 59))); - executeInContext(context, + executeInContext( + context, () -> { assertTrue(equalsNode.execute(ensoTime, javaDate)); return null; @@ -132,11 +142,21 @@ public void testTimeEquality() { @Test public void testDateTimeEquality() { - Object ensoDateTime = unwrapValue(context, createValue(context, "(Date_Time.new 1999 3 1 23 59)", "import Standard.Base.Data.Time.Date_Time.Date_Time")); - Object javaDateTime = unwrapValue(context, context.asValue( - ZonedDateTime.of(LocalDate.of(1999, 3, 1), LocalTime.of(23, 59), ZoneId.systemDefault()) - )); - executeInContext(context, + Object ensoDateTime = + unwrapValue( + context, + createValue( + context, + "(Date_Time.new 1999 3 1 23 59)", + "import Standard.Base.Data.Time.Date_Time.Date_Time")); + Object javaDateTime = + unwrapValue( + context, + context.asValue( + ZonedDateTime.of( + LocalDate.of(1999, 3, 1), LocalTime.of(23, 59), ZoneId.systemDefault()))); + executeInContext( + context, () -> { assertTrue(equalsNode.execute(ensoDateTime, javaDateTime)); return null; @@ -145,11 +165,14 @@ public void testDateTimeEquality() { @Test public void testVectorsEquality() { - Object ensoVector = unwrapValue(context, createValue(context, "[1,2,3]", "from Standard.Base.import all")); + Object ensoVector = + unwrapValue(context, createValue(context, "[1,2,3]", "from Standard.Base.import all")); Object javaVector = unwrapValue(context, context.asValue(List.of(1, 2, 3))); - executeInContext(context, () -> { - assertTrue(equalsNode.execute(ensoVector, javaVector)); - return null; - }); + executeInContext( + context, + () -> { + assertTrue(equalsNode.execute(ensoVector, javaVector)); + return null; + }); } } diff --git a/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java b/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java index 327456df16d7..8c39fff912c0 100644 --- a/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java +++ b/engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java @@ -82,6 +82,7 @@ protected static Object unwrapValue(Context ctx, Value value) { /** * Creates an Enso value from the given source. + * * @param src One-line assignment into a variable * @param imports Imports, may be empty. */ @@ -104,6 +105,7 @@ protected static Value createValue(Context ctx, String src) { /** * Evaluates the given source as if it was in an unnamed module. + * * @param src The source code of the module * @return The value returned from the main method of the unnamed module. */ From 34dcc0f8ac5b155a659dff3d0e165fbace036e7f Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 8 Feb 2023 09:37:41 +0100 Subject: [PATCH 50/60] Do not check hash codes in Any.== --- .../lib/Standard/Base/0.0.0-dev/src/Any.enso | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 8c9cee7c144f..7ec0c05ed224 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -112,18 +112,15 @@ type Any eq_self = Panic.catch No_Such_Conversion (Comparable.from self) _-> Default_Unordered_Comparator eq_that = Panic.catch No_Such_Conversion (Comparable.from that) _-> Default_Unordered_Comparator if Meta.is_same_object eq_self Incomparable then False else - # Comparable.equals_builtin is a hack how to directly access EqualsNode from the - # engine, so that we don't end up in an infinite recursion here (which would happen - # if we would compare with `eq_self == eq_that`). similar_type = Meta.is_same_object eq_self eq_that if similar_type.not then False else - hash_self = eq_self.hash self - hash_that = eq_that.hash that - if Comparable.equals_builtin hash_self hash_that . not then False else - case eq_self.is_ordered of - True -> - Comparable.equals_builtin (eq_self.compare self that) Ordering.Equal - False -> eq_self.equals self that + case eq_self.is_ordered of + True -> + # Comparable.equals_builtin is a hack how to directly access EqualsNode from the + # engine, so that we don't end up in an infinite recursion here (which would happen + # if we would compare with `eq_self == eq_that`). + Comparable.equals_builtin (eq_self.compare self that) Ordering.Equal + False -> eq_self.equals self that ## ALIAS Inequality From d23d1fa6b358a99338b42a1fb68f357c69b79a12 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 8 Feb 2023 09:39:50 +0100 Subject: [PATCH 51/60] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 39fa400e0638..945a32e54b77 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -554,6 +554,7 @@ - [Optimize Atom storage layouts][3862] - [Make instance methods callable like statics for builtin types][4077] - [Convert large longs to doubles, safely, for host calls][4099] +- [Consistent ordering with comparators](4067) - [Profile engine startup][4110] [3227]: https://github.com/enso-org/enso/pull/3227 @@ -645,6 +646,7 @@ [4056]: https://github.com/enso-org/enso/pull/4056 [4077]: https://github.com/enso-org/enso/pull/4077 [4099]: https://github.com/enso-org/enso/pull/4099 +[4067]: https://github.com/enso-org/enso/pull/4067 [4110]: https://github.com/enso-org/enso/pull/4110 # Enso 2.0.0-alpha.18 (2021-10-12) From 2bf52564904d427f937af4f895641270d2d3e38d Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 8 Feb 2023 09:49:21 +0100 Subject: [PATCH 52/60] Import Any in benchmarks failing on "No such method ==". --- .../semantic/CurriedFunctionBenchmarks.java | 2 ++ .../bench/benchmarks/semantic/EqualsBenchmarks.java | 1 + .../bench/benchmarks/semantic/VectorBenchmarks.java | 1 + .../bench/fixtures/semantic/AtomFixtures.scala | 3 +++ .../bench/fixtures/semantic/CallableFixtures.scala | 10 +++++++--- .../semantic/NamedDefaultedArgumentFixtures.scala | 6 ++++-- .../bench/fixtures/semantic/RecursionFixtures.scala | 12 ++++++++---- 7 files changed, 26 insertions(+), 9 deletions(-) diff --git a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/CurriedFunctionBenchmarks.java b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/CurriedFunctionBenchmarks.java index 0ba34c00a9e6..5f3f63c7bade 100644 --- a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/CurriedFunctionBenchmarks.java +++ b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/CurriedFunctionBenchmarks.java @@ -44,6 +44,8 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception { var benchmarkName = params.getBenchmark().replaceFirst(".*\\.", ""); var code = """ + import Standard.Base.Any.Any + avg fn len = sum acc i = if i == len then acc else sum (acc + fn i) i+1 diff --git a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/EqualsBenchmarks.java b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/EqualsBenchmarks.java index 2021799ca46a..3af62d6bf2d4 100644 --- a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/EqualsBenchmarks.java +++ b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/EqualsBenchmarks.java @@ -71,6 +71,7 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception { var benchmarkName = params.getBenchmark().replaceFirst(".*\\.", ""); var codeBuilder = new StringBuilder(""" import Standard.Base.Data.Range.Extensions + import Standard.Base.Any.Any type Node C1 f1 diff --git a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/VectorBenchmarks.java b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/VectorBenchmarks.java index 2213245e1857..2a6e836921e4 100644 --- a/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/VectorBenchmarks.java +++ b/engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/semantic/VectorBenchmarks.java @@ -48,6 +48,7 @@ public void initializeBenchmark(BenchmarkParams params) throws Exception { var code = """ import Standard.Base.Data.Vector.Vector import Standard.Base.Data.Array_Proxy.Array_Proxy + import Standard.Base.Any.Any avg arr = sum acc i = if i == arr.length then acc else diff --git a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/AtomFixtures.scala b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/AtomFixtures.scala index 6495ce98d123..910e87b7788c 100644 --- a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/AtomFixtures.scala +++ b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/AtomFixtures.scala @@ -7,6 +7,7 @@ class AtomFixtures extends DefaultInterpreterRunner { val millionElementList = eval( s"""import Standard.Base.Data.List.List + |import Standard.Base.Any.Any | |main = | generator fn acc i end = if i == end then acc else @Tail_Call generator fn (fn acc i) i+1 end @@ -16,6 +17,7 @@ class AtomFixtures extends DefaultInterpreterRunner { val generateListCode = """import Standard.Base.Data.List.List + |import Standard.Base.Any.Any | |main = length -> | generator = acc -> i -> if i == 0 then acc else @Tail_Call generator (List.Cons i acc) (i - 1) @@ -27,6 +29,7 @@ class AtomFixtures extends DefaultInterpreterRunner { val generateListQualifiedCode = """import Standard.Base.Data.List.List + |import Standard.Base.Any.Any | |main = length -> | generator = acc -> i -> if i == 0 then acc else @Tail_Call generator (List.Cons i acc) (i - 1) diff --git a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/CallableFixtures.scala b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/CallableFixtures.scala index e569c0d3798d..f4e2b46f444d 100644 --- a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/CallableFixtures.scala +++ b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/CallableFixtures.scala @@ -8,6 +8,7 @@ class CallableFixtures extends DefaultInterpreterRunner { val sumTCOfromCallCode = """ |from Standard.Base.Data.Numbers import all + |import Standard.Base.Any.Any | |type Foo | @@ -22,7 +23,8 @@ class CallableFixtures extends DefaultInterpreterRunner { val sumTCOmethodCallCode = - """ + """import Standard.Base.Any.Any + | |summator = acc -> current -> | if current == 0 then acc else @Tail_Call summator (acc + current) (current - 1) | @@ -33,7 +35,8 @@ class CallableFixtures extends DefaultInterpreterRunner { val sumTCOmethodCall = getMain(sumTCOmethodCallCode) val sumTCOmethodCallWithNamedArgumentsCode = - """ + """import Standard.Base.Any.Any + | |summator = acc -> current -> | if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current) | @@ -45,7 +48,8 @@ class CallableFixtures extends DefaultInterpreterRunner { getMain(sumTCOmethodCallWithNamedArgumentsCode) val sumTCOmethodCallWithDefaultedArgumentsCode = - """ + """import Standard.Base.Any.Any + | |summator = (acc = 0) -> current -> | if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current) | diff --git a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/NamedDefaultedArgumentFixtures.scala b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/NamedDefaultedArgumentFixtures.scala index 43e3d5acc6c6..2d016a113b81 100644 --- a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/NamedDefaultedArgumentFixtures.scala +++ b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/NamedDefaultedArgumentFixtures.scala @@ -6,7 +6,8 @@ class NamedDefaultedArgumentFixtures extends DefaultInterpreterRunner { val hundredMillion: Long = 100000000 val sumTCOWithNamedArgumentsCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = acc -> current -> | if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current) @@ -17,7 +18,8 @@ class NamedDefaultedArgumentFixtures extends DefaultInterpreterRunner { val sumTCOWithNamedArguments = getMain(sumTCOWithNamedArgumentsCode) val sumTCOWithDefaultedArgumentsCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = (acc = 0) -> current -> | if current == 0 then acc else @Tail_Call summator (current = current - 1) (acc = acc + current) diff --git a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/RecursionFixtures.scala b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/RecursionFixtures.scala index 230fd5090c59..2f9091102919 100644 --- a/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/RecursionFixtures.scala +++ b/engine/runtime/src/bench/scala/org/enso/interpreter/bench/fixtures/semantic/RecursionFixtures.scala @@ -9,7 +9,8 @@ class RecursionFixtures extends DefaultInterpreterRunner { val hundred: Long = 100 val sumTCOCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = acc -> current -> | if current == 0 then acc else @Tail_Call summator acc+current current-1 @@ -20,7 +21,8 @@ class RecursionFixtures extends DefaultInterpreterRunner { val sumTCO = getMain(sumTCOCode) val sumTCOFoldLikeCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = acc -> i -> f -> | if i == 0 then acc else @Tail_Call summator (f acc i) (i - 1) f @@ -30,7 +32,8 @@ class RecursionFixtures extends DefaultInterpreterRunner { val sumTCOFoldLike = getMain(sumTCOFoldLikeCode) val sumRecursiveCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = i -> if i == 0 then 0 else i + summator (i - 1) | res = summator sumTo @@ -39,7 +42,8 @@ class RecursionFixtures extends DefaultInterpreterRunner { val sumRecursive = getMain(sumRecursiveCode) val oversaturatedRecursiveCallTCOCode = - """ + """import Standard.Base.Any.Any + | |main = sumTo -> | summator = acc -> i -> f -> | if i == 0 then acc else @Tail_Call summator (f acc i) (i - 1) f From bddb09fa00f75e653772d3629c83551e2e93dc7b Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 8 Feb 2023 12:26:07 +0100 Subject: [PATCH 53/60] Comparable, and Default_(Un)Ordered_Comparator are "hidden" builtins This should fix MetaIsObjectTest --- .../node/expression/builtin/ordering/Comparable.java | 2 +- .../expression/builtin/ordering/DefaultOrderedComparator.java | 2 +- .../expression/builtin/ordering/DefaultUnorderedComparator.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java index f5ea1e89d13b..ee28336eff12 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/Comparable.java @@ -4,5 +4,5 @@ import org.enso.interpreter.node.expression.builtin.Builtin; /** A hidden builtin. Only conversions with target type of Comparable are visible. */ -@BuiltinType(name = "Standard.Base.Data.Ordering.Comparable") +@BuiltinType public class Comparable extends Builtin {} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java index 863a1efb1fdf..0b9839e26ea0 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultOrderedComparator.java @@ -3,5 +3,5 @@ import org.enso.interpreter.dsl.BuiltinType; import org.enso.interpreter.node.expression.builtin.Builtin; -@BuiltinType(name = "Standard.Base.Data.Ordering.Default_Ordered_Comparator") +@BuiltinType public class DefaultOrderedComparator extends Builtin {} diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java index 7fba407b64b5..21c661b157eb 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/ordering/DefaultUnorderedComparator.java @@ -3,5 +3,5 @@ import org.enso.interpreter.dsl.BuiltinType; import org.enso.interpreter.node.expression.builtin.Builtin; -@BuiltinType(name = "Standard.Base.Data.Ordering.Default_Unordered_Comparator") +@BuiltinType public class DefaultUnorderedComparator extends Builtin {} From 229ed4408e931592fb700f74be810d6710d7c607 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Wed, 8 Feb 2023 17:50:58 +0100 Subject: [PATCH 54/60] Address some nitpicks from review --- distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso | 3 +-- .../lib/Standard/Base/0.0.0-dev/src/Data/Array.enso | 6 +++--- .../lib/Standard/Base/0.0.0-dev/src/Data/Json.enso | 1 + .../lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso | 10 +++++----- distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso | 2 -- .../Standard/Database/0.0.0-dev/src/Data/Table.enso | 2 +- .../lib/Standard/Table/0.0.0-dev/src/Data/Column.enso | 4 ++-- .../lib/Standard/Table/0.0.0-dev/src/Data/Table.enso | 2 +- .../Data/Ordering/Vector_Lexicographic_Order_Spec.enso | 2 +- test/Tests/src/Data/Time/Time_Of_Day_Spec.enso | 1 + 10 files changed, 16 insertions(+), 17 deletions(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso index 7ec0c05ed224..4752b8b80950 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Any.enso @@ -1,5 +1,3 @@ -# We have to import also conversion methods from Ordering, therefore, we import all -from project.Data.Ordering import all import project.Data.Pair.Pair import project.Data.Range.Extensions import project.Data.Text.Text @@ -12,6 +10,7 @@ import project.Meta import project.Panic.Panic from project.Data.Boolean import Boolean, True, False +from project.Data.Ordering import all ## Any is the universal top-type, with all other types being subsumed by it. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso index d8e52a3c4cbe..fbea107de5fe 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Array.enso @@ -137,7 +137,7 @@ type Array ## Sorts the Array. Arguments: - - compare_func: A comparison function that takes two elements and returns + - comparator: A comparison function that takes two elements and returns an Ordering that describes how the first element is ordered with respect to the second. @@ -146,8 +146,8 @@ type Array [3,2,1].to_array.sort sort : (Any -> Any -> Ordering) -> Array - sort self compare_func=(Ordering.compare _ _) = - self.sort_builtin compare_func + sort self comparator=(Ordering.compare _ _) = + self.sort_builtin comparator ## Identity. diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso index 7a83d5802745..511ccf659fc2 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Json.enso @@ -183,6 +183,7 @@ type JS_Object to_default_visualization_data self = render self +## PRIVATE type JS_Object_Comparator is_ordered : Boolean is_ordered = False diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index 06423880ad28..b292c7d3fa7e 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -1,15 +1,15 @@ -import project.Data.Numbers.Integer +import project.Any.Any import project.Data.Numbers.Decimal +import project.Data.Numbers.Integer import project.Data.Numbers.Number import project.Error.Common.Type_Error import project.Error.Error import project.Error.Incomparable_Values.Incomparable_Values import project.Error.Unimplemented.Unimplemented import project.Nothing -import project.Any.Any -from project.Data.Boolean import all import project.Meta import project.Meta.Atom +from project.Data.Boolean import all ## Provides custom ordering, equality check and hash code for types that need it. @@ -127,12 +127,12 @@ type Comparable ## PRIVATE Called as a callback from internal engine code for an atom with a custom comparator. It is assumed that the given atom has a custom comparator, that is - a comparator different than `Default_Unordered_Comparator`.: + a comparator different than `Default_Unordered_Comparator`. hash_callback : Atom -> Integer hash_callback atom = (Comparable.from atom).hash atom ## PRIVATE - A custom comparator is any comparator that is different than the two + A custom comparator is any comparator that is different than the default ones. has_custom_comparator : Atom -> Boolean has_custom_comparator atom = diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso index c435b4185ed1..4007294c178a 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Main.enso @@ -78,7 +78,6 @@ import project.Data.Ordering.Natural_Order import project.Data.Ordering.Ordering import project.Data.Ordering.Comparable import project.Data.Ordering.Incomparable -import project.Data.Ordering.Default_Unordered_Comparator import project.Data.Ordering.Default_Ordered_Comparator import project.Data.Ordering.Sort_Direction.Sort_Direction import project.Data.Pair.Pair @@ -133,7 +132,6 @@ export project.Data.Ordering.Natural_Order export project.Data.Ordering.Ordering export project.Data.Ordering.Comparable export project.Data.Ordering.Incomparable -export project.Data.Ordering.Default_Unordered_Comparator export project.Data.Ordering.Default_Ordered_Comparator export project.Data.Ordering.Sort_Direction.Sort_Direction export project.Data.Pair.Pair diff --git a/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso b/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso index d0a4c2966256..8e934021b730 100644 --- a/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso +++ b/distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso @@ -289,7 +289,7 @@ type Table ## Returns a new table with the columns sorted by name according to the specified sort method. By default, sorting will be according to - case-sensitive ascending order based on the `Default_Ordered_Comparator`. + case-sensitive ascending order based on the normalized Unicode ordering. Arguments: - order: Whether sorting should be in ascending or descending order. diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso index a2bb1e68efc6..9f3b389d0e5b 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso @@ -1172,7 +1172,7 @@ type Column this rule, ignoring the ascending / descending setting. - by: function taking two items in this column and returning an ordering. If specified, it is used instead of the natural - ordering as defined by `Default_Ordered_Comparator`. + ordering of the values. > Example Sorting a column in ascending order. @@ -1191,7 +1191,7 @@ type Column Examples.integer_column.sort Sort_Direction.Descending missing_last=False > Example - Sorting `column` in ascending order, using a custom compare + Sorting `column` in ascending order, using a custom comparison function. import Standard.Examples diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso index bb7b186dc24a..a68360e72613 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Table.enso @@ -402,7 +402,7 @@ type Table ## Returns a new table with the columns sorted by name according to the specified sort method. By default, sorting will be according to - case-sensitive ascending order based on the `Default_Ordered_Comparator`. + case-sensitive ascending order based on the normalized Unicode ordering. Arguments: - order: Whether sorting should be in ascending or descending order. diff --git a/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso b/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso index 423ec83d8ccb..f96403578b26 100644 --- a/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso +++ b/test/Tests/src/Data/Ordering/Vector_Lexicographic_Order_Spec.enso @@ -15,7 +15,7 @@ spec = Test.group "Lexicographic Order on Vectors" <| Vector_Lexicographic_Order.compare [] [1] . should_equal Ordering.Less Vector_Lexicographic_Order.compare [1] [1] . should_equal Ordering.Equal - Test.specify "should work correctly with a custom compare function" <| + Test.specify "should work correctly with a custom comparator" <| comparator = x-> y-> Ordering.compare x.a y.a Vector_Lexicographic_Order.compare [My_Type.Value "a" 1, My_Type.Value "b" 1, My_Type.Value "c" 1] [My_Type.Value "b" 1, My_Type.Value "a" 1, My_Type.Value "c" 1] element_comparator=comparator . should_equal Ordering.Less Vector_Lexicographic_Order.compare [My_Type.Value "a" 1, My_Type.Value "b" 1, My_Type.Value "c" 1] [My_Type.Value "a" 100, My_Type.Value "b" 2, My_Type.Value "c" 3] element_comparator=comparator . should_equal Ordering.Equal diff --git a/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso b/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso index 68709b14187c..01e6f8bf9ae7 100644 --- a/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso +++ b/test/Tests/src/Data/Time/Time_Of_Day_Spec.enso @@ -116,6 +116,7 @@ specWith name create_new_time parse_time = time_1!=time_2 . should_be_true time_1>time_2 . should_be_true time_1 Date: Wed, 8 Feb 2023 19:22:40 +0100 Subject: [PATCH 55/60] Temporarily ignore `Any == Boolean` tests. --- test/Tests/src/Semantic/Equals_Spec.enso | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/Tests/src/Semantic/Equals_Spec.enso b/test/Tests/src/Semantic/Equals_Spec.enso index 18ed63527168..7eb0d55ed225 100644 --- a/test/Tests/src/Semantic/Equals_Spec.enso +++ b/test/Tests/src/Semantic/Equals_Spec.enso @@ -166,9 +166,11 @@ spec = (Child == Point).should_be_false (Point == Child).should_be_false (Boolean == Any).should_be_false + (Boolean == Boolean).should_be_true + + Test.specify "should handle `==` on types with Any as first operand" pending="Any == Boolean resolves to Any.type.== static method call" <| (Any == Boolean).should_be_false (Any == Any).should_be_true - (Boolean == Boolean).should_be_true Test.specify "should dispatch to overriden `==` in vectors" <| ([(Child.Value 1)] == [(Child.Value 101)]).should_be_true From 610eaf28a8bb348317f2744a2613c3b5336267bf Mon Sep 17 00:00:00 2001 From: Jaroslav Tulach Date: Thu, 9 Feb 2023 06:44:06 +0100 Subject: [PATCH 56/60] import Default_Unordered_Comparator in Map_Spec --- test/Tests/src/Data/Map_Spec.enso | 1 + 1 file changed, 1 insertion(+) diff --git a/test/Tests/src/Data/Map_Spec.enso b/test/Tests/src/Data/Map_Spec.enso index 9c4dba0bba00..975d958000b1 100644 --- a/test/Tests/src/Data/Map_Spec.enso +++ b/test/Tests/src/Data/Map_Spec.enso @@ -3,6 +3,7 @@ import Standard.Base.Error.Illegal_Argument.Illegal_Argument import Standard.Base.Error.No_Such_Key.No_Such_Key import Standard.Base.Data.Time.Date_Time.Date_Time from Standard.Base.Data.Map import Map +from Standard.Base.Data.Ordering import Default_Unordered_Comparator from Standard.Test import Test, Test_Suite, Problems import Standard.Test.Extensions From 731b10eab120c79b0c93f1ab68bff2adc57145ef Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 9 Feb 2023 10:30:18 +0100 Subject: [PATCH 57/60] Small fix in Vector_Spec --- test/Tests/src/Data/Vector_Spec.enso | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/Tests/src/Data/Vector_Spec.enso b/test/Tests/src/Data/Vector_Spec.enso index 8113e603feba..fd45cd786f99 100644 --- a/test/Tests/src/Data/Vector_Spec.enso +++ b/test/Tests/src/Data/Vector_Spec.enso @@ -21,6 +21,8 @@ type T_Comparator compare t1 t2 = Comparable.from t1.a . compare t1.a t2.a hash t = Comparable.from t.a . hash t.a +Comparable.from (_:T) = T_Comparator + type My_Error Value a From 001e792bdb698c6a618a0f85e3bb5335b9b20f56 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 9 Feb 2023 10:38:30 +0100 Subject: [PATCH 58/60] Remove Eq_Spec --- test/Tests/src/Semantic/Eq_Spec.enso | 70 ---------------------------- 1 file changed, 70 deletions(-) delete mode 100644 test/Tests/src/Semantic/Eq_Spec.enso diff --git a/test/Tests/src/Semantic/Eq_Spec.enso b/test/Tests/src/Semantic/Eq_Spec.enso deleted file mode 100644 index 3415e3349651..000000000000 --- a/test/Tests/src/Semantic/Eq_Spec.enso +++ /dev/null @@ -1,70 +0,0 @@ -# TODO[PM]: This file should be merged with Equals_Spec.enso once the usage of equality is -# unified. - -from Standard.Base import all -import Standard.Base.Data.Index_Sub_Range -from Standard.Base.Data.Eq import all - -from Standard.Test import Test, Test_Suite - -spec = - Test.group "Test equality on numbers" <| - Test.specify "Compare different numbers" <| - 10 === 20.3 . should_be_false - - Test.specify "Compare same numbers" <| - 10 === 10 . should_be_true - - Test.specify "Different hash prevents equality" <| - Wrong_Hash.Elem1 === Wrong_Hash.Elem2 . should_be_false - - Test.group "Test inequality on numbers" <| - Test.specify "Compare two numbers" <| - 10 <== 11 . should_be_true - - Test.group "Rational Numbers" <| - Test.specify "3/4 == 6/8" <| - Rational.Fraction 3 4 === Rational.Fraction 6 8 . should_be_true - - Test.specify "1/2 != 2/6" <| - Rational.Fraction 1 2 === Rational.Fraction 2 6 . should_be_false - - Test.group "Other" <| - Test.specify "texts" <| - "aaa" === "bbb" . should_be_false - "aaa" === "aaa" . should_be_true - "xxx" === "XxX" . should_be_false - "aaa" <== "xxx" . should_be_true - "aaa" >== "xxx" . should_be_false - -type Wrong_Hash - Elem1 - Elem2 - -Comparable.from (_ : Wrong_Hash) = Wrong_Hash_Eq - -type Wrong_Hash_Eq - is_ordered = True - hash e = case e of - Wrong_Hash.Elem1 -> 1 - Wrong_Hash.Elem2 -> 2 - compare _ _ = True - -type Rational - Fraction (numerator:Integer) (denominator:Integer) - -Comparable.from (_ : Rational) = Rational_Ordering - -type Rational_Ordering - is_ordered = True - - compare r1 r2 = - v1 = r1.numerator * r2.denominator - v2 = r2.numerator * r1.denominator - if v1 < v2 then Ordering.Less else - if v1 > v2 then Ordering.Greater else - Ordering.Equal - - hash _ = 42 - -main = Test_Suite.run_main spec From c3cb84f97bf23d9b821a43ae787296abb10f0a13 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 9 Feb 2023 10:38:35 +0100 Subject: [PATCH 59/60] Revert "Fix Map visualization" This reverts commit c0e08e9dc14309b359d0dcffdbea1693d7214163. --- .../enso/interpreter/instrument/job/VisualizationResult.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java b/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java index df6274cb1327..5dbaa67512d9 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/instrument/job/VisualizationResult.java @@ -30,10 +30,6 @@ public static byte[] visualizationResultToBytes(Object value) { } catch (UnsupportedMessageException ex) { // fallthru } - } else if (iop.hasHashEntries(value)) { - return visualizationResultToBytes( - iop.toDisplayString(value) - ); } return null; } From 658af5a9a5ddfbc5bb7a002db6e61e209644f5d6 Mon Sep 17 00:00:00 2001 From: Pavel Marek Date: Thu, 9 Feb 2023 18:06:23 +0100 Subject: [PATCH 60/60] fmt --- distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso index b292c7d3fa7e..3686f7071493 100644 --- a/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso +++ b/distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso @@ -39,7 +39,7 @@ from project.Data.Boolean import all Note that there has to be `is_ordered` method defined which returns a Boolean indicating that the comparator is ordered. This is currently needed as there is - no way how to define interfaces in Enso. + no way to define interfaces in Enso. An _unordered comparator_ has to implement both `equals` and `hash` to define a _total_ custom equality. By _total_, we mean that every instance of the type