- Haskell-Cafe - Haskell.org

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

18 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 17 Sep '15

17 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 16 Sep '15

16 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