- Haskell-Cafe - Haskell.org

Approaches for a DSL for API-level testing
by Damian Nadales 19 Jan '17

19 Jan '17

Hello, I'm writing an embedded DSL for API level testing. The idea in a nutshell is that I can write tests like the following one: createProjectCreates = do p <- createProject "foobar" ps <- getProjects ps `shouldContain` p Here http://stackoverflow.com/questions/41740658/separating-concerns-in-a-dsl-us… I show a sketch of the solution I'm working on, and the issues I'm running into. I wonder whether there are other approaches to embedded DSL writing in Haskell that allows for a better compositionality and separation of concerns. Thanks! Damian.

1 0

[ANNOUNCE] Glasgow Haskell Compiler 8.0.2 is available!
by Ben Gamari 19 Jan '17

19 Jan '17

=============================================== The Glasgow Haskell Compiler -- version 8.0.2 =============================================== The GHC team is happy to at last announce the 8.0.2 release of the Glasgow Haskell Compiler. Source and binary distributions are available at http://downloads.haskell.org/~ghc/8.0.2/ This is the second release of the 8.0 series and fixes nearly two-hundred bugs. These include, * Interface file build determinism (#4012). * Compatibility with macOS Sierra and GCC compilers which compile position-independent executables by default * Compatibility with systems which use the gold linker * Runtime linker fixes on Windows (see #12797) * A compiler bug which resulted in undefined reference errors while compiling some packages (see #12076) * A number of memory consistency bugs in the runtime system * A number of efficiency issues in the threaded runtime which manifest on larger core counts and large numbers of bound threads. * A typechecker bug which caused some programs using -XDefaultSignatures to be incorrectly accepted. * More than two-hundred other bugs. See Trac [1] for a complete listing. * #12757, which lead to broken runtime behavior and even crashes in the presence of primitive strings. * #12844, a type inference issue affecting partial type signatures. * A bump of the `directory` library, fixing buggy path canonicalization behavior (#12894). Unfortunately this required a major version bump in `directory` and minor bumps in several other libraries. * #12912, where use of the `select` system call would lead to runtime system failures with large numbers of open file handles. * #10635, wherein -Wredundant-constraints was included in the -Wall warning set A more detailed list of the changes included in this release can be found in the release notes, https://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/8.0.2-notes.… Please note that this release breaks with our usual tendency to avoid major version bumps of core libraries in minor GHC releases by including an upgrade of the `directory` library to 1.3.0.0. Also note that, due to a rather serious bug (#13100) affecting Windows noticed late in the release cycle, the Windows binary distributions were produced using a slightly patched [2] source tree. Users compiling from source for Windows should be certain to include this patch in their build. This release is the result of six months of effort by the GHC development community. We'd like to thank everyone who has contributed code, bug reports, and feedback to this release. It's only due to their efforts that GHC remains a vibrant and exciting project. [1] https://ghc.haskell.org/trac/ghc/query?status=closed&milestone=8.0.2&col=id… [2] http://downloads.haskell.org/~ghc/8.0.2/0001-SysTools-Revert-linker-flags-c… How to get it ~~~~~~~~~~~~~ Both the source tarball and binary distributions for a wide variety of platforms are available at, http://www.haskell.org/ghc/ Background ~~~~~~~~~~ Haskell is a standardized lazy functional programming language. The Glasgow Haskell Compiler (GHC) is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating efficient code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces. GHC is distributed under a BSD-style open source license. Supported Platforms ~~~~~~~~~~~~~~~~~~~ The list of platforms we support, and the people responsible for them, can be found on the GHC wiki http://ghc.haskell.org/trac/ghc/wiki/Platforms Ports to other platforms are possible with varying degrees of difficulty. The Building Guide describes how to go about porting to a new platform: http://ghc.haskell.org/trac/ghc/wiki/Building Developers ~~~~~~~~~~ We welcome new contributors. Instructions on getting started with hacking on GHC are available from GHC's developer site, http://ghc.haskell.org/trac/ghc/ Community Resources ~~~~~~~~~~~~~~~~~~~ There are mailing lists for GHC users, develpoers, and monitoring bug tracker activity; to subscribe, use the web interfaces at http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets There are several other Haskell and GHC-related mailing lists on www.haskell.org; for the full list, see https://mail.haskell.org/cgi-bin/mailman/listinfo Some GHC developers hang out on the #ghc and #haskell of the Freenode IRC network, too: http://www.haskell.org/haskellwiki/IRC_channel Please report bugs using our bug tracking system. Instructions on reporting bugs can be found here: http://www.haskell.org/ghc/reportabug

3 3

Re: [Haskell-cafe] Control.Parallel seemingly randomly behaviour
by Johannes Waldmann 19 Jan '17

19 Jan '17

Hi Juan, I am interested in this because I use Control.Parallel in teaching currently. But - * what is your actual Main program / main function (it was not included in your message?) * what is your actual cabal / stack config file? * on what machine (OS, CPU) are you running this (it seems pretty slow)? * have you looked at eventlogs with threadscope? - J.

2 1

