- Haskell-Cafe - Haskell.org

Performance counters
by Andrew Coppin 05 May '09

05 May '09

OK, so I'm pretty sure I'm not the first person to run into this... I've got a fairly large, complex program. It seems to work fine. But now I want to add some counters to measure various things. Trouble is, to do that, I'd have to "infect" the entire program with boilerplate code to propogate these counters. At best I could wrap it up in a monad, but it's still annoying to have to make 90% of the code in the program monadic just to carry these performance counters around. Does anybody know of a better solution? I could use the dreaded unsafePerformIO to prod some IORefs, but now you have to start sprinkling NOINLINE pragmas around and hope you know what you're doing... Scary! o_O

5 6

using interact with state, was Re: [Haskell-cafe] applicative challenge
by Thomas Hartman 05 May '09

05 May '09

Aha! There is in fact a way to fit this specification into the applicative paradigm. I'm a bit muzzy as to what it all means, but I must say, aesthetically I'm rather pleased with the result: module Main where import Control.Monad.State import Control.Applicative import Control.Applicative.State -- applicative-extras on hackage -- works t18 = interact $ evalState f18 where f18 = return paint `ap` grabTillBlank `ap` grabTillBlank paint first second = "first\n" ++ first ++ "second\n" ++ second grabTillBlank = State $ \s -> let (beg,end) = break null . lines $ s in (unlines beg, (unlines . drop 2 $ end)) -- And, with applicative extras: t19 = interact $ evalState f19 where f19 = paint <$> grabTillBlank <*> grabTillBlank paint first second = "first\n" ++ first ++ "second\n" ++ second 2009/5/5 Thomas Hartman <tphyahoo(a)gmail.com>: >> interact (\s -> let (first,second) = span (not . null) (lines s) > in unlines ("first":first++"second":takeWhile (not.null) second)) > > So, that didn't quite do the right thing, and it seemed like using > span/break wouldn't scale well for more than two iterations. Here's > another attempt, which is a little closer I think, except that it > seems to be using some sort of half-assed state without being explicit > about it: > > module Main where > > t17 = interact f17 > f17 s = let (first,rest) = grabby s > (second,_) = grabby rest > in "first\n" ++ first ++ "second\n" ++ second > > grabby :: String -> (String,String) > grabby s = > let (beg,end) = break null . lines $ s > in (unlines beg, (unlines . drop 2 $ end)) > > > 2009/5/5 Ketil Malde <ketil(a)malde.org>: >> Thomas Hartman <tphyahoo(a)gmail.com> writes: >> >>> That's slick, but is there some way to use interact twice in the same program? >> >> No :-) >> >>> t10 = >>> let f = unlines . takeWhile (not . blank) . lines >>> in do putStrLn "first time" >>> interact f >>> putStrLn "second time" >>> interact f >>> >>> this results in *** Exception: <stdin>: hGetContents: illegal >>> operation (handle is closed) -} >> >> Yes. Interacting uses hGetContents, and hGetContents semi-closes (or >> fully-closes) the handle. If you do it from GHCi, you only get to run >> your program once. >> >>> I also tried >>> >>> t15 = >>> let grabby = unlines . takeWhile (not . blank) . lines >>> top = ("first time: " ++) . grabby . ("second time: " ++) . grabby >>> in interact top >> >>> but that didn't work either: >>> thartman@ubuntu:~/haskell-learning/lazy-n-strict>runghc sequencing.hs >>> a >>> first time: second time: a >>> b >>> b >> >> Well - the input to the leftmost grabby is "second time" prepended to >> the input from the first, and then you prepend "first time" - so this >> makes sense. >> >> Something like this, perhaps: >> >> interact (\s -> let (first,second) = span (not . null) (lines s) >> in unlines ("first":first++"second":takeWhile (not.null) second)) >> >>> If someone can explain the subtleties of using interact when you run >>> out of stdio here, it would be nice to incorporate this into >> >> hGetContents - there can only be one. >> >> -k >> -- >> If I haven't seen further, it is by standing in the footprints of giants >> >

1 0

Re: FW: Re: [Haskell-cafe] calling a variable length parameter lambda expression
by Ryan Ingram 05 May '09

