- Haskell-Cafe - Haskell.org

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