- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Why not some subclass of Floating to model NaNs as some handleable bottom?
by Michal J Gajda 04 Aug '21

04 Aug '21

Dear Yue, Bottom has much weaker semantics than an exception: it means You may never get a result and thus will never handle it! Another reason is convenience: it is frequently the case that giving NaN in a row of numbers is much more informative than crashing a program with an exception and never printing the result anyway. Finally IEEE special values have clear propagation semantics: they are basically Maybe on steroids. The problem with this approach is indeed a silent handling. But in order to fix this, it is better to add preconditions to specific algorithms that do not allow IEEE special value on input (`isFinite` or `isNotNaN`) and then track the origin of the special value with the methods like those described here: https://skillsmatter.com/skillscasts/14905-agile-functional-data-pipeline-i… Never throw an error without telling exactly why it happened and exactly where to fix it :-). Using bottom is last resort; exceptions likewise. -- Cheers Michał

1 0

Re: [Haskell-cafe] Parsing XML
by Michal J Gajda 04 Aug '21

04 Aug '21

Dear John, I recommend Xeno: https://gitlab.com/migamake/xeno It was released on Hackage some time ago by Chris Done, then maintained by Marco Zocca. It was benchmarked against fastest parsers in both Haskell and other languages: * https://arxiv.org/abs/2011.03536 * http://neilmitchell.blogspot.com/2016/12/new-xml-parser-hexml.html It allows you to use SAX and DOM-style processing. It has an awesome memory efficiency that is surpassed only by PugiXML parser (which builds DOM in place, but occasionally crashes). It does not support some XML features (namespaces, entity normalization etc.), but these can be added as postprocessing after the DOM is built. It is maintained. And there is a yet unreleased version that can be used to parse HTML documents and documents that are not well formed. Disclosure: I am current maintainer. -- Cheers Michał J. Gajda

1 0

GHC 9.x on M1 mac?
by Stuart Hungerford 04 Aug '21

04 Aug '21

Hi Haskellers, Has anyone been able to build a 9.x series GHC installation for the M1 mac with macOS, in native binary form (i.e. not under Rosetta translation)? TIA, Stu

1 0

Why not some subclass of Floating to model NaNs as some handleable bottom?
by YueCompl 03 Aug '21

03 Aug '21