05 May '09

On Tue, May 5, 2009 at 10:05 AM, Nico Rolle <nrolle(a)web.de> wrote: > I dont't understand why u ask me that but the lambda expression will > only get values not functions as a parameter. > a = 1 > b = 2 > c = 3 > >>> What if I call >>> a (+)? > > this won't happen in my use case. > regards nico Here's an example for a single fixed argument and return types: class LambdaApply lam where lamApply :: lam -> [Integer] -> Bool instance LambdaApply Bool where lamApply b [] = b lamApply _ _ = error "Too many arguments in argument list" instance LambdaApply r => LambdaApply (Integer -> r) where lamApply _ [] = error "Not enough arguments in argument list" lamApply f (x:xs) = lamApply (f x) xs The problem is generalizing this to any type, because of the base case: instance LambdaApply r where lamApply r [] = r lamApply _ _ = error "Too many arguments in argument list" overlaps with function types such as (Integer -> a). Since you say this is only for value types, if you're willing to encode each value type you care about, you can make this work in a somewhat more general way. But unless you are just using it for syntactic sugar (which seems unlikely for this use case), it's usually a signal that you are doing something wrong. -- ryan >>> Von: Ryan Ingram <ryani.spam(a)gmail.com> >>> Gesendet: 05.05.09 18:58:32 >>> An: Nico Rolle <nrolle(a)web.de> >>> CC: haskell-cafe(a)haskell.org >>> Betreff: Re: [Haskell-cafe] calling a variable length parameter lambda expression >> >>> This is a Hard Problem in Haskell. >>> >>> Let me ask you, how many parameters does this function take? >>> a = (\x -> x) >>> >>> How many parameters does this function take? >>> b = (\f x -> f x) >>> >>> How many parameters does this function take? >>> c = (\f x y -> f x y) >>> >>> What if I call >>> a (+)? >>> >>> -- ryan >>> >>> On Tue, May 5, 2009 at 9:49 AM, Nico Rolle <nrolle(a)web.de> wrote: >>> > Hi everyone. >>> > >>> > I have a problem. >>> > A function is recieving a lambda expression like this: >>> > (\ x y -> x > y) >>> > or like this >>> > (\ x y z a -> (x > y) && (z < a) >>> > >>> > my problem is now i know i have a list filled with the parameters for >>> > the lambda expression. >>> > but how can i call that expression? >>> > [parameters] is my list of parameters for the lambda expression. >>> > lambda_ex is my lambda expression >>> > >>> > is there a function wich can do smth like that? >>> > >>> > lambda _ex (unfold_parameters parameters) >>> > >>> > best regards >>> > _______________________________________________ >>> > Haskell-Cafe mailing list >>> > Haskell-Cafe(a)haskell.org >>> > http://www.haskell.org/mailman/listinfo/haskell-cafe >>> > >>> >

1 0

Parsec - Custom Fail
by mwinter＠brocku.ca 05 May '09

05 May '09

Hi, I am using parsec to parse a small programming language. The language is typed and I need to do some type checking, too. I have decided to do the parsing and type checking simultaneously in the my parsec parser. This approach avoids to keep source code positions in the data type in order to produce suitable error messages during type checking. Anyhow, because type errors are usually detected after parsing some code I need produce error messages with an earlier source position. Unfortunately, there is no function that produces an error taking a position as parameter. I tried the following: myFail :: SourcePos -> String -> GenParser tok st a myFail pos msg = setPosition pos >> fail msg This is already a workaround because I am modifying the position in the parser just to produce an error message. But even worse, it does not work. If I use this function as in: test :: Either ParseError () test = runParser (char '(' >> myFail (newPos "" 100 100) "Test") () "" "(" the position of the error is still the original position (line 1, column 2). As far as I can tell setPosition does not take effect until another symbol is read. This could be achieved by simply using anyToken if we are not at the end of the input (as in the example above). I came up with the following: myFail :: SourcePos -> String -> GenParser Char st a myFail pos msg = do { State toks _ st <- getParserState; setParserState $ State ('d':toks) pos st; anyToken; fail msg } This code works but it is not nice at all. The function myFail is not longer polymorphic in the type of tokens since we need an element of this data type in order to add it temporarily to the input ('d' above). My guess is that one has to enforce strictness at some point in order to work with the first approach, but I was not successful. Any ideas? Thanks, Michael

