How will rational number be implemented?

[amano-kenji]

Will it be implemented as haskell's Decimal library or Raku's Rat type or something else?

[wmedrano]

Update: Related PR #155

Steel newbie here but under the hood, it will probably be a combination Rational32 and BigRational. As for behavior:

(+ 1/5 4/5) ;; 1
(- 1 1/5)   ;; 4/5
(/ 4 5)     ;; 4/5
(* 2/3 5/7) ;; 10/21
(+ 1/5 0.8) ;; 1.0

[amano-kenji]

Things like +, -, *, /, and round-to-decimal.

[mattwparas]

There is nothing stopping you (from the implementation stand point ) of implementing your own versions of these functions, and even shadow the existing definition within a module if you so choose.

[amano-kenji]

That's what I was worried about. So, there is no typeclass.

I guess I will have to manually economize memory consumption of big rational numbers. Things like eliminating common factors and rounding to a specific number of decimal places...

I can also implement my own operations in my library, but I prefer using core functions.

[wmedrano]

The implementation of rational numbers already eliminates common factors and even demotes from BigRational to Rational32 when appropriate.

• common factor removal
• BigRational to Rational32 demotion

[amano-kenji]

You only need to implement something like round-to-decimal or round-to, then?

[kenaryn]

I apologize in advance if I am off-topic but would valids and posits (formerly known as unum) be worth implementing? It is said to be more performant and accurate than floating point numbers and integers based on IEEE-754 specification.

• Here is the book describing the author's work: https://www.routledge.com/The-End-of-Error-Unum-Computing/Gustafson/p/book/9781482239867.
  A glance at https://annas-archive.org/md5/b0e09ff07a6968086bcb3227ea08f95c shall make the trick.

• Here is the Rust port of posit numbers: https://crates.io/crates/softposit

• There are some Racket bindings for the C implementation:
  https://pkgs.racket-lang.org/package/softposit-rkt which I hope would be of value to help understand its internals and allow any motivated contributor to port it to Steel.
  The associated documentation is there: https://pkgs.racket-lang.org/package/softposit-rkt/index.html

• Here is the C official implementation: https://gitlab.com/cerlane/SoftPosit published for NGA (New Generation Arithmetic collective).

• Here are some very brief lessons related to projective reals (from which the posits are a representation): https://web.archive.org/web/20170213233747/http://www.math.poly.edu/courses/projective_geometry/chapter_two/node1.html

And last but not least, the posit standard from march 2022: https://posithub.org/khub_doc

[mattwparas]

I see the value here, however given that steel is designed for first class embedding, I think straying from the builtin types would be difficult.

There shouldn't be any reason this couldn't be implemented as a library though! That being said if it were implemented separately as a shared library, we would probably lose all of the performance wins

[amano-kenji]

Will steel scheme embedded in helix editor be able to use steel scheme packages available for standalone interpreter?

I think there will be two kinds of packages.

• scheme steel packages for helix editor
• scheme steel packages for standalone interpreter

[mattwparas]

There shouldn't be any difference between the two. You should be able to use packages written for the standalone interpreter for helix. Of course, if you write a package and it depends on APIs that only exist within helix, then it won't be able to be used by the standalone interpreter.