- Haskell-Cafe - Haskell.org

Simply and easy graphical toolkit?
by Christopher Howard 24 Sep '15

24 Sep '15

Hi. What would be the simplest and easiest Haskell graphical toolkit to use? I remember a few years ago I tried Gloss and was really happy with it, but I also wanted to be able to have a few buttons and text fields on the screen for user input, without having to build them from scratch. -- http://justonemoremathproblem.com/

5 4

ANN: The Herbie GHC Plugin
by Mike Izbicki 24 Sep '15

24 Sep '15

80% of packages in stackage that contain floating point expressions have numerically unstable expressions. The Herbie GHC plugin automatically makes these expressions numerically stable. You can find the project on github at: https://github.com/mikeizbicki/HerbiePlugin

8 17

ANN: CfN for new Haskell Prime language committee
by Herbert Valerio Riedel 23 Sep '15

23 Sep '15

Dear Haskell Community, In short, it's time to assemble a new Haskell Prime language committee. Please refer to the CfN at https://mail.haskell.org/pipermail/haskell-prime/2015-September/003936.html for more details. Cheers, hvr -- PGP fingerprint: 427C B69A AC9D 00F2 A43C AF1C BA3C BA3F FE22 B574

1 0

ANN: FunGEn-1.0 - easy-to-install cross-platform game engine
by Simon Michael 21 Sep '15

21 Sep '15