4 4

ANN: BUG FIX release of regex-tdfa-1.1.2
by ChrisK 05 May '09

05 May '09

Hello, While occasionally and slowly updating the future version of regex-tdfa I found a bug that exists in the released 1.1.1 version. It was just a matter of passing the wrong value into a function, so was easy to fix when I figured it out. The test case triggered an impossible "error" call and so I know this can kill a program that uses a buggy version of this library. Please upgrade regex-tdfa to version 1.1.2 which is available on hackage at: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/regex-tdfa Cheers, Chris

1 0

How to understand the fmap here ?
by z_axis 05 May '09

05 May '09

The following code snippets is from xmonad: -- Given a window, find the screen it is located on, and compute -- the geometry of that window wrt. that screen. floatLocation :: Window -> X (ScreenId, W.RationalRect) --....... rr <- snd `fmap` floatLocation w Prelude> :i fmap class Functor f where fmap :: (a -> b) -> f a -> f b It seems it is different from the definition of fmap ? sincerely! 2009-05-05 z_axis

4 3

StateT IO Action on `onKeyPress`
by Andy Stewart 05 May '09

05 May '09

Hi all, I have a function named `keymapTest` need moand state WindowListT, and WindowListT is `type WindowListT = StateT WindowList IO`. when i add "(\event -> keymapTest winList event >> return False)" after `onKeyPress` for handle key press event, i got GHC error: Manatee.hs:57:58: Couldn't match expected type `IO a' against inferred type `WindowListT Bool' In the first argument of `(>>)', namely `keymapTest winList event' In the expression: keymapTest winList event >> return False In the second argument of `onKeyPress', namely `(\ event -> keymapTest winList event >> return False)' So function `onKeyPress` just accept *one* IO-action? Have a way to fix above problem? Any help? Thanks! -- Andy Below is source code of Manatee.hs file. ------------------------------> Manatee.hs start <------------------------------ module Main where import Text.Printf import Data.Monoid import Data.List import Data.Maybe import Control.Monad import Control.Monad.State import Control.Applicative import Data.IORef import Graphics.UI.Gtk hiding (Window, windowNew, get) import Graphics.UI.Gtk.SourceView import Graphics.UI.Gtk.Abstract.Widget import Manatee.Event import Manatee.Buffer import Manatee.WindowList import Manatee.Pane import Manatee.Statusbar import Manatee.Utils import Manatee.Window import qualified Data.Set as Set import qualified Graphics.UI.Gtk.Windows.Window as W import qualified Graphics.UI.Gtk.Gdk.Events as E main :: IO () main = do -- Init. initGUI -- Root frame. rootFrame <- W.windowNew rootFrame `onDestroy` mainQuit -- quit main loop when root frame close -- Root frame status. windowFullscreen rootFrame -- fullscreen -- Windows list. let windowsList = WindowList 0 Set.empty evalStateT (do -- Window 1 window1 <- windowNewWithBuffer DTop "test" liftIO $ containerAdd rootFrame $ windowPaned window1 (window2, window3) <- windowSplitVertically window1 (window4, window5) <- windowSplitHorizontally window3 winList <- windowListGetList liftIO $ rootFrame `onKeyPress` (\event -> keymapTest winList event >> return False) -- Handle window content synchronous. windowHandleSynchronous ) windowsList -- Loop widgetShowAll rootFrame -- display all widget mainGUI keymapTest :: [Window] -> E.Event -> WindowListT Bool keymapTest winList event = do window <- liftIO $ windowFindFocus winList case window of Just x -> handleKeyPress x event Nothing -> return False handleKeyPress :: Window -> E.Event -> WindowListT Bool handleKeyPress window ev = do liftIO $ case eventTransform ev of Nothing -> return False Just e -> do let display = statusbarOutputSubitemSetText $ paneStatusbar $ windowPane $ window eventName = eventGetName e case eventName of -- Window commands. "M-t" -> display "windowSplitVertically" -- "M-t" -> windowSplitVertically window >> return False _ -> display $ printf "%s undefined." eventName ------------------------------> Manatee.hs end <------------------------------

