Sysrift v0.1.0 release

straight-shoota · April 7, 2026, 9:43am

I wish Crystal had type-safe equality.

The issue with Value/Ref#== having a default implementation

opened 11:02PM - 21 Jan 21 UTC

kind:feature topic:stdlib status:discussion community:to-research

I realized that Crystal currently allows comparisons that always fail: ```cr … "a" == 'a' # Not comparable, but accepted by compiler and always returns false SomeEnum::Member == 10 # Same here (`SomeEnum != Int32` but again accepted and returns false) ``` I asked on Crystal chat and @asterite and @straight-shoota report that comparing anything to anything (defaulting to returning `false`) was allowed because otherwise comparing union types would be problematic, and the language would be too rigid. Previous or similar tickets about this issue, which explain it, are #2996, #6154, and #8893. (And #1730 which asks about the same issue.) (For a very brief example, if such comparisons were prevented, they would have prevented some very reasonably-looking code from working, such as: `{1, "a", nil}.includes? 'x'`) In any case, the reason why these comparisons are allowed (and always returning false) is this fallback implementation of `#==` in types `Value` and `Reference`: ```cr # Returns `false`. def ==(other) false end ``` This seems to me as undesirable because it (1) removes type safety from arguably the most basic operator in a language (`==`), and also it partially masks `Comparable`. I think that both arguments: 1) Being able to compare anything to anything, returning false 2) Asking for type safety in a comparison operator Are completely valid, and in fact they represent two different use cases which shouldn't be hidden behind a single `#==` operator. My suggestion is that we add a new operator which implements the other case. Option 1: The default implementation of `#==` is removed, so that the only working `#==` comes from `Comparable` or a specific implementation of `#==`, and is type safe. Another operator (for example `==?`) is added which does what `#==` currently does (returns `false` as a fallback). Option 2: `#==` is left as-is, and another operator is added, which enforces type checks. I think option 1 would be clean and consistent, certainly preferrable, and option 2 would maybe be easier/more viable, all things considered. @straight-shoota mentioned that he was preparing an RFC about this issue. @asterite said: "It would be nice if equality was type safe. Someone can try it and see how hard it is to make the std specs pass with that change, and how the code changes." Comments welcome.

Topic		Replies	Views
[ANN] Pyrite: Hardware-bound binary execution and anti-tamper sealing for Crystal Community	0	62	August 28, 2026
Is Crystal Just a Blend of Other Languages? Community blog	14	545	April 17, 2026
Introduction Introductions	1	128	March 25, 2026
The core principles behind Crystal Community	33	4472	May 27, 2020
Segfault while bootstraping from ruby Help & Support	13	706	January 25, 2025

Sysrift v0.1.0 release

Related topics