infinite (fractional) precision

[Ketil Z. Malde]

Hi

I was just browsing around on comp.arch a bit, and there was this
discussion about various ways to represent non-integer numeric
values. 

It seems one could easily (I'll get back to that in a moment)
calculate the fractional part of numbers lazily, generating the needed
precision, and nothing more.  Does any such implementation exist in
Haskell? 

I realize it's probably far from trivial, e.g. comparing two equal
numbers could easily not terminate, and memory exhaustion would
probably arise in many other cases.

So, if such implementations exist, how does one deal with these
issues?  Is it indeed possible to make this useful in practice?  

(And if it hasn't been implemented, would anybody be interested if I
gave it a try?)

-kzm
-- 
If I haven't seen further, it is by standing in the footprints of giants