I'm pleased to announce the release of FunGEn 1.0 ! What is it ? FunGEn (Functional Game Engine) is the oldest game engine in Haskell. It was created by Andre Furtado in 2002, has never been used since, and yet it is arguably still the easiest and most practical way to make a video game using Haskell. It is BSD-licensed, installs easily on unix, mac and windows, does not use FRP, and comes with two playable example games. What does it do ? Here's Andre's original feature list: - Initialization, updating, removing, rendering and grouping routines for game objects; - Definition of a game background (or map), including texture-based maps and tile maps; - Reading and intepretation of the player's keyboard input; - Collision detection; - Time-based functions and pre-defined game actions; - Loading and displaying of 24-bit bitmap files; - Some debugging and game performance evaluation facilities; - Sound support (actually for windows platforms only... :-[ ) What's new in 1.0 ? - supports GHC 7.10 - supports stack - the repo (and project) has moved to the haskell-game organization on Github How to install $ cabal update $ cabal install FunGEn # ensure ~/.cabal/bin or windows equiv. is in your PATH or $ git clone https://github.com/haskell-game/fungen $ cd fungen $ stack install How to run the examples $ fungen-hello $ fungen-pong $ fungen-worms More info http://hackage.haskell.org/package/FunGEn https://github.com/haskell-game/fungen http://joyful.com/fungen - old home page Why ? I think FunGEn still has some value, for building games and also as an example of how to structure games in haskell. I don't have time to do much with it, so I've moved it to the haskell-game organization, where all org members now have push access. I'd like it to be as open as possible to contributors, and am seeking a new or co- maintainer. Best, -Simon (sm on #haskell-game)

1 0

GSoC Retrospective
by Dominic Steinitz 20 Sep '15

20 Sep '15

In past years, Gwern did an outstanding job of summarising the GSoC proposals and how well they had done: http://www.gwern.net/Haskell%20Summer%20of%20Code <http://www.gwern.net/Haskell%20Summer%20of%20Code> Here are the proposals for this year. Perhaps students or their mentors could comment on how successful their projects have been? I realise this is a very poor substitute for Gwen’s analyses but it would better than nothing. A Strict language pragma for GHC - Adam Sandberg Eriksson <https://github.com/adamse> STM Data Structures Implementation <https://gist.github.com/Alllex/439480b7e80303f19ddc> - Alex Semin Implementation of Layered Gramamar of Graphics <https://gist.github.com/AjayRamanathan/c84a4641836700a2547b> - chinu <https://github.com/AjayRamanathan/Plot> Implementing Version Comparison for Cabal Packages - Craig Roche <https://github.com/cdxr> Improving Hackage Discoverability <http://dzackgarza.com/mockup/main.html> - D. Zack Garza <https://github.com/dzackgarza> Darcsden improvements <http://darcs.net/GSoC/2015-Darcsden> - Daniil Frumin <https://github.com/co-dan> Pursuit enhancements <https://gist.github.com/hdgarrood/0a389937149453c69e03> - Harry Garrood <https://github.com/hdgarrood> Improvements For HBLAS And Adding LAPACK Bindings. - JuejiYang A standalone functional parser for CommonMark <https://gist.github.com/Jubobs/7a9298eeaf02bcefbc35> - Julien Cretel <https://github.com/Jubobs> Refactor program with HLint suggestions <http://mpickering.github.io/gsoc2015.html> - Matthew Pickering <https://github.com/mpickering> Replication back-end for acid-state - Max Voit Native Haskell Type Encoding for LiquidHaskell <https://gist.github.com/spinda/b261167303515cc8a1d9> - Michael Smith <https://github.com/spinda> Exhaustiveness Checker for PureScript - Nicolas Del Piano <https://github.com/nicodelpiano> Fast splittable pseudorandom number generator for System.Random <https://gist.github.com/nkartashov/e46fd146b1df2d79aaf3> - Nikita Kartashov <https://github.com/nkartashov> Interactive widgets in IHaskell <https://github.com/sumitsahrawat/gsoc/blob/master/2015/ihaskell.pdf> - Sumit Sahrawat <https://github.com/sumitsahrawat> Improvements to yesod-devel - urbanslug <https://github.com/urbanslug> Implement nix-like package management features in cabal <https://gist.github.com/fugyk/37510958b52589737274> - Vishal Agrawal <https://github.com/fugyk> Haddock improvements - Łukasz Hanuszczak <https://github.com/mrhania> Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

6 9

MonadPlus and Alternative folds
by David Feuer 19 Sep '15

19 Sep '15

It kind of seems like there should be fold-like things to match some and many. foldrAlt :: Alternative f => (a -> b -> b) -> b -> f a -> f b foldrAlt c n m = foldr1Alt c n m <|> pure n foldr1Alt :: Alternative f => (a -> b -> b) -> b -> f a -> f b foldr1Alt c n m = c <$> m <*> foldrAlt c n m foldlMP' :: MonadPlus f => (b -> a -> b) -> b -> f a -> f b foldlMP' f b m = foldl1MP' f b m <|> pure b foldl1MP' :: MonadPlus f => (b -> a -> b) -> b -> f a -> f b foldl1MP' f b m = m >>= \r -> let !b' = f b r in foldlMP' f b' m --These look a bit iffy foldlAlt :: Alternative f => (b -> a -> b) -> b -> f a -> f b foldlAlt f b m = ($ b) <$> foldrAlt (\x r acc -> r (f acc x)) id m foldl1Alt :: Alternative f => (b -> a -> b) -> b -> f a -> f b foldl1Alt f b m = ($ b) <$> foldr1Alt (\x r acc -> r (f acc x)) id m Do these or similar exist somewhere? If not, should they exist somewhere? I'm particularly interested in whether either of these will be fast, or will admit a fast implementation, for attoparsec parsers. Thanks, David Feuer

3 6

Re: [Haskell-cafe] MonadPlus and Alternative folds
by Olaf Klinke 19 Sep '15

19 Sep '15

Is there an instance of Alternative where some and many are not bottom? The usual example monads, [] and Maybe, don't serve as a source of intuition. In general I agree with David: If f is a functor such that every type (f a) is a monoid, then there should be folds. The usual question here is: Your functions have types more general than the known foldr and foldl. Do your functions specialize to the known ones? It seems not. For example, foldrAlt (+) 0 [1,2,3] diverges, and so does foldlMP' (+) 0 [1,2,3]. I have doubts that knowing how to append two lists gives you access to the recursive structure of a list. Note that mplus is a _constructor_ of lists, while recursion is built on _destructors_. The same seems to apply to all other functions provided by Applicative, Alternative and MonadPlus. The foldr of Data.Foldable, by contrast, accepts a foldable structure and produces something which is not a foldable structure. Hence it must have access to the internals of that foldable structure. Olaf

2 1

Why Haskell is beautiful to the novice
by Olaf Klinke 19 Sep '15

19 Sep '15

Dear cafe, please correct me if questions like this should not go via this mailing list. Presumably everyone on this list agrees that Haskell stands out as a beautiful and pleasant language to have. The recent nitpicking and real-world problems like cabal hell don't change that. However, statements supporting Haskell's beauty usually involve: "In Haskell it is so much clearer/easier/faster to ... than in another language." That is, the beauty of Haskell presents itself to those who can compare it to other imperative or not strongly typed languages that one learned before Haskell. My question is, for what reason should anyone not acquainted with any programming language find Haskell beautiful? Maybe it does not look beautiful at all to the novice. The novice can not draw on the comparison, unless he takes the effort to learn more than one language in parallel. The novice likely also does not have the mathematical background to see the beautiful correspondence between the language and its semantics. (My reason to love FP is because it is executable domain theory.) One might argue that it is not the language itself that is beautiful, but rather the concepts (data structures, algorithms, recursion) and Haskell does a great job to preserve their beauty into the implementation. Do you agree? Disclaimer: I am about to start teaching a first course in computer science in secondary school. I can teach whatever I want, since this is the first CS course the school ever had. I want to teach beautiful things. I love functional programming. I need not start teaching programming right away. But I am reluctant to expose the pupils to something whose beauty escapes them completely. -- Olaf

29 79

persistent sqlite: getting record by ID
by miro 19 Sep '15

19 Sep '15

Please, can you help me with following? I’m trying to get a record from sqlite by id. I have found following peace of code,…but I’m missing the place that where can I specify the table I’m actually querying (like PersonId). get $ Key $ (PersistInt64 $ fromIntegral id) Cheers, Miro

2 1

Looking for better than Dragon Book
by Michael Litchard 18 Sep '15

18 Sep '15

I've got the Tiger Book, ML version, which I will use to help me implement Tiger in Haskell. Below is a class curriculum I've found. But besides the Tiger Book, it uses the Dragon Book. I know there are more modern books out there. Looking for suggestions as what might be a good fit. http://cs.nyu.edu/courses/fall13/CSCI-GA.2130-001/

4 4

London Haskell eXchange & Haskell Infrastructure Hackathon
by Oliver Charles 18 Sep '15

18 Sep '15

Hi all, In October Skills Matter & Well-Typed are organising a few Haskell events in London that will (I expect!) be of interest to people here. On the 8-9th of October is the Haskell eXchange, a 2-day conference on various topics about Haskell. The programme includes a variety of topics from the theoretical to the practical, with a mixture of talks, keynotes, lightning talks and workshop. A promo-code is valid until Sept 19th for 25% off - use HASKELL-EXCHANGE-25. For more details and booking, see https://skillsmatter.com/conferences/7069-haskell-exchange-2015. Shortly after the Haskell eXchange, Well-Typed will co-organize and participate in a two-day Haskell Hackathon <https://skillsmatter.com/conferences/7316-haskell-hackathon-2015>, which takes place directly after the Haskell eXchange, 10-11th October. This Hackathon aims at bringing together Haskell developers – both beginners and experts – who want to help improve the Haskell infrastructure, predominantly Hackage and Cabal. We’ll aim to arrange some introductory overview talks, to e.g. provide an overview over the code bases and the most important open issues. Participation is free, but please register online: https://skillsmatter.com/conferences/7316-haskell-hackathon-2015. Hope to see you there! ocharles

1 0

Replication class
by David Feuer 18 Sep '15

18 Sep '15

A number of types support some version of replication. Lists and vectors offer replicateM, while sequences have replicateA (the same thing, but generalized to Applicative). Is there, or should there be, a class for structures that support this operation?

2 2

Anchors in Haddock
by Sven Panne 17 Sep '15

17 Sep '15

Haddock offers a way to add anchors to the documentation and to link to them, see https://www.haskell.org/haddock/doc/html/ch03s08.html#idm140354810720016. I've got

1 1

Linking to anchors in Haddock
by Sven Panne 17 Sep '15

17 Sep '15

Haddock offers a way to add anchors to the documentation and to link to them, see https://www.haskell.org/haddock/doc/html/ch03s08.html#idm140354810720016. I've got 2 problems with that: * A link to an anchor "Foo.Bar#Baz" is always rendered with the text "Foo.Bar" in the HTML backend. Is there a way to change that? With the HTML backend I actually want something like: <a href="path-to-Foo.Bar#Baz">My own link text</a> * Using relative hype [My own link text](Foo-Bar.html#Baz) instead has problems, too: The "Foo-Bar.html" part is fragile and depends on Haddock flags. Furthermore, when using the LaTeX backend, the resulting LaTeX code is broken (the '#' needs an escaping backslash). So is there a non-fragile way working with several backends which makes it possible to specify the link text? Staring at the Haddock docs and the Haddock source code didn't help, and several experiments gave no clue, either. :-/

1 0

test socket buffer full
by Alberto G. Corona 17 Sep '15

17 Sep '15

Hi haskellers I´m implementing a form of intelligent streaming among nodes so that a process could know if there are bottlenecks on sending/receiving data so the process can increase or decrease the number of worker threads, for example. For this purpose, I planned to use hPutBufNonBlocking and hGetBufNonBlocking to detect when the buffer is full, using block buffering. I created hPutStrLn' that tries to write the entire string in the buffer. if it does not fit, the process would be notified in a state variable, then it would do a flush of the buffer and the rest of the string would be sent with hPutBuf. Doing some tinkering here and there It came up to be this: hPutStrLn' h str= do let bs@(PS ps s l) = BS.pack $ str ++ "\n" n <- withForeignPtr ps $ \p-> hPutBufNonBlocking h (p `plusPtr` s) l when( n < l) $ do error "BUFFER FULLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL" hFlush h withForeignPtr ps $ \p -> hPutBuf h ( p `plusPtr` (n * sizeOf 'x' ) ) (l - n) return () The error condition is the one that I expected to detect in the tests. In the real code, this line just would set a state variable, that would be read by the process somewhere else. The problem is that this routine behaves identically to hPutStrLn. The error condition never happens and hPutBufNonBlocking send the complete string every time. I created a program https://gist.github.com/agocorona/6568bd61d71ab921ad0c The example print the output of the receiver "hello" continuously Note that in the complete running code below, the receiver has a threadDelay of a second, so the send and receive buffers should be full. That happens in Windows and Linux, in a single process (like in the example) or within two processes in the same machine. How the processes can detect the congestion? -- Alberto.

3 8

Simple question about blackholing
by Kei Davis 16 Sep '15

16 Sep '15

Hello, By all accounts I've found a thunk is blackholed by replacing its header with a (the) blackhole code pointer (or blackhole info pointer in the unregisterized case). My simple-minded question is how garbage collection can take place given that the layout of the payload is lost. Surely not a custom blackhole for each (statically defined) thunk? A list of blackholes maintained somewhere that the GC knows about? Thanks for any insight! Kei -- Kei Davis Applied Computer Science Group CCS-7, Mail Stop B287 Los Alamos National Laboratory Los Alamos, NM 87545, U.S.A.

2 3

Converting EpochTime to Integer
by Bram Neijt 16 Sep '15

16 Sep '15

Dear Haskell cafe, I want to convert form mtime :: System.Posix.Types.EpochTime to something aeson can eat without having to define an instance. I choose Integer. My current solution[1] is just using (read . show). I know, ugly, but the only thing I could get going. What is the proper way to convert System.Posix.Types.EpochTime to Integer or something else aeson will automatically convert without making a ToJSON instance? As a beginner I wonder: is there a general way to go about finding conversion paths between types? Greetings, Bram Neijt [1] https://github.com/bneijt/httpmtimeline/blob/master/src/Main.hs#L21

6 11

Re: [Haskell-cafe] Powerset of a set
by Olaf Klinke 16 Sep '15

16 Sep '15

Jerzy is right, of course. I should have issued the warning to Jorge: If you just want to understand how to compute the powerset, don't look into filterM. But in a way, filterM works like Jerzy's Prolog example: filterM (const [False,True]) [] = [[]] -- filterM is defined via foldr with base case (return []). filterM (const [False,True]) (x:xs) = do includeFirstElement <- [False,True] -- in reality, includeFirstElem <- const [False,True] x subsetOfxs <- filterM (const [False,True] xs) -- recursive call. return (if includeFirstElement then x:subsetOfxs else subsetOfxs) In order to produce a sublist of a list, we need to decide for each element if we want to include it in the sublist. That is, a sublist of xs :: [a] can be obtained by running filter (p :: a -> Bool) xs for some decision procedure p. The type of filterM allows the decision procedure to give more than one answer. In our case, the p, when asked "Should we include this particular element in the sublist?" always answers "Yes and No!". Is there a monad transformer generalisation of filterM, where the monad [] is replaced by other monad(-transformer)s? Recall that many monad transformers rely on distributive laws. class Distributive t where distrib :: (Monad m) => t (m a) -> m (t a) instance Distributive [] where distrib = sequence The term \p -> liftM (\x -> liftM (\b -> if b then return x else mzero) (p x)) can be given the type (Monad m, MonadPlus t) => (a -> m Bool) -> t a -> t (m (t a)) Therefore the term \p -> (liftM join).distrib.(liftM (\x -> liftM (\b -> if b then return x else mzero) (p x))) can be given the type (MonadPlus t,Distributive t, Monad m) => (a -> m Bool) -> t a -> m (t a) Indeed for t = [] it is equivalent to filterM. To explain what's going on, notice that sequence :: Monad m => [m a] -> m [a] computes, when m = [], all possible ways of picking one element from each list in a list of lists. One could say that sequence produces choice functions. I used sequence above: To compute the powerset of a set, replace each element x by the set {{},{x}}, then compute all choices, and then take the union of each such choice. -- Olaf

1 0

Sound advice
by Mike Meyer 16 Sep '15

16 Sep '15

I'm looking for advice on generating sounds from a desktop app. I'm perfectly happy if it doesn't have a GUI, but runs from the command line. The desire is to take a config file for an embedded device that encodes tunes it plays back and play them on the desktop. The data could be represented as: type Note = Integer type Duration = Integer data Tone = Tone Note Duration newtype Tune = Tune [Tone] [N.B. - I don't necessarily plan on using the above, I just wanted to illustrate the types. Now I just need to play back the resulting tune. Looking through hackage and hoogle find a number of sound libraries, but they either seem to be targeted at manipulating audio files and the data therein, or dealing with midi events and associated devices. I suspect that at least one of them can do what I want, but before I start delving into one I'd like to know that it can do this with minimal extra code and pain. So, anyone want to suggest a library for this task? Thanks, <mike

4 3

Re: [Haskell-cafe] [haskell art] the library of beautiful instruments implemented in haskell / csound
by Anton Kholomiov 16 Sep '15

16 Sep '15

Alas there is no CsdSco typeclass anymore. The original idea was to implement score type with the most basic type and give the user a chance to write converters and use score playing functionality by the class CsdSco. But I've noticed that this approach was preventing me from using advanced score structures (they are implemented in the separate package). And type signatures become scary for the novice. So I've settled down the type. It's like choosing between Prelude.List ListLike.List. I've decided to pick the simplest one. You can write your own converter to the `Sco` type. ```` type Sco a = Track <http://hackage.haskell.org/package/temporal-media-0.6.0/docs/Temporal-Media…> D <http://hackage.haskell.org/package/csound-expression-4.8.2/docs/Csound-Type…> a ``` The `Track` comes from temporal-media package. It's very easy to construct it from list of events. One possible solution: ``` type Note = (Double, Double, a) fromEvents :: [Note] -> Sco a fromEvents = har . fmap f where f (start, duration, a) = del (double start) $ str (double duration) $ temp a ``` Notice the need for converting to csound doubles (`D`s). The `har` is parallel composition. `del` is for delaying nd `str` is for stretching in time domain. `temp` creates an event that lasts for one seconds and starts right away. I don't know your type, but I think it can be rendered to a list of notes. Then you can plug the converter to the functions: `sco` or `atSco` (used for patches). Cheers, Anton 2015-09-15 22:11 GMT+03:00 Edward Lilley <ejlilley(a)gmail.com>: > Hi > > The most useful part of this (for me) is the ability to play midi-style > instruments at arbitrary frequencies, so this looks great! > > To that end, I'm looking for the definition of the 'CsdSco' typeclass, > as I want to write my own instance. It seems to be referenced in the > csound-expression documentation, and once in a code comment, but is > otherwise absent from the source. Indeed, installing temporal-csound > from hackage fails with the error > > src/Csound.hs:135:10: > Not in scope: type constructor or class ‘CsdSco’ > > Where do I find it? > > thanks, > Edward > > Anton Kholomiov <anton.kholomiov(a)gmail.com> writes: > > > Status update for my haskell synth csound-expression. The main point is > > presence of many cool instruments. They are implemented in the package > > csound-catalog. All packages are compiled with GHC-7.10 So the hackage > > fails to build them and unfortunately docs a broken too. But you can look > > at the source code of the module Csound.Patch to now the names of the > > instruments. The usage is pretty straightforward. It's described here: > > > > > https://github.com/spell-music/csound-expression/blob/master/tutorial/chapt… > > > > There is an mp3 file to listen to the instruments. > http://ge.tt/1jNETqN2/v/0 > > > > *The 4.8.3 is out! New features:* > > > > This is a very important release to me. It tries to solve the problem > > present in the most open source music-production libraries. It's often > the > > pack of beautiful sounds/timbres is missing. User is presented with many > > audio primitives but no timbres are present to show the real power of the > > framework. This release solves this problem. See the friend package > > csound-catalog on Hackage. It defines 200+ beautiful instruments ready to > > be used. > > > > The csound-expression defines a new type called Patch for description of > an > > instrument with a chain of effects. It's good place to start the journey > to > > the world of music production. > > > > There are new functions for synchronized reaction on events. The > triggering > > of events can be synchronized with given BPM. > > > > The library is updated for GHC-7.10! > > > > > > github repo: https://github.com/spell-music/csound-expression > > > > hackage: http://hackage.haskell.org/package/csound-expression > > > > > > Cheers! > >

1 0

ANN ghc-mod-5.4.0.0, now with Stack support!
by Daniel Gröber 16 Sep '15

16 Sep '15

I'm pleased to announce the release of ghc-mod 5.4.0.0! What's new? =========== * Stack support After countless requests ghc-mod now finally has first class Stack support. This should mostly Just-Work^TM there is one caveat though if `dist/setup-config` exists in a Cabal-project directory ghc-mod will continue using cabal-install instead of Stack so if you want to use Stack instead simply remove that file or the whole directory. You also need at least Stack version 0.1.4.0 for this to work. * Support for unsaved files Nikolay Yakimov (@lierdakil) has contributed support for remapping files in a project to temporary files so that the frontend can use these to communicate unsaved file contents to ghc-mod. This is currently supported by Atom's ide-haskell and ghc-mod own Emacs frontend. If you're using a different frontend you should probably nudge the maintainer to get this supported. * Massive slowdown has been fixed A bug causing recompilation checking to be skipped, introduced in v5.3.0.0, has been fixed and ghc-mod should be as responsive as `:reload` in ghci again. * Fixed `Cannot add module to context: not interpreted` When compilation output from a `cabal build` run were present in `dist/` ghc-mod would in certain cases throw this error. This bug was introduced in v5.3.0.0 and has now been fixed. What is ghc-mod? ================ ghc-mod is both a backend program for enhancing editors and other kinds of development environments with support for Haskell and a library for abstracting the black magic incantations required to use the GHC API in various environments, especially Cabal projects. The library is used by ambitious projects like HaRe[1] and mote[2]. Getting ghc-mod =============== GitHub: https://github.com/kazu-yamamoto/ghc-mod Hackage: http://hackage.haskell.org/package/ghc-mod Editor frontends: - Emacs (native): https://github.com/kazu-yamamoto/ghc-mod https://github.com/iquiw/company-ghc - Vim: https://github.com/eagletmt/ghcmod-vim https://github.com/eagletmt/neco-ghc - Atom: https://github.com/atom-haskell/ide-haskell https://github.com/andyfriesen/Helium Known issues ============ ghc-mod's `case`, `sig` and `refine` commands still do not work properly with GHC 7.10 (See https://github.com/kazu-yamamoto/ghc-mod/issues/438) Unless someone volunteers to fix this issue I will work towards repacing the features using mote[2] instead as the current code is, from my point of view, unmaintainable. If you do notice any other problems please report them: https://github.com/kazu-yamamoto/ghc-mod/issues ---- [1]: https://github.com/alanz/HaRe [2]: https://github.com/imeckler/mote

1 0

Re: [Haskell-cafe] Powerset of a set
by Olaf Klinke 15 Sep '15

15 Sep '15

This was one of the most woundrous moments I ever had with reading a Haskell library: If lists are used to represent finite sets (hence disregarding order and multiplicity of elements), then Control.Monad.filterM (const [False,True]) :: [a] -> [[a]] computes the powerset. Exercise for Jorge: Read the source code of filterM [*], understand what this function is doing, and why this indeed computes (a representation of) the powerset. Cheers, Olaf [*] http://hackage.haskell.org/package/base-4.8.1.0/docs/src/Control.Monad.html…

2 1

Haskell related search engines in the Opera browser
by Henk-Jan van Tuyl 15 Sep '15

15 Sep '15

L.S., It is easy to define the search facility of the Haskell wiki as a search engine in the Opera browser. Press alt-p to get to the preferences panel (details differ per Opera version) and define the following parameters for the new search engine: Name HaskellWiki Keyword hw Address https://wiki.haskell.org/Special:Search?search=%s Now you can enter, for example, hw wxHaskell on the URL bar, to get to the wxHaskell page on the Haskell wiki. Another option is to double click a word on a web page, right click on the word and select Search with -> HaskellWiki. Similarly, you can search with Hoogle: Name Hoogle Keyword h Address http://www.stackage.org/lts-2.22/hoogle?q=%s Hackage: Name HackageDB Keyword hd Address https://hackage.haskell.org/package/%s Hayoo: Name Hayoo Keyword hay Address http://holumbus.fh-wedel.de/hayoo/hayoo.html?query=%s Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

3 2

Re: [Haskell-cafe] Thoughts about redesigning "Num" type class
by Jerzy Karczmarczuk 15 Sep '15

15 Sep '15

Dominique Devriese comments my remark : > Could you mention, please, a system whose measures are for sure positive > reals, infinity included? here: > I think he's talking about the mathematical notion of measure: > https://en.wikipedia.org/wiki/Measure_(mathematics) Gosh, I should have read Olaf Klinke somewhat slower... But I was a physicist too long. Sorry! On the other hand, I would like to see where, in what kind of computations, the Rig type class would be useful (and how to squeeze infinity into it). I spent some time doing some computations using probabilistic measures and very standard programming standards, and I am conservatist. Of course, as Macchiavelli said in "Prince" (more or less): "the innovator makes enemies of all those who have done well under the old conditions". I am doubtful whether I "did well", but I wait for the innovators to show me their "new conditions". A good example, where a new Prelude with Rigs, Rngs, etc., permit to solve better some concrete, useful computational problems. Thanks in advance. Jerzy Karczmarczuk

2 1

Thoughts about redesigning "Num" type class
by DreamApart AtHaskells 15 Sep '15

15 Sep '15

The class Num defines the method functions like (+), (-), (*), negate, ... But they are actually different concepts. We often meet situations that we want an addition for some type, but not a multiplication. For example: *data* Vec3 = Vec3 Float Float Float The additive (and subtractive) operation is obvious, but not for a multiplication. * Note* (*) :: a -> a -> a -- not avaliable for a Vec3 scale :: Float -> Vec3 -> Vec3 dot :: Vec3 -> Vec3 -> Float We cannot define a (+) alone for a type, so we got many different functions from different libs, like mappend, mplus, plus, (<+>), (.+.), (+.), which all reads "plus". My opinion is that the methods of Num should be seperated into different type classes, so we don't need to invent a new symbol for a new lib. A feasible design is: *import* Prelude *hiding* ( Num (..), Monoid (..), sum ) *class* SemiGroup a *where* (+) :: a -> a -> a *class* SemiGroup a => Monoid a *where* zero :: a *class* Monoid a => Group a *where* negate :: a -> a (-) :: a -> a -> a x - y = x + negate y negate x = zero - x *class* Group a => Ring a *where *-- not sure about the name ... (*) :: a -> a -> a *class* Ring a => Num a *where* abs :: a -> a signum :: a -> a fromInteger :: Integer -> a sum :: (Foldable t, Monoid a) => t a -> a sum = foldl' (+) zero -- for compatibility mempty = zero mappend = (+) mconcat = sum

11 21

Strange problem with inference
by Nikolay Amiantov 15 Sep '15

15 Sep '15

Hi Cafe, I've been playing around with lens and stumbled upon strange GHC behaviour. Consider this source (using lens package and GHC 7.10.2): {-# LANGUAGE TypeFamilies #-} import Control.Lens class Test a where type TestT a myiso :: Iso' a (TestT a) test1 :: Test a => a -> TestT a test1 = view myiso test2 :: Test a => TestT a -> a test2 = view (from myiso) GHC would emit this error: /tmp/test.hs:13:9: Could not deduce (Control.Monad.Reader.Class.MonadReader (TestT a) ((->) (TestT a))) arising from a use of ‘view’ from the context (Test a) bound by the type signature for test2 :: Test a => TestT a -> a at /tmp/test.hs:12:10-31 In the expression: view (from myiso) In an equation for ‘test2’: test2 = view (from myiso) Failed, modules loaded: none. However, `MonadReader r ((->) r)` is defined for any and all `r`! Furthermore, `test1` has no problem with this and `view` there uses this instance too. The only difference that I see is the presence of a type family: * `test1` needs `MonadReader a ((->) a)` * `test2` needs `MonadReader (TestT a) ((->) (TestT a))` , but I don't understand how can this result in a different behavior. Notice that this likely may be reproduced somehow without lens -- I've spent some time trying to minify this example further but alas to no avail. Thanks in advance! -- Nikolay.

4 5

Darcs Hacking Sprint #9 (September 18th-20th, Paris)
by Guillaume Hoffmann 15 Sep '15

15 Sep '15

Dear Hackers the next Darcs Sprint that will be in Paris, on September 18-20 at IRILL (near Place d'Italie). Please check out the details at: http://darcs.net/Sprints/2015-09 Here are three things to know 1. Everybody is welcome to join us. We'd love to have you, whatever your Haskell or Darcs hacking experience. Also, if you've got a wacky idea for the future of version control, or a cool use for the Darcs library, you should join us too :-) 2. Please let us know if you're attending. Just add your name to http://wiki.darcs.net/Sprints/2015-09 and you're good to go. You can also send us an email. 3. We can reimburse travel costs (within reason!). Let us know if you'd like a reimbursement, and save your receipts. Many thanks to everybody who participated in our fundraising drives or who gave money on the side. Thanks also to the Software Freedom Conservancy for making fundraising and reimbursements so painless! If you can't join us in person, but you'd like to cheer us on, say hello at http://darcs.net/Donations ! see you in one month! Guillaume

1 1

Powerset of a set
by JORGE MALDONADO 15 Sep '15

15 Sep '15

The powerset of set s is a set containing all subsets of s. I need a clue on how to write Haskell code to get the superset of a set using direct recursion and list comprehension. Best regads.

7 9

the library of beautiful instruments implemented in haskell / csound
by Anton Kholomiov 14 Sep '15

14 Sep '15

Status update for my haskell synth csound-expression. The main point is presence of many cool instruments. They are implemented in the package csound-catalog. All packages are compiled with GHC-7.10 So the hackage fails to build them and unfortunately docs a broken too. But you can look at the source code of the module Csound.Patch to now the names of the instruments. The usage is pretty straightforward. It's described here: https://github.com/spell-music/csound-expression/blob/master/tutorial/chapt… There is an mp3 file to listen to the instruments. http://ge.tt/1jNETqN2/v/0 *The 4.8.3 is out! New features:* This is a very important release to me. It tries to solve the problem present in the most open source music-production libraries. It's often the pack of beautiful sounds/timbres is missing. User is presented with many audio primitives but no timbres are present to show the real power of the framework. This release solves this problem. See the friend package csound-catalog on Hackage. It defines 200+ beautiful instruments ready to be used. The csound-expression defines a new type called Patch for description of an instrument with a chain of effects. It's good place to start the journey to the world of music production. There are new functions for synchronized reaction on events. The triggering of events can be synchronized with given BPM. The library is updated for GHC-7.10! github repo: https://github.com/spell-music/csound-expression hackage: http://hackage.haskell.org/package/csound-expression Cheers!

3 5

The semiring of Scott reals (Thoughts about redesigning "Num" type class)
by Olaf Klinke 13 Sep '15

13 Sep '15

This departs somewhat from the thread's topic. Below I detail a semiring R that is not a ring because negation is not definable in Haskell. I further sketch integration in Haskell which I ripped off papers by Gordon Plotkin, Steve Vickers, Anders Kock and others. Infinity comes in as a limit, of course. Approximate a real number by an ascending stream of rational numbers. (The ascending can not be enforced by Haskell's type system, of course.). What you have is a so-called lower real or Scott real. Still addition and multiplication is continuous on such reals and there is a unique way of extending these operations to infinity, represented by any strictly ascending stream. Neither subtraction not division are computable for the Scott reals. Indeed, to know a lower bound of x-y one needs to know upper bounds of y. Denote this type by R: type R = Stream Rational Further consider ascending streams of Booleans, where any two streams containing True are considered semantically equivalent. type S = Stream Bool Consider the following types: type ScottOpen x = x -> S type V x = (ScottOpen x) -> R Certain elements of the type V x are called valuations, assigning to any Scott open subset[*] of x a lower real number. The type constructor V has a monad instance. If there was a one-element type in Haskell (say 1), then V 1 is isomorphic to R. Hence a lower semicontinuous real-valued function f :: x -> R is the same as a function f :: x -> V 1. Now observe that (=<<) :: (x -> V 1) -> V x -> V 1 :: (x -> R ) -> V x -> R has the type of an integral operator. In other words, the bind of the monad V implements integration. I have an implementation that lets you do integration over any Haskell type, but it is very slow. An analogue of this is the monad []. Indeed, total elements of type N = [()] are natural numbers. Disregarding permutations, an element of [x] assigns to finitely many elements of x a weight from the natural numbers. Then (=<<) :: (x -> [()]) -> [x] -> [()] :: (x -> N ) -> [x] -> N is the integral operator integrating natural-number-valued functions against a finite natural-number-valued measure. Further observe that liftM2 (flip const) :: Monad m => m () -> m x -> m x is a monoid action that implements multiplication on N. It distributes over (++) for categorical reasons: (++) arises from the isomorphism (up to permutation) ([a],[b]) -> [Either a b]. As an exercise, define a monad instance for type FinDist x = [(x,Rational)] Hint: FinDist x = WriterT (Product Rational) [] x and observe that FinDist () is isomorphic to Rational (up to some equivalence relation). Voila: You have integration of Rational-valued functions against finitely supported distributions. For many combinatorial applications, this is sufficient. [*] For u :: x -> S, consider the set of elements of x for which u produces a stream containing True. This is the Scott open subset. Valuations are required to send the empty open to the constant zero stream and further obey the modular law you know from measures: v(u) + v(u') = v(union u u') + v(intersection u u') where union = liftA2 max and intersection = liftA2 min. -- Olaf

2 1

ANNOUNCE: ioctl 0.0.1
by Maciej Piechotka 13 Sep '15

13 Sep '15

A package for type-safe I/O control. Currently only ioctl is supported. Currently simply a extract from my tuntap fork TODO: - Return the integer as well as structure (will break the API) - Port for Windows Network.Socket.IOCtl (as soon as I manage to setup some sane environment on this platform) - Wrapping around DeviceIoControl Example (in hsc): data NotRead = NotRead instance NotRead Int where ioctlReq _ = #const FIONREAD notRead s = ioctlsocket' s NotRead Regards

2 1

Re: [Haskell-cafe] haskell est il compatible avec mon projet graphique ?
by Daniel Díaz 13 Sep '15

13 Sep '15

Pardonnez mon mauvais français. Il existe des liaisons pour SDL2: http://hackage.haskell.org/package/sdl2 Aussi jeter un oeil à "diagrams" http://projects.haskell.org/diagrams/gallery.html On Saturday, September 12, 2015 at 6:17:04 AM UTC+2, Vincent Douce LR wrote: > > salut à tous > je dois réaliser des créations graphiques, avec deux destinations : des > animations sur l'écran, et des images fixes destinées à être publiées sur > papier > ces créations reposent sur des algorithmes de mon crû > je souhaite me créer une bibliothèque de séquences de code que je pourrai > étoffer au fur et à mesure et utiliser dans mes programmes > je cherche quel langage adopter, et quel pendant graphique lui adjoindre > j'envisage des pistes comme C+sdl ou python +? > utiliser haskell serait un défi parce que c'est moins intuitif pour moi un > langage fonctionnel et aussi tout simplemetn parce que je n'y connais rien > en haskell, je sais juste un peu de Scheme > mais peut être qu'il y a dans l'univers haskell un moyen de générer des > graphiques de qualité ? je susi ouvert > qu'en pensez-vous ? >

2 1

Re: [Haskell-cafe] Thoughts about redesigning "Num" type class
by Olaf Klinke 12 Sep '15

12 Sep '15

I sencond the statement that semirings might be a useful typeclass to have. Another example: Non-negative reals with infinity, the values that a measure can take. Nevertheless the biggest issue is what _symbol_ to use for the operations. We know that a ring is a semigroup in two ways, and no matter what semigroup structure we think the ring to "originate" from, we're going to annoy the other half of users who thought it the other way around. Some semigroups are thought of as (+), others as (*). Picking one of these symbols for all semigroups will be counter-intuitive for some structures. As to affine structures, Martin Escardo and Alex Simpson have a paper showing that the unit interval is the free cancellative midpoint algebra over two generators. They have Haskell code for this [1]. And yes, a typeclass is not a mathematical category, but Haskell is a language that lets you formalise quite a bit of category theory, and this is a cool thing to have. You can read a paper based on category theory and obtain executable code with very little effort. There are now entire Ph.D. theses written in Agda. To me it seems that the solution to the Num typeclass problem would be to have sub-typeclass statements that let you introduce aliases for the operations, as so: class Semigroup a where (<>) :: a -> a -> a class Group a where (*) :: a -> a -> a unit :: a inverse :: a -> a superclass Semigroup Group where (<>) = (*) But wait, we do have a mechanism for aliases: It's called newtype! Conclusion: If you want to express that any Num instance is a Group, do so with a newtype. Data.Monoid is a good example for this. -- Olaf [1] http://www.cs.bham.ac.uk/~mhe/.talks/map2011/martin_map.pdf

4 3

Re: [Haskell-cafe] lazily updating dependencies, git submodules and cabal
by timmy tofu 10 Sep '15

10 Sep '15

> > Using the 'cabal sandbox add-source' solution now requires that I > "add-source" the MarketModel package too. Otherwise, any change I make > to this package will not be tracked. > then… > Cabal sets the paths for "import"ed > modules in the "hs-source-dirs:" and that is global to the whole > package. > I can't tell if you do or do not want ProfitCalculator and Persistence to track changes made in MarketModel. If you do, and both should be in lock-step with it (unlike your situation with Tax), then you don't have a problem. If not, then the problem is Trader would depend on ProfitCalculator which might depend on a different version of MarketModel than Persistence (upon which Trader also depends). That is a classic dependency problem and not a function of submodules or add-sourcing, per se. The Trader module seems to be at the top of this heap - why would you want the Trader to (indirectly) use one version of MarketModel through ProfitCalculator, and another through Persistence?

3 2

Best deployment method for Hakyll websites (with Stack)?
by Nicola Gigante 10 Sep '15

10 Sep '15

Hello, Note, this is not a Hakyll question, after all. I’m trying to host a hakyll website on a CentOS 7 server. I want to replicate the setup I had with the previous site, made with Jekyll: at each push on the git repository (hosted on the same server), the branch is recompiled and deployed to the web server. I already have the git hooks in place etc… The problem is how to manage the installation of ghc, hakyll, and their dependencies. I really really wish to have a clean solution. I really like stack, but its “per-user” directories make me wonder. The site compilation has to be performed by the git user account, which does not have an home directory. Can I setup a stack installation of a set of packages and then point stack to use that and only that? Also, how about the integration with docker? Is it really so painless as it is advertised? If I’ve understood correctly, I could install the docker image with stackage packages already installed, and tell stack to use that image with docker, having the site compilation sandboxed. Is it feasible? Thank you for any advice, Nicola

5 4

Senior Haskell developer roles at Standard Chartered, Singapore
by Don Stewart 10 Sep '15

10 Sep '15

The Strats team at SCB has two more open roles for Haskell developers in Singapore. These are exciting "director level" development roles in a large team. Location is Singapore. Details here: https://donsbot.wordpress.com/2015/09/10/senior-haskell-developer-roles-at-… Please contact me for more details.

1 0

lazily updating dependencies, git submodules and cabal
by Dimitri DeFigueiredo 09 Sep '15

09 Sep '15

Hello all, I am facing a problem that I assume others have seen before, but am stumped for a solution. It's not about Haskell per se, but about how to organize my haskell code to play nicely with the build tools. #The Setup I am currently developing a bitcoin trading agent. I produce 2 executables: the "Trader" and the "Tax" calculator. These 2 executables share a common dependency to talk to a SQLite3 database in their "Persistence" layer. (I actually have 3 levels of dependency, but we'll get to that later) I spend most of my time working on the Trader and the Persistence layer. These are just different source code files: Trader.hs and Persistence.hs. The problem is that as I update the Persistence.hs file I break Tax.hs. Because I am "lazy" and only really have to calculate taxes once I year. I do *not* want to have to continuously modify the Tax.hs file to keep up with the development in the Persistence layer. I just want it to use an old version, so that I only have to bring it up to speed later. In other words, I want to: 1. always be able to compile both executables, 2. delay updating an executable because of changes in a common dependency as much as possible. I want to be lazy and delay updating my Tax.hs code to work with latest version of the Persistence layer a much as possible. At the same time, the Trader and Persistence layer are worked on simultaneously. #My Current Solution The immediate solution that comes to mind is to put these files in 3 different packages. That way, I can use version 1.5 of the Persistence layer for the Tax calculator, but still develop version 2.0 at the same time as working on the Trader. I can use 'cabal sandbox add-source' to immediately get changes made to the Persistence layer as I develop the Trader. There is one minor problem with this approach: I have to manually track the version numbers. I need to put the proper version number in the "build-depends" section in the .cabal file. For example, for Tax.cabal I would have: "build-depends: persistence == 1.5". There is a different approach that is completely orthogonal to using Cabal packages. I can put each of the 3 files (Trader.hs, Tax.hs and Persistence.hs) in 3 different repositories and use git submodules. The Persistence layer would be a submodule of both the Trader and the Tax repos. As each submodule just points to a specific commit in the Persistence repo, I don't have to manually track version numbers and the Trader and Tax calculator can point to different commits and use different versions of the Persistence layer. The git solution is really convenient because when you clone a repo (with --recursive), it comes with the correct versions of the dependencies you need. This is what I did. #The Problem The problem I am facing is that I now have 3 (or more) levels and multiple dependencies. There are 2 changes to the original setup: 1. Persistence.hs now imports MarketModel.hs and that also changes pretty quickly as I develop the Trader. 2. The Trader now also depends on ProfitCalculator.hs that also imports MarketModel.hs Using the 'cabal sandbox add-source' solution now requires that I "add-source" the MarketModel package too. Otherwise, any change I make to this package will not be tracked. In fact, I have to "add-source" two different versions of MarketModel (in general, there's an exponential blow up as the number of levels increases). The manual tracking of version numbers in the cabal file also becomes critical. If I forget to update a version number, the package will be reinstalled over an existing one that's being used. This quickly becomes a mess. The git submodule solutions doesn't work either. Although GHC does the right thing and only complains about two modules with the same name if I use a symbol that is ambiguous. Cabal sets the paths for "import"ed modules in the "hs-source-dirs:" and that is global to the whole package. I can't say: 1. first, compile the Persistence.hs file by "import"ing files in the path /trader/persistence/marketmodel, 2. now, compile the ProfitCalculator.hs by "import"ing files in the path /trader/profitcalculator/marketmodel. That path is the same for the whole project and I can't use different versions of MarketModel.hs In short, it seems no solution works anymore. Is there a way to make this work? Is there another way for me to be lazy about updating my dependencies when building multiple targets? Any pointers on this would be much appreciated! Thanks, Dimitri

1 0

emacs haskell-mode with cabal exec, test suite sections
by Stuart Popejoy 09 Sep '15

09 Sep '15

I'm having trouble coding test-suite and executable sections with the emacs REPL and flycheck. 1. cabal-repl can compile against the library code, but fails to see any modules within the non-library section. 2. flycheck has the opposite problem: it fails on library module imports but recognizes imports local to the section. Note I don't always have these issues, but they seem to crop up whenever I upgrade GHC, or emacs, or haskell-mode, flycheck-haskell etc. I'm not sure #1 ever works, but #2 is happening to me on my mac, but not at work on Linux. For #1, in the past I've tried a big .dir-locals.el to use `ghci` for the repl and just import everything -- of course losing the nice cabal integration, plus it being slow as molasses to load source files. I also briefly investigated modifying haskell-mode to support separate sessions for a given section. For #2, flycheck is just a pain to debug, my only recourse is to stick debug output into `flycheck-start-command-checker` to see what commands are going out, and try to troubleshoot. Any thoughts or suggestions? Commiseration is OK too :) Thanks, Stuart

3 5

Helsinki Haskell User Group metope, 2015-09-24 @ 18:00 Gofore
by Oleg Grenrus 09 Sep '15

09 Sep '15

Dear all, especially people not on the meetup.com. After a summer break we'll resume Helsinki Haskell User Group meetups. The first one will be on Thursday, September 24th at 18:00 at Gofore office. We'll have three talks: about hpack & stack, purescript and history of functional programming. If you are in the neighbourhood, join us. For details see: http://www.meetup.com/Helsinki-Haskell-Users-Group/ Everybody is welcome! Oleg Grenrus

2 1

ANN: Creation of Haskell-Community list for Haskell.org Community Infrastructure Discussions
by Gershom B 09 Sep '15

09 Sep '15

Dear all, The haskell.org committee [1] had a productive week during ICFP, and at some point we'll try to write up some of the small things underway and future plans -- many things are quite tentative at the moment. However, one thing that became clear to us (well, thanks to the useful prodding of SPJ) is that we have historically participated in discussions in other venues (-cafe, reddit, etc) and then had our own internal discussions (few, seldom, and largely organizational to be honest) on the low-traffic committee [at] haskell.org mail alias. But this leaves open people wondering what those discussions are. And it also leaves open where the *designated place* to discuss haskell.org community infrastructure is. The haskell-infrastructure [2] list is very quiet and really about technical considerations. Meanwhile, -cafe, reddit and soforth are about anything and everything. So we created another list, which will be a place where we seek to have our discussions related to plans for haskell.org committee work, and where we invite everyone to join us. This new list is the haskell-community list: https://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-community The committee alias will still work, and is still the way to just write directly to the members of the committee -- no list to join. But if you wish to have a discussion about how we have things set up on haskell community infrastructure, services provided, and that we might wish to add, and how you can help (or even just what your thoughts are on how things might be done), now there is a good place for that. Hope to continue conversations with many of you there, Gershom (for the haskell.org committee) [1] https://wiki.haskell.org/Haskell.org_committee [2] http://community.galois.com/mailman/listinfo/haskell-infrastructure

2 2

Stuck in proof of trivial compiler
by Rustom Mody 09 Sep '15

09 Sep '15

Trying to prove a trivial compiler with respect to a corresponding interpreter --------------- Code ------------------ +-* Expression tree data Exp = Lf Int | Add Exp Exp | Mul Exp Exp eval (Lf x) = x eval (Add el er) = eval el + eval er eval (Mul el er) = eval el * eval er Simple stack machine instructions (LC is load constant) data Instr = LC Int | AddI | MulI compile (Lf x) = [LC x] compile (Add el er) = compile el ++ compile er ++ [AddI] compile (Mul el er) = compile el ++ compile er ++ [MulI] mac [] stk = stk mac (LC x : is) stk = mac is (x:stk) mac (AddI : is) (r : l : stk) = mac is (l+r : stk) mac (MulI : is) (r : l : stk) = mac is (l*r : stk) ------------ Proof Attempt ----------------------- Theorem mac(compile e).s = eval.e : s Base case mac(compile (Lf x)) s = eval (Lf x) : s LHS = mac (compile (Lf x)) s mac [LC x] s mac [] (x: s) x: s RHS = eval (Lf x) : s x: s Induction Step: Assumption l: mac (comp el).s = eval el : s Assumption r: mac (comp er).s = eval er : s LHS = mac (Add el er) s = mac (comp el ++ comp er ++ [AddI]) RHS = eval (Add el er) : s = (eval el + eval er) : s Now What???

2 2

Re: [Haskell-cafe] Thoughts about redesigning "Num" type class
by Oleg 09 Sep '15

09 Sep '15

Alexey Muranov wrote: > My, maybe naive, impression is that there should always be one class per > operation, as this is obviously the most flexible approach. Then maybe some > classes can be grouped together by introducing other classes. Truly what goes around comes around. The ``less ad hoc'' overloading which we now associate with type classes was first proposed (and even implemented!) by Stefan Kaes, a couple of years before the type classes. Kaes so-called parametric overloading may be regarded as an implementation of type classes with only one method. http://okmij.org/ftp/Computation/typeclass.html#Kaes Incidentally, Kaes' system included not only `local instances' but also `local classes'. Likewise, 'Haskell with only one type class', http://okmij.org/ftp/Haskell/TypeClass.html#Haskell1 deals first with one-method classes. Type classes like Num are then regarded as convenient collections, as bundles of previously defined methods. Naturally, the same method, like (+), can be a part of several bundles, not necessarily related otherwise. Incidentally, The `Haskell with only one type class' required NO extensions, even back in 2007, when it was first proposed.

1 0

I wrote a type checker: ARF. Is it novel?
by David Foster 09 Sep '15

09 Sep '15

I've written a small untyped language calculus (ARF) and an interprocedural flow-based type checker to explore techniques for efficiently inferring all types in the presence of recursive function calls, with no prior type declarations or annotations required in the original program. The type checking algorithm I've come up with appears not only to work but also to have good performance: O(m^2) time in the worst case and O(m) time in the average case, where m is the number of functions in the program. So the question I'd like to pose to any type system buffs on this list is: (1) Is such an interprocedural flow-based type checking algorithm with that kind of performance likely to be novel? And if you have some interest and time to actually review the strategy and/or implementation of the algorithm at <https://github.com/davidfstr/arf#assign-recurse-flow-arf>, I'd love to know: (2) Are there similar type checking algorithms that already exist in the academic literature? I'm posting these questions here because I'm guessing that a number of folk that work with type systems and type checkers are likely to be subscribed to this list. If there are other more-appropriate venues, I'd love to hear about about them as well. -- David Foster

3 3

GHC Extension Proposal: ArgumentBlock
by Andrew Gibiansky 09 Sep '15

09 Sep '15

I'd like to propose a GHC extension called (for now) `ArgumentBody`. `ArgumentBody` is a simple syntax extension, than, when enabled, permits the following code: main = when True do putStrLn "Hello!" main = forM values \value -> print value main = forM values \case Just x -> print x Nothing -> print y In this code we do not need `$` before `do`, lambda, or lambda-case (if -XLambdaCase is enabled). This change would *not* extend to `let`, `if`, `case`, or any other constructs. Pros: 1. Code is simpler and it greatly reduces the need for "operator line noise" of $ everywhere. 2. We can avoid using the type-checker hack for $ <http://stackoverflow.com/questions/9468963/runst-and-function-composition> for things such as runSt. Cons: 1. Adds complexity to the compiler. (NB: The change is minimal and not invasive at all.) 2. Contributes to a proliferation of extensions that other tools must support. (NB: This is just a parser change so should be easy for all tools to support.) I'm very interested in hearing both favoring and dissenting opinions on this proposed change. If this change is approved of, names besides -XArgumentBody can be considered. See more info on Trac <https://ghc.haskell.org/trac/ghc/ticket/10843#ticket> . -- Andrew Gibiansky

40 73

Flag to recompile modules which had warnings
by Kostiantyn Rybnikov 09 Sep '15

09 Sep '15

This is a call for comments before I'd create a ticket in corresponding project (I'm not sure if it should be ghc or stack/cabal). There's a common situation I get into: I compile with "stack build" (or cabal build), get a big list of warnings, fix few of them, then I re-compile project, but a lot of warnings are gone now. The only option I'm left with is to use "-fforce-recomp". Problems with -fforce-recomp are: - full-recompile is quite long for big projects - most people don't know about it, especially newbies I think some flag, which would be turned on by default, which would indicate to "recompile modules if they previously had warnings" would be awesome to have. 1. would you like to have that flag? 2. would you like it "on" by default? 3. should ticket go into ghc or stack/cabal-install project? Thank you.

8 10

Can #Haskell be used to generate the #Java class libraries relatively error free? #Java8u60
by KC 08 Sep '15

08 Sep '15

Can #Haskell be used to generate the #Java class libraries relatively error free? #Java8u60 -- -- Sent from an expensive device which will be obsolete in a few months! :D Casey

3 2

Functional counterpart of counting-sort?
by Nicola Gigante 08 Sep '15

08 Sep '15

Hi all, I’m sorry if this is a trivial question. Everybody knows the counting sort algorithm to sort an array of integer values, which runs in O(n) time, circumventing the O(n log n) lower bound by avoiding comparison operations. Of course, that only works for integers. However, it seems to me that it essentially relies on the availability of a O(1) indexing operation on the array, not on algebraic or logical properties of the set of the integers. Do any of you know if it is possible to sort a _list_ of integers in O(n) time in a (lazy) purely functional language? I’d say no, but given all the crazy laziness tricks out there, I can’t say for sure ;) Even if no: any theoretical considerations on why not? Greetings, Nicola

