- Haskell-Cafe - Haskell.org

Data import from octave / text file
by kaffeepause73 15 Jun '11

15 Jun '11

Dear all, I want to read numeric data in vector / matrix format generated by octave. As I haven't seen any octave specific libraries yet (only matlab), I'm tyrying the way via ascii - file. The folloing file log.txt contains three signal traces in the three columns (time, signal 1, signal 2) 0 30 9 0.1 30 9 0.2 30 9 0.3 30 9 0.4 30 9 0.5 30 9 0.6000000000000001 30 9 0.7000000000000001 30 9 0.8 30 9 0.9 30 9 1 30 9 I got the following bit of code compiled with ghc: import System.IO main = do text <- readFile "./log.txt" putStrLn text putStrLn "SecondLot" let m = read text :: [[Double]] putStrLn (show m) putStrLn "Finish" Reading text works, but not reading text into m. The Output: 0 30 9 0.1 30 9 0.2 30 9 0.3 30 9 0.4 30 9 0.5 30 9 0.6000000000000001 30 9 0.7000000000000001 30 9 0.8 30 9 0.9 30 9 1 30 9 SecondLot signalImport: Prelude.read: no parse Any suggestions ? - Thanks in advance. -- View this message in context: http://haskell.1045720.n5.nabble.com/Data-import-from-octave-text-file-tp44… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

5 6

Lazy lists vs generators
by oleg＠okmij.org 15 Jun '11

15 Jun '11