2 5

Re: Using Takusen is a real intellectual challenge
by oleg＠okmij.org 05 May '09

05 May '09

Perhaps you might find the following code, relying on low-level Takusen's functions, useful http://darcs.haskell.org/takusen/Database/PostgreSQL/Test/pgaccess.hs The code is a stand-alone program that does the following: docstrings = [ "A helper to access a PostgreSQL from a `scripting' language.", "This function attempts to closely emulate `dbaccess' of Informix.", "The goal is to have my Scheme-to-Informix interface work with", "PostgreSQL with minimal changes.", "", "Synopsys:", " dbaccess <conn-parms>", "where <conn-parms> is the string of database connection parameters.", "", "The program connects to the database and listens on its standard", "input for a SQL command. A command is an ASCII sequence terminated by", "NL-NULL-NL.", "If the command is other than SELECT or COPY, we submit it to the database.", "On success, no reply is generated, and we wait for a new command.", "If the command starts with a /*simple*/ SELECT, we expect few rows.", "We submit the query to the database and write the result to stdout.", "If the command was SELECT, we make a query and write the result,", "in groups, to the stdout. Each group of results has the form:", " 0 NL", " for the last group of results", " <nrows> <space> <ncols> NL", " followed by the matrix of <nrows> * <ncols> field values in the", " row-major order. Each field value has the form", " <length>NL<value>", " where <length> is the length of the value proper (no NL).", "", "If the command was COPY, we assume ", " COPY /*<len> fname*/ table ... FROM STDIN...", " where <len> is the length of the file name. We open the file and", " send its contents to the server", "", "Any error causes the termination of this program.", "We log all the results to stderr." ] The above was my attempt at comments shared between compile-time and run-time. HERE documents would have certainly helped; I hope Haskell will get them one day. As the comments show, pgaccess is a very simple program to endow any scripting language (Scheme in my case) to communicate with a PostgreSQL database. The scripting language communicates with pgaccess via a pipe; thus the language itself needs to know nothing about databases and need not depend on any database libraries. The code has been designed keeping incremental processing firmly in mind. It was written about three years ago and in constant use. The program runs for days and indeed moves quite large amount of data to and from the database (the amount of data in a transaction can be larger than the amount of available memory).

1 0

ANN: atom-0.0.2
by Tom Hawkins 05 May '09

05 May '09

Atom is a DSL in Haskell for designed hard realtime embedded programs. At Eaton, we are using it to control hydraulic hybrid refuse trucks and shuttle buses. After my talk at CUFP (http://cufp.galois.com/2008/schedule.html) a few people inquired about atom -- I finally had a chance to upload it to Hackage. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/atom-0.0.2 Some new enhancements: - A simple rule scheduler for load balancing. - Signal probing for debug and data logging. - Functional coverage to monitor which rules have executed. - Started integration with the Yices SMT solver for bounded model checking. Experiences with our Eaton project: - 5K lines of Haskell/atom replaced 120K lines of matlab, simulink, and visual basic. - 2 months to port simulink design to atom. - 3K lines of atom generates 22K lines of embedded C. - Design composed of 450 atomic state transition rules. - Rules with execution periods from 1ms to 10s all scheduled at compile time to a 1 ms main loop. - 3 minute compilation time from atom source to ECU. - Atom design clears electronic/sw testing on first pass. - Currently in vehicle testing with no major issues. Tom

3 3

Using Takusen is a real intellectual challenge
by Gü?nther Schmidt 05 May '09

05 May '09

Hi, well I'm *trying* to use Takusen to export from one database into the other. I'm using Takusen for this so that I can guarantee that during the export not a single huge result is assembled (possibly in memory) and then insert in one lump into the second database. Trying to figure out how to do that in Takusen has left me totally exhausted, my brain is pudding and I need to have a lay down now. I couldn't even figure out whether that's at all possible. help Günther

2 1