Yesod devel issue: cannot satisfy -package-key main
by Geraldus 18 Jan '17

18 Jan '17

Hi folks! I haven't used Yesod quite a while; now when I'm trying to run development server of freshly scaffolded PostgreSQL stack's template I see this error message: Rebuilding application... (using cabal) Starting development server... *<command line>: cannot satisfy -package-key main* (use -v for more information) Exit code: ExitFailure 1 I've found several issues on the web, however I wasn't able to resolve this. I've tried to upgrade my Yesod binary first via `stack install yesod-bin`. Now I have: stack exec yesod version *yesod-bin version: 1.4.18.7* stack --version *Version 1.1.2 x86_64 hpack-0.14.0* I also tried to comment out the test suite section in cabal file, but devel server still fails to run. Can someone clarify how to deal with this?

2 2

Re: [Haskell-cafe] Hyper-recursion?
by Olaf Klinke 18 Jan '17

18 Jan '17

If I may step into this discussion, I'd like to suggest you start modelling your world of parcels more concretely, as data types. From there it should be easier to grasp our hyper-recursion. Question: Does every parcel have its own time, or is there a universal clock ticking in the background? If you have a uiversal clock, you could model your world as a linear series of state changes, stretching infinitely into the past and future. Hence two streams going out form a "now" would be the overarching data type. This has been used e.g. for doubly linked lists. Doesn't functional reactive programming use a similar model? Question: How does one identify a parcel of land? Is it a polygon of coordinates in some reference system? Hence can the state be seen as a finite set of (Polygon,Owner) pairs? Question: What is more important: The state or the state change? If the state is more important, a kind of graph might be the appropriate data structure. If the change is important, it might be interesting to model the world (and time) as a network of functions. Question to all mathematicians on this list: Suppose (again assuming a universal clock) there is a type (a set?) X and a function change :: Integer -> (X -> X) where the state of "now" is to be understood as the value now = change 0 . change (-1) . change (-2) . {...ad infinitum} Under which circumstances does this determine the value of "now"? The only instance I can think of are contractions on a (compact) metric space. (Brouwer's/Banach's fixed point theorems) I second the contributors who suggest that this has not much to do with recursion nor corecursion. To me, the essence of recusion is self-reference. A function building e.g. an infinite stream from a seed is not self-referential in itself, it is the resulting data that is self-referential. Olaf

3 2

[ANN] FloatingHex: Hexadecimal floats (quasiquoter and pretty-printer)
by Levent Erkok 18 Jan '17

18 Jan '17