Yves Pare`s wrote: > I cannot help smiling when I hear Java/C#/Python developers telling about > the "wondeful features" of their languages ;) > (- We have generators! We can _yield_ values! [1] > - Yeah, so nice... We have simple lists... with lazy evaluation) Just for the record, lazy lists per se are sufficient only for simplest generators. Re-writing an accumulating traversal to accommodate suspension by hand is too ungainly and error prone. Still, if we just add exceptions (the Either monad), we can idiomatically write all the generator examples of Python or Icon, for example. If we do not need effects other than yielding or non-determinism, [Either e a], which is ErrorT e [] a, suffices. If we need IO or mutable state, we should replace [] with LogicT (which is the monad of lazy lists with effect). The following web page talks about lazy lists and generators http://okmij.org/ftp/continuations/generators.html in (perhaps too) great detail.

3 3

Re: [Haskell-cafe] Best platform for development with GHC?
by michael rice 15 Jun '11

15 Jun '11

I don't know about the other Linux distros, but Fedora seems to have excellent support for Haskell. Michael

1 0

YesodAuth documentation
by Никита Тимофеев 14 Jun '11

14 Jun '11

Does exist some simple examples using yesod authentication except code of Haskellers site? Does exist some examples using YesodAuthEmail? For example, can i use third-party mail server instead of Sendmail for YesodAuthEmail? Can i disable registration confirmation? Does passwords stored in a database in an unencrypted form? -- Timofeev N.D.

3 3

Re: [Haskell-cafe] Acquiring a random set of a specific size (w/o dups) from a range of Ints
by Patrick Perry 14 Jun '11

14 Jun '11

There are time/space tradeoffs in sampling without replacement. The version in monte-carlo takes space O(n) and time O(k), for all k. I chose this algorithm instead of a streaming algorithm, with takes space O(k) and time O(n). If k is much less than n, you can improve a bit. Here is a version taking space O(k) and time O(k^2), *provided k << n*; when k is large relative to n, the time increases to roughly O(n log n). import Control.Monad( liftM ) import Control.Monad.MC import Data.List( nub ) sampleSmallIntSubset :: MonadMC m => Int -> Int -> m [Int] sampleSmallIntSubset n k = (take k . nub) `liftM` repeatMC (sampleInt n) sampleSmallSubset :: MonadMC m => [a] -> Int -> m [a] sampleSmallSubset xs k = (map (xs !!)) `liftM` sampleSmallIntSubset (length xs) k -- strict version of the above sampleSmallSubset' :: MonadMC m => [a] -> Int -> m [a] sampleSmallSubset' xs k = do ys <- sampleSmallSubset xs k (length ys) `seq` return ys -- by forcing the length, we make sure we are done with the RNG when we return If you're wondering about the strict version, the following example should be instructive: Let's note the first three numbers generated by the RNG with seed 0: ghci> (replicateM 3 $ uniform 0 1) `evalMC` mt19937 0 [0.999741748906672,0.16290987539105117,0.28261780529282987] Now, let's look at the first number we get after a call to sampleSmallSubset, if we don't evaluate the subset: ghci> sampleSmallSubset [1..10000] 2 >> uniform 0 1) `evalMC` mt19937 0 0.999741748906672 Apparently, the call to sampleSmallSubset doesn't consume any random numbers. Now, let's try the strict version: ghci> (sampleSmallSubset' [1..10000] 2 >> uniform 0 1) `evalMC` mt19937 0 0.28261780529282987 This time, the call to sampleSmallSubset' consumes two random numbers, even if we throw away the result. Since you're just starting out, I recommend using the strict versions of the functions. They are less space-efficient than the lazy versions, but they are guaranteed to be safe. > From: Jonas Almström Duregård <jonas.duregard at chalmers.se> > Subject: Re: [Haskell-cafe] Acquiring a random set of a specific size (w/o dups) from a range of Ints > To: "michael rice" < > nowgate at yahoo.com > > > Cc: "Felipe Almeida Lessa" < > felipe.lessa at gmail.com>, haskell-cafe at haskell.org > > Date: Tuesday, June 14, 2011, 5:17 AM > > > > Shuffle [1..20], then take 5? > > > > Yes, so simple, I'm embarrassed I didn't think of it. > > > That works well for small numbers, but I'm guessing it will evaluate the entire list so it should not be used for large inputs. If you have a large interval and use a relatively small part of it, the following function should be significantly faster (it builds a random permutation lazily):

1 1

YesodAuth documentation
by Тимофеев Никита Дмитриевич 14 Jun '11

14 Jun '11

Does exist some simple examples using yesod authentication except code of Haskellers site? Does exist some examples using YesodAuthEmail? For example, can i use third-party mail server instead of Sendmail for YesodAuthEmail? Can i disable registration confirmation? Does passwords stored in a database in an unencrypted form? -- Timofeev N.D.

3 4

Dead else branch does influence runtime?
by Johannes Waldmann 14 Jun '11

14 Jun '11

Dear all, I am very puzzled by a program that contains an "else" branch that is never executed, but still seems to slow down the program. (When I replace it by "undefined", the resulting program runs much faster.) http://hackage.haskell.org/trac/ghc/ticket/5256 I thought it may be a type issue (the type of the else branch forces the type of the "then" branch to be more general, thus some optimization might not fire) but the types of the branches look identical. (They are generic, but the specializer should take care of that.) I am sure GHC headquarters will look at this when they find the time but perhaps there's some additional knowledge on this mailing list that might help. J.W.

3 7

Re: [Haskell-cafe] Acquiring a random set of a specific size (w/o dups) from a range of Ints
by michael rice 14 Jun '11

14 Jun '11

Thanks, all. It seemed like something like this should exist in a prob/stat package, and if so, didn't want to reinvent the wheel. Shuffle [1..20], then take 5? Yes, so simple, I'm embarrassed I didn't think of it. Michael --- On Mon, 6/13/11, Felipe Almeida Lessa <felipe.lessa(a)gmail.com> wrote: From: Felipe Almeida Lessa <felipe.lessa(a)gmail.com> Subject: Re: [Haskell-cafe] Acquiring a random set of a specific size (w/o dups) from a range of Ints To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Date: Monday, June 13, 2011, 9:38 PM On Mon, Jun 13, 2011 at 8:56 PM, michael rice <nowgate(a)yahoo.com> wrote: > Is there an (existing) way to select 5 Ints randomly (no duplicates) from a population, say 1-20 (inclusive)? Yes, already implemented in the monte-carlo package as sampleSubset [1], sampleSubset :: MonadMC m => [a] -> Int -> m [a] Complete example code for your example: evalMC (sampleSubset [1..20] 5) (mt19937 0) Cheers! [1] http://hackage.haskell.org/packages/archive/monte-carlo/0.4.1/doc/html/Cont… -- Felipe.

3 5

GHC7 build problem
by Scott Lawrence 14 Jun '11

14 Jun '11

Trying to compile GHC7 from source (as the ubuntu repository is still on GHC6), I came across the following error in the final phase: libraries/base/GHC/ST.lhs:78:1: You cannot SPECIALISE `forever' because its definition has no INLINE/INLINABLE pragma (or its defining module `Control.Monad' was compiled without -O) This was after: git clone [...] ./sync-all get perl boot ./configure make Is there some problem with trying to build GHC7 on a machine with GHC6, or did I just get the build procedure wrong (the last line of the error looks like a hint that I did). -- Scott Lawrence