Dear Cafe, I kinda understand the [Floating](https://hackage.haskell.org/package/base/docs/GHC-Float.html#t:Fl… <https://hackage.haskell.org/package/base/docs/GHC-Float.html#t:Floating>) class doesn't care about NaN, as not expecting all floating point implementations to have such semantics. But [IEEE Silent NaN](https://en.wikipedia.org/wiki/NaN#Quiet_NaN <https://en.wikipedia.org/wiki/NaN#Quiet_NaN>) has become a norm today, I think it deserves more than mere [isNaN](https://hackage.haskell.org/package/base/docs/GHC-Float.html#v:isNaN <https://hackage.haskell.org/package/base/docs/GHC-Float.html#v:isNaN>) in the [RealFloat](https://hackage.haskell.org/package/base/docs/GHC-Float.html#t:R… <https://hackage.haskell.org/package/base/docs/GHC-Float.html#t:RealFloat>) class. While [Signaling NaN](https://en.wikipedia.org/wiki/NaN#Signaling_NaN <https://en.wikipedia.org/wiki/NaN#Signaling_NaN>) can be an `Exception` triggering bottom like "divide by zero" is, the silent `NaN` feels like a different kind of bottom, or some thing similar to `Nothing` as in the `Num a => Maybe a` monad? Is Haskell's type system capable of encoding silent NaN as a special kind/type of bottom that handleable? Though I don't think I've gained correct understanding at all, on "bottom"s, I'm interested in what options we have to encode them, especially ergonomics ways to handle them accordingly. Best regards, Compl

1 0

Sets, typeclasses and functional dependencies
by Stuart Hungerford 02 Aug '21

02 Aug '21

Hi Haskellers, After reading: https://stackoverflow.com/questions/34790721/where-is-the-set-type-class https://stackoverflow.com/questions/25191659/why-is-haskell-missing-obvious… https://stackoverflow.com/questions/11508642/haskell-how-can-i-define-a-typ… I can see why Haskell base does not provide typeclasses for sets. I'm wondering now though if I did create a Set typeclass what it would look like. There's several approaches using various language extensions and to me this approach using functional dependencies seems simpler than the other approaches: class Setish set a | set -> a where empty :: set singleton :: a -> set -- and so on. My question is how does the functional dependency in Setish interact with "extra" types needed for richer set operations like finding the powerset or taking a cartesian product? Something like: class Setish set a | set -> a where empty :: set singleton :: a -> set power_set :: set -> ?something product :: set -> ?something -> ?something -- and so on. TIA, Stu

4 5

Explanation of Data.Set, please
by Galaxy Being 02 Aug '21

02 Aug '21

I'm looking at this <https://hackage.haskell.org/package/containers-0.6.5.1/docs/src/Data.Set.In…> code and wondering, first, about the strategy behind the data type Set itself data Set a = Bin {-# UNPACK #-} !Size !a !(Set a) !(Set a) | Tip It says it's a "balanced tree." I found this <http://groups.csail.mit.edu/mac/users/adams/BB/index.html> talking about maybe why that is. Will read. But in the meantime, any explanation in plain English as to why we're doing it as a tree and not some other structure would be helpful. And why are we bringing Size along, and in general, why all the strictness !'s? All this might have something to do with why a balanced tree is better than quick-and-dirty list representation like I see in beginner tutorials? Next, is this ZFC? I've seen treatments that supposedly are ZFC-friendly. Finally, I've taken a preliminary look at Agda, and right from the start there's Set, and no doubt an entirely alternative, category universe approach to the concept of set theory. Any contrast and compare between Haskell and Agda's set notions would be appreciated. Haskell seems to dance in and out of Category Theory, while Agda seems pretty much just CT.... -- ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2

I want to read documents about haskell.
by Kim Chaegon 01 Aug '21

01 Aug '21

I want read documents about haskell, pure functional language. Rgank you!

2 1

Re: [Haskell-cafe] Help on syntactic sugar for combining lazy & strict monads?
by Olaf Klinke 30 Jul '21

30 Jul '21

On Thu, 29 Jul 2021, Benjamin Redelings wrote: > Hi Olaf, > > I think you need to look at two things: > > 1. The Giry monad, and how it deals with continuous spaces. I believe I understand the Giry monad well, and it is my measuring stick for functional probabilistic programming. Even more well-suited for programming ought to be the valuation monad, because that is a monad on domains, the [*] semantic spaces of the lambda calculus. Unfortunately, to my knowledge until now attempts were unsuccessful to find a cartesian closed category of domains which is also closed under this probabilistic powerdomain construction. [*] There are of course other semantics, domains being one option. > > 2. The paper "Practical Probabilistic Programming with Monads" - > https://doi.org/10.1145/2804302.2804317 Wasn't that what you linked to in your original post? As said above, measure spaces is the wrong target category, in my opinion. There is too much non constructive stuff in there. See the work of Culbertson and Sturtz, which is categorically nice but not very constructive. > > Also, observing 2.0 from a continuous distribution is not nonsensical. > > -BenRI Perhaps I am being too much of a point-free topologist here. Call me pedantic. Or I don't understand sampling at all. To me, a point is an idealised object, only open sets really exist and are observable. If the space is discrete, points are open sets. But on the real line you can not measure with infinite precision, so any observation must contain an interval. That aligns very nicely with functional programming, where only finite parts of infinite lazy structures are ever observable, and these finite parts are the open sets in the domain semantics. So please explain how observing 2.0 from a continuous distribution is not nonsensical. Olaf > > On 7/21/21 11:15 PM, Olaf Klinke wrote: >>> However, a lazy interpreter causes problems when trying to introduce >>> *observation* statements (aka conditioning statements) into the monad >>> [3]. For example, >>> >>> run_lazy $ do >>> x <- normal 0 1 >>> y <- normal x 1 >>> z <- normal y 1 >>> 2.0 `observe_from` normal z 1 >>> return y >>> >>> In the above code fragment, y will be forced because it is returned, and >>> y will force x. However, the "observe_from" statement will never be >>> forced, because it does not produce a result that is demanded. >> >> I'm very confused. If the observe_from statement is never demanded, then >> what semantics should it have? What is the type of observe_from? It seems >> it is >> a -> m a -> m () >> for whatever monad m you are using. But conditioning usually is a function >> Observation a -> Dist a -> Dist a >> so you must use the result of the conditioning somehow. And isn't the >> principle of Monte Carlo to approximate the posterior by sampling from it? >> I tend to agree with your suggestion that observations and sampling can not >> be mixed (in the same do-notation) but the latter have to be collected in a >> prior, then conditioned by an observation. >> >> What is the semantic connection between your sample and obsersvation monad? >> What is the connection between both and the semantic probability >> distributions? I claim that once you have typed everything, it becomes >> clear where the problem is. >> >> Olaf >> >> P.S. It has always bugged me that probabilists use elements and events >> interchangingly, while this can only be done on discrete spaces. So above I >> would rather like to write >> (2.0==) `observe_from` (normal 0 1) >> which still is a non-sensical statement if (normal 0 1) is a continuous >> distribution where each point set has probability zero. >

1 0

Re. Looking for exemplars of "boring" or "simple" Haskell projects... (Rishiyur Nikhil)
by Stuart Hungerford 29 Jul '21

29 Jul '21

On Thu, Jul 29, 2021 at 10:07 PM <haskell-cafe-request(a)haskell.org> wrote: > [...] > A couple of years ago I wrote "Forvis", a "complete" semantics of the > RISC-V instruction set in "extremely elementary" Haskell. > > It's free and open-source, at: > https://github.com/rsnikhil/Forvis_RISCV-ISA-Spec > > "Extremely Elementary" Haskell: small subset of Haskell 98. No > type classes, no monads (except the top-level driver that uses > standard IO), no GHC extensions, nothing. Just vanilla function > definitions and vanilla algebraic types (a "Miranda" subset). > > Motivation: appeal to hardware designers, compiler writers, and others > who are keenly interested in a clearly readable and executable precise > spec of RISC-V semantics, but are not at all interested in learning > Haskell. Thanks for that, I'll have a look. Stu

1 0

Re. Looking for exemplars of "boring" or "simple" Haskell projects...
by Rishiyur Nikhil 28 Jul '21

28 Jul '21

A couple of years ago I wrote "Forvis", a "complete" semantics of the RISC-V instruction set in "extremely elementary" Haskell. It's free and open-source, at: https://github.com/rsnikhil/Forvis_RISCV-ISA-Spec "Extremely Elementary" Haskell: small subset of Haskell 98. No type classes, no monads (except the top-level driver that uses standard IO), no GHC extensions, nothing. Just vanilla function definitions and vanilla algebraic types (a "Miranda" subset). Motivation: appeal to hardware designers, compiler writers, and others who are keenly interested in a clearly readable and executable precise spec of RISC-V semantics, but are not at all interested in learning Haskell. It's about 12K-13K lines of Haskell, all in one 'src/' directory. Full "standard ISA" coverage: - Unprivileged ISA: - RV32I (32-bit) and RV64I (64-bit) basic Integer instructions - Standard ISA extensions M (Integer Mult/Div), A (Atomics), C (Compressed) and FD (Single- and Double-precision floating point) - Privileged ISA: Modes M (Machine), S (Supervisor) and U (User), including full complement of CSRs (Control and Status Registers). This includes full trap and interrupt handling, and RISC-V Virtual Memory schemes Sv32, Sv39 and Sv48. I've tested it on all the standard RISC-V ISA tests (pass), booted a Linux kernel (about 200 Million RISC-V Instructions), and the much smaller real-time OS FreeRTOS. I'm sure it'll work for any other RISC-V software as well. For this, the sources contain additional code to package the "CPU" into a small "system", by adding Haskell models of memory and a UART. I haven't looked at it since early 2020, but it should all still work fine. Nikhil

1 0