3 3

Re: [Haskell-cafe] GHC Extension Proposal: ArgumentBlock
by James Burton 08 Sep '15

08 Sep '15

On 8 Sep 2015 3:12 pm, Carlo Nucera <meditans(a)gmail.com> wrote: > > -1 > > I wouldn't like to read code written with this extension. It feels to > me like an ad-hoc case, > hindering the general uniformity of the language. I agree, and think it could be confusing to switch between styles in different codebases or in a single codebase. I teach Haskell and encourage students to use brackets liberally if they're not sure when they're needed and experiment with removing redundant ones and replacing others with $ later on. I don't think this is one of the things they tend to get confused about. > It has been a nice > opportunity to read up > the haskell report, though :) > > 2015-09-08 15:35 GMT+02:00 Alexander Berntsen <alexander(a)plaimi.net>: > > -----BEGIN PGP SIGNED MESSAGE----- > > Hash: SHA512 > > > > ($) is just a function like any other*, so I don't think it's a great > > argument for or against a syntax extension. > > > > *Bar a few details like the special infix typing rule for > > accommodating impredicative polymorphism. > > - -- > > Alexander > > alexander(a)plaimi.net > > https://secure.plaimi.net/~alexander > > -----BEGIN PGP SIGNATURE----- > > Version: GnuPG v2 > > > > iQIcBAEBCgAGBQJV7uQDAAoJENQqWdRUGk8BA3wQAMdZ3xHQDYUy17HahMbMjxyT > > xkm2bZLDNMPwmyaciGHsC+BeRae9Oo1oVgjWDDzrL41zSf9e2GS5SmEQumJeAgLm > > TNkJgctJ44Ej+yPnJkik9OCK4YsFjZPFYdj8iI4T7uEBfC5vDQczODgKvcXo3WiY > > JmujgC+QFjU3PaDaz8HZ8UzDIRszBRPQyTTLzlYnsshQwws/eU7W1hBKBLNFjn90 > > t9n8xq49BfbNInHSzVy5CbUW5VyPCYikkCAz7zRBc25iWtaXODvYnDCyc4vwVg38 > > QsNfXvOsSrnE80WOQxXKbaHutMaf8QoiNQ5+M8gMNKWAHXZ0ROYgAE9lm2QfLMTE > > oidjVh9WrYmlXCmJl0pgFdN1Dc5J+KimoTK8ttvGcweRckUdgkBRQsmyqILtn+ql > > peNN9QU5W1V8rUfliTq9XCXDu1rAKuKtSPb3GQD9vXDQ22QSHQqjk8eLdd2bAK1n > > ji/r+Bjp9XNLvySaPi9neiEp3geFjZnN7b3pC2QtDsRJozv6prliNHOsGgLin5dN > > FmrwSXysha7hZtxy3ze4XnMa/91GZPB9Z91hZdALXyVSbDBrE4ukUABprI6tK8/6 > > O2pfmsdWzvGMNgXFibg1sgJk9e8aTvp6YPyi6Xyj/88hLD6YxB3/ekxxBy00EDW/ > > RFqKfswkYKypfKwx0FXq > > =8Rg1 > > -----END PGP SIGNATURE----- > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > > ___________________________________________________________ > This email has been scanned by MessageLabs' Email Security > System on behalf of the University of Brighton. > For more information see http://www.brighton.ac.uk/is/spam/ > ___________________________________________________________ ___________________________________________________________ This email has been scanned by MessageLabs' Email Security System on behalf of the University of Brighton. For more information see http://www.brighton.ac.uk/is/spam/ ___________________________________________________________