FloatingHex (http://hackage.haskell.org/package/FloatingHex) is a simple package that implement hexadecimal notation for floating point numbers, as described in p57-58 of http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf The package provides a quasi-quoter for hexadecimal floats: hf, and a pretty-printer for floats to show them in this notation: showFFloat. (Note that the latter is not 100% compatible with C's %a modifier for printf, but it does render a faithful representation of its input.) Hex-floats are useful as they allow writing floating-point constants without any loss of precision, while remaining human readable. For instance, the float 2 is written as 0x1p1. (With the quasiquoter, the syntax is [hf|0x1p1|].) This representation is to be preferred over decimal rendering where loss of precision can be a problem: Note that not all floating point numbers have a terminating decimal representation as currently required by the Haskell syntax. It would be nice if Haskell itself allowed for such literals in the language specs itself, following the recent changes to other language standards. (Again, see p57-58 of http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf for the new C standard.) In the mean time, I hope FloatingHex library will provide a workaround for the numerophilias amongst us. Bug reports and improvements always welcome! Cheers, -Levent.

2 3

[ANN] Haskell ITA meetup in Milan, Italy (2017-02-25)
by Francesco Ariis 18 Jan '17

18 Jan '17

Good evening -cafe, the italian Haskell Community (http://haskell-ita.it/) is happy to announce its winter Haskell meetup. The event is going to be hosted in Milano, on February 25th (Saturday). It will be kindly hosted by MIKAMAI [1], Via Giulio e Corrado Venini, 42 - 20127 Milano (MI), IT [1] https://www.mikamai.com/ To register, check: https://www.metooo.io/e/incontro-haskell-ita-inverno-2017 Any haskeller (beginner, experienced, curious) is welcome! *** italian follows *** Buonasera a tutti, abbiamo finalmente deciso la data dell'incontro invernale di Haskell-ITA! Ci riuniremo il 25 Febbraio 2017 (un Sabato), presso MIKAMAI [1], che gentilmente mette i locali a disposizione. [1] https://www.mikamai.com/ L'indirizzo è: Via Giulio e Corrado Venini, 42 - 20127 Milano (MI), IT Per registrarvi: https://www.metooo.io/e/incontro-haskell-ita-inverno-2017

1 0

A question on datakinds syntax
by Haiwei Zhou 17 Jan '17

17 Jan '17

Hi, I am reading the document of spock-0.11, and found two strange definitions in the Web.Spock. ```` type Var a = Path ((:) * a ([] *)) Open var :: (Typeable * a, PathPiece a) => Path ((:) * a ([] *)) Open ```` What's the meaning of the star between Typeable and a ? The kind of Typeable is * -> *. I cannot understand why the Typeable in the var prototype takes two kinds. In the Web.Routing.Combinators of reroute-0.4, those are defined as following: ```` type Var a = Path (a ': '[]) Open var :: (Typeable a, PathPiece a) => Path (a ': '[]) Open ```` Why there are two difference definition about the same thing? Thanks, Haiwei

3 2

Control.Parallel seemingly randomly behaviour
by Juan Luis Martty 17 Jan '17

17 Jan '17

Hello everyone, I'm having a consistency issue with the following piece of code: heavyAm = 500 lightAm = 1000 heavyCalc :: Int -> Int heavyCalc s = sum [1..1000000*s] parallel = (heavyCalc lightAm, heavyCalc heavyAm) `using` (parTuple2 rseq rseq) For some reason, during runtime the RTS sometimes parallelizes the evaluation and sometimes it doesn't. I'm running with all the RTS/compile time options correctly afaik. Here is the output from a couple of runs of the program: jmartty@walrus:~/hs/parallel$ stack build && time stack exec par-exe Warning: File listed in par.cabal file does not exist: README.md (500000000500000000,125000000250000000) Computation time: 1.557007s real 0m1.732s user 0m2.528s sys 0m0.464s jmartty@walrus:~/hs/parallel$ stack build && time stack exec par-exe Warning: File listed in par.cabal file does not exist: README.md (500000000500000000,125000000250000000) Computation time: 1.544837s real 0m1.720s user 0m2.544s sys 0m0.712s jmartty@walrus:~/hs/parallel$ stack build && time stack exec par-exe Warning: File listed in par.cabal file does not exist: README.md (500000000500000000,125000000250000000) Computation time: 2.316537s real 0m2.484s user 0m2.592s sys 0m0.680s jmartty@walrus:~/hs/parallel$ stack build && time stack exec par-exe Warning: File listed in par.cabal file does not exist: README.md (500000000500000000,125000000250000000) Computation time: 2.318514s real 0m2.489s user 0m2.612s sys 0m0.688s jmartty@walrus:~/hs/parallel$ stack build && time stack exec par-exe Warning: File listed in par.cabal file does not exist: README.md (500000000500000000,125000000250000000) Computation time: 1.544975s real 0m1.718s user 0m2.512s sys 0m0.456s As you can see, sometimes wall time roughly equals userspace time, sometimes it doesn't (meaning it parallelized at least some amount). I'm running on a dual core machine under Ubuntu using stack with lts-7.14 (GHC 8.0.1) and parallel-3.2.1.0. Regards, Juan

2 3

Re: [Haskell-cafe] Hyper-recursion?
by Anthony Clayden 17 Jan '17

17 Jan '17

>> On 16 Jan 2017 04:43, "Lawrence Bottorff" <borgauf at gmail.com> wrote: >> >> A while back I worked at an assessor's office, i.e., the people responsible >> for handling properties as land parcels. ... Hi Lawrence, I too worked on land parcels -- a local government rates billing and land valuation application. >> ... how property changed hands, and especially how property lines >> changed due to properties either merging or being split up. >> That is to say, how the parcel map changed over time. I think the important aspect is that the a parcel can be split, and one of the splits merged with another parcel that was not originally with it. (I don't know how it was in your application. but in mine a legal parcel might consist of discontiguous areas of land -- for example a house in a terrace parcelled with a garage amongst a block of garages at the end of the street,) That is, looking over history you cannot group the parcels into a strict hierarchy of splits. >> Somewhere in the functional paradigm, specifically recursion, >> would seem to be a model for this issue. No I'm not seeing anything specifically functional about this. It's a directed graph, where each node is an instance of parcel ownership. >> So in chapter 1 of any functional programming tutorial is the factorial >> calculation function done with recursion. We beginners see the recursion >> "going out" to the "last one," then "coming back," adding up the results of >> each stage as it returns . . . like a yo-yo winding out, >> then winding up again. Nice image, but there's no "last one" here (nor a "first one" that we could make sense of), There's no boundary from where we could be "coming back". Recursion does not apply [see more below] >> David Turner dct25-561bs at mythic-beasts.com >> Mon Jan 16 07:47:41 UTC 2017 >> >> I suspect you have stumbled onto the dual concept of corecursion: ... Nor corecursion. a) because of the infinite and arbitrary potential for splits/mergers; b) because even if there was some time in the distant past when the whole country was a single parcel with a single owner. (The Emperor? But even empires and countries split and merge. Or no owner, only hunter-gatherers/nomads, which might as well be a single parcel.) We're never going to try to rebuild that history. c) because there's never going to be a future end-state. Arbitrary splits/mergers will continue forever. We can't predict what might be the smallest parcels some area of land could be split into. (Note that one trick to prevent mineral exploitation companies from buying up glorious scenery is to split it into $1-parcels and sell each to a different owner.) >> ... Haskell being the most pure functional language, is, hence, >> my starting point on this question. There's nothing specifically Haskell in this. A better place to ask might be lambda-the-ultimate. Anthony

4 3