3 4

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 93, Issue 58
by Gregory Guthrie 14 Jun '11

14 Jun '11

An earlier note on students reactions to the imperative style forced on them by some Haskell libraries ("do ...") is interesting, and seems similar to an observation in a project I was developing for students; making a version of a simple lab from previous SML assignment. It uses a dictionary to do some statistics for a text analysis, but since the dictionary is read at a leaf node of the analysis algorithm, that function must be IO(), and thus the analysis using it also, ... etc. all the way up to the top. So the implication of the rules: 1) all IO must start from the top level, and there is only one IO 2) you cannot extract anything from an IO Seems to be that the whole program structure becomes a series of do... blocks, which is basically a sequential imperative looking style. The general advice of "Strive to keep as much of the program pure as possible" thus seems difficult. An option I suppose would be to read the dictionary at the top level, and then pass it all the way down to the analysis routine that uses it, but that exposes the details of how the analysis is done, and couples the top and bottom levels of the previously modular functions. While this is all logical and understandable, it is quite different than how I did this in SML; where I could encapsulate the IO in the analysis function. It was a local secret of the analysis what data it needed, and where it came from. Note that (of course...) if the dictionary was static and an internal data structure, then this would all go away. It is interesting to me (and curious at first) that one could not somehow treat a "constant" data definition file resource in a more encapsulated manner, and not have it ripple all the way up through the program because it was "impure" once converted to an external definition (=IO). My first impulse was to read the dictionary in a do... and then try to extract it and go merrily on, but that won't work - by design of course! Considering something like a properties file in Java, it thus seems like every part of a program wanting to use these, must either be passed some global definition, or become a leaf on a hierarchy of do.. blocks if it does its own IO to read the properties. Anyway, while the more precise treatment and isolation of IO in Haskell seems valuable, it also seems to have a notable impact on the lack of ability to encapsulate and decouple parts of the program, and keep things pure between them. I suppose this is because that by definition, once you have touched IO at any leaf of a program, the whole thing is impure all the way up the functional tree. I rather had the feeling expressed by Robert Harper: " Once you're in the IO monad, you're stuck there forever, and are reduced to Algol-style imperative programming." (http://existentialtype.wordpress.com/2011/05/01/of-course-ml-has-monads/) Just an observation, in case I am missing something - being fairly new to Haskell. I suppose this is just an adjustment to proper treatment of the impurity of IO, but the effect on program structure was not good. :-) ------------------------------------------- > -----Original Message----- > Subject: Haskell-Cafe Digest, Vol 93, Issue 58 > Now, I have a personal pedagogical comment. >A few months ago I gave to some 30 students an >The results? A true DISASTER! > The OpenGL bindings in Haskell are hardly "functional". > You make us sweat with generic functional patterns, laziness, exquisite typing, non-determinism monad, parsing tools, etc., > and then you throw us into this ugly imperativism !

7 10