1 0

"Assignment" in do blocks?
by Anupam Jain 08 Sep '15

08 Sep '15

Hi all, I'd like to propose an inbuilt "assignment" operator for use within do-blocks. Here's a common pattern - do foo <- someaction do something with foo -- Here we "update" the value of foo let foo' = bar foo -- The code from this point onwards shouldn't use foo -- but there is no way to enforce that What I'd like to do instead is something like - let foo = bar foo But to Haskell this is a recursive definition instead of an update to the previous value. I can do this instead - foo <- return $ bar foo which works fine but (I assume) GHC currently can't optimise it for arbitrary monads. Also it won't necessarily work if the monad laws don't hold. It would be nice to have an "assignment arrow", say (<-=), which lets GHC optimise this, so - foo <-= bar foo ... desugars to something like - foo' (bar foo) where foo' foo = ... -- Anupam

7 11

Conduit and foldLines
by Kees Bleijenberg 07 Sep '15

07 Sep '15

My goal is to parse a big text-file line by line using the same parser for every line. I am new to Conduit and I've read this https://www.fpcomplete.com/user/chad/snippets/random-code-snippets/folding-l ines-in-conduit article. After adding import Control.Monad.Trans.Resource for runResourceT and adding rankNTypes, I got it working. Code in www.tbsoftware.nl/TestConduit/TestConduit7.hs I don't understand what is going on in myFunc. Does CL.fold fold over the already read lines? I wonder whether CL.fold loads the whole file in memory? if I change count <- CL.fold (\count t -> count + T.length t) 0 to count <- CL.fold (\count t -> T.length t) 0 nothing changes in the output. If count is always zero, why using a fold? How can I get the 'current line' in myFunc? Kees

2 1