- Haskell-Cafe - Haskell.org

Functional programmer's intuition for adjunctions?
by Edsko de Vries 06 Mar '08

06 Mar '08

Hi, Is there an intuition that can be used to explain adjunctions to functional programmers, even if the match isn't necessary 100% perfect (like natural transformations and polymorphic functions?). Thanks, Edsko

7 10

Haddock Documentation for Yhc Web Service available online
by Dimitry Golubovsky 06 Mar '08

06 Mar '08

Hi, I have regenerated Haddock documentation for Haskell modules included into the Yhc Web Service. http://www.golubovsky.org:5984/_utils/yhcws/index.html Thanks. -- Dimitry Golubovsky Anywhere on the Web

1 0

Re: [Haskell-cafe] Doubting Haskell
by Cale Gibbard 06 Mar '08

06 Mar '08

(I'm copying the list on this, since my reply contains a tutorial which might be of use to other beginners.) On 19/02/2008, Alan Carter <alangcarter(a)gmail.com> wrote: > Hi Cale, > > On Feb 19, 2008 3:48 PM, Cale Gibbard <cgibbard(a)gmail.com> wrote: > > Just checking up, since you haven't replied on the list. Was my > > information useful? Did I miss any questions you might have had? If > > you'd like, I posted some examples of using catch here: > > Thanks for your enquiry! My experiment continues. I did put a progress > report on the list - your examples together with a similar long an > short pair got me over the file opening problem, and taught me some > things about active whitespace :-) I couldn't get withFile working > (says out of scope, maybe 'cos I'm ghc 6.6 on my Mac) Make sure to put: import System.IO at the top of your source file, if you haven't been. This should import everything documented here: http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html > but it turned out the line I was looking for (collapsed from the examples) > was: > > text <- readFile "data.txt" `catch` \_ -> return "" > > This ensures the program never loses control, crashing or becoming > unpredictable by attempting to use an invalid resource, by yielding an > empty String if for any reason the file read fails. Then an empty > String makes it very quickly through parsing. I guess that's quite > "functiony" :-) > > Amazing how easy once I knew how. Even stranger that I couldn't find a > "bread and butter" example of it. > > Then I was going very quickly for a while. My file is dumped from a > WordPress MySql table. Well formed lines have 4 tab separated fields > (I'm using pipes for tabs here): > > line id | record id | property | value > > Line IDs are unique and don't matter. All lines with the same record > ID give a value to a property in the same record, similar to this: > > 1|1|name|arthur > 2|1|quest|seek holy grail > 3|1|colour|blue > 4|2|name|robin > 5|2|quest|run away > 6|2|colour|yellow > > Organizing that was a joy. It took minutes: let cutUp = tail (filter (\fields -> (length fields) == 4) (map (\x -> split x '\t') (lines text))) This should almost certainly be a function of text: cutUp text = tail (filter (\fields -> (length fields) == 4) (map (\x -> split x '\t') (lines text))) > I found a split on someone's blog (looking for a library tokenizer), > but I can understand it just fine. I even get to chuck out ill-formed > lines and remove the very first (which contains MySql column names) on > the way through! Sadly, there's no general library function for doing this. We have words and lines (and words would work here, if your fields never have spaces), but nobody's bothered to put anything more general for simple splitting into the base libraries (though I'm sure there's plenty on hackage -- MissingH has a Data.String.Utils module which contains split and a bunch of others, for example). However, for anything more complicated, there are also libraries like Parsec, which are generally really effective, so I highly recommend looking at that at some point. > I then made a record to put things in, and wrote some lines to play > with it (these are the real property names): > > data Entry = Entry > { occupation :: String > , iEnjoyMyJob :: Int > , myJobIsWellDefined :: Int > , myCoworkersAreCooperative :: Int > , myWorkplaceIsStressful :: Int > , myJobIsStressful :: Int > , moraleIsGoodWhereIWork :: Int > , iGetFrustratedAtWork :: Int > } > ... > let e = Entry{occupation = "", iEnjoyMyJob = 0} > let f = e {occupation = "alan"} > let g = f {iEnjoyMyJob = 47} > putStrLn ((occupation g) ++ " " ++ (show (iEnjoyMyJob g))) > > Then I ran into another quagmire. I think I have to use Data.Map to > build a collection of records keyed by record id, and fill them in by > working through the list of 4 item lists called cutUp. As with the > file opening problem I can find a few examples that convert a list of > tuples to a Data.Map, one to one. I found a very complex example that > convinced me a map from Int to a record is possible, but gave me no > understanding of how to do it. I spent a while trying to use foldl > before I decided it can't be appropriate (I need to pass more values). > So I tried a couple of recursive functions, something like: > > type Entries = M.Map Int Entry > ... > let entries = loadEntries cutUp > ... > loadEntries :: [[String]] -> Entries > loadEntries [] = M.empty Entries > loadEntries [x : xs] = loadEntry (loadEntries xs) x -- Possible common beginner error here: [x:xs] means the list with one element which is a list whose first element is x and whose tail is xs. Your type signature and the type of cutUp seems to confirm that this is the right type, but you don't seem to have a case to handle a longer list of lists. If you want just a list with first entry x, and with tail xs, that's just (x:xs). If you want to handle lists of lists recursively, you'll generally need two cases: ([]:xss) and ((x:xs):xss). We'll end up doing something different instead of recursion in a moment. > > loadEntry entries _ rid fld val = entries > > Trying to create an empty map at the bottom of the recursion so later > I can try to fiddle about checking if the key is present and crating a > new record otherwise, then updating the record with a changed one (a > big case would be needed deep in to do each property update). If I'm > on the right track it's not good enough to get better, so now I'm just > throwing bits of forest animals into the pot at random again :-( > > So I certainly would be grateful for a clue! The bits I can do (I got > a non-trivial wxHaskell frame sorted out quite easily, the tokenizing > and record bit were OK) I think show I'm not *totally* stupid at this, > I'm putting loads of time investment in (it's an experiement in > itself) but there do seem to be certain specific things that would be > ubiquitous patterns in any production or scripting environment, which > are not discussed at all and far from obvious. The more I see of > Haskell the more I suspect this issue is the gating one for popular > uptake. > > I couldn't help thinking of this bit, from the Wikipedia entry on the > Cocteau Twins: > > "The band's seventh LP, Four-Calendar Café, was released in late 1993. > It was a departure from the heavily-processed, complex and layered > sounds of Blue Bell Knoll and Heaven or Las Vegas, featuring clearer > and more minimalistic arrangements. This, along with the record's > unusually comprehensible lyrics, led to mixed reviews for the album: > Some critics accused the group of selling out and producing an > 'accessible album,' while others praised the new direction as a > felicitous development worthy of comparison with Heaven or Las Vegas." > > Best wishes, > > Alan I woke up rather early, and haven't much to do, so I'll turn this into a tutorial. :) Okay. The most common ways to build a map are by using the fromList, fromListWith, or fromListWithKey functions. You can see them in the documentation here: http://www.haskell.org/ghc/docs/latest/html/libraries/containers/Data-Map.h… The types are: fromList :: (Ord k) => [(k,a)] -> Map k a fromListWith :: (Ord k) => (a -> a -> a) -> [(k,a)] -> Map k a fromListWithKey :: (Ord k) => (k -> a -> a -> a) -> [(k,a)] -> Map k a They take a list of (key,value) pairs, and build a map from it. Additionally, the fromListWith function takes a function which specifies how the values should be combined if their keys collide. There is also a fromListWithKey function which allows the means of combination to depend on the key as well. At this point we realise something interesting about the way the data is being represented: if there is a field in someone's record with no row in the database, what should the resulting field contain? In C, they often use some integer which is out of range, like -1 for this. How about for a missing occupation field? Well, that's a String, you could use some generic failure string, or an empty string, but I'll show you another possibility that just might be convenient. If t is any type, then the type (Maybe t) consists of the values Nothing, and Just x, whenever x is a value of type t. This is another convenient way to represent the idea that a computation might fail. Let's start by changing your record type so that each field is a Maybe value, that is, either the value Nothing, or the value Just x, where x is the value it would have been. data Entry = Entry { occupation :: Maybe String , iEnjoyMyJob :: Maybe Int , myJobIsWellDefined :: Maybe Int , myCoworkersAreCooperative :: Maybe Int , myWorkplaceIsStressful :: Maybe Int , myJobIsStressful :: Maybe Int , moraleIsGoodWhereIWork :: Maybe Int , iGetFrustratedAtWork :: Maybe Int } There's a very general function in the module Control.Monad which I'd like to use just for the Maybe type here. It's called mplus, and for Maybe, it works like this: mplus (Just x) _ = Just x mplus Nothing y = y So if the first parameter isn't Nothing, that's what you get, otherwise, you get the second parameter. Of course, this operation has an identity element which is Nothing. So this lets you combine partial information expressed by Maybe types, in a left-biased way. It's about to become obvious that record types are less convenient than perhaps they could be in Haskell, and this is absolutely true -- I'd actually probably use a somewhat different representation myself (possibly something involving a Map from Strings (field names) to Int values), but I can't really be sure what you intend with this data, and how much type safety you want. I'll elide the field names just because I can here. It's not necessarily good style. combine :: Entry -> Entry -> Entry combine (Entry a1 a2 a3 a4 a5 a6 a7 a8) (Entry b1 b2 b3 b4 b5 b6 b7 b8) = Entry (a1 `mplus` b1) (a2 `mplus` b2) (a3 `mplus` b3) (a4 `mplus` b4) (a5 `mplus` b5) (a6 `mplus` b6) (a7 `mplus` b7) (a8 `mplus` b8) Even with all the shorthand, this is pretty ugly (and I'll show how I'd represent the data in a moment), but what this does is to combine two partial entries, favouring the information in the first, but filling the holes in the first with data from the second. This operation has an identity element, which is: emptyEntry = Entry Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Let's try a different representation, which is a little more flexible, but expresses less in the type system. data Entry = Entry { occupation :: Maybe String, survey :: M.Map String Int } deriving (Eq, Ord, Show) So now, instead of a bunch of separate Maybe Int fields, we have just one Map from String to Int. If we don't have information for a field, we simply won't have that key in the Map. Of course, this means we'll have to use strings for field labels. If that seems unhappy, you could always define a type like: data SurveyQuestion = IEnjoyMyJob | MyJobIsWellDefined | MyCoworkersAreCooperative | MyWorkplaceIsStressful | MyJobIsStressful | MoraleIsGoodWhereIWork | IGetFrustratedAtWork deriving (Eq, Ord, Show) to be used in place of the String type. Let's see how combine will look now: combine :: Entry -> Entry -> Entry combine (Entry o1 s1) (Entry o2 s2) = Entry (o1 `mplus` o2) (s1 `M.union` s2) Or, using the record syntax more: combine :: Entry -> Entry -> Entry combine e1 e2 = Entry { occupation = (occupation e1 `mplus` occupation e2), survey = (survey e1 `M.union` survey e2) } Again, this new version has an identity with respect to combine, which is: emptyEntry = Entry {occupation = Nothing, survey = (M.empty)} Now, we just need a way to take one of your rows, and turn it into a (key,value) pair, where the value is a partial entry. readRow :: [String] -> (Int, Entry) readRow [n, k, "occupation", v] = (read k, emptyEntry { occupation = Just v }) readRow [n, k, f, v] = (read k, emptyEntry { survey = M.singleton f (read v) }) readRow xs = error "failure case, should never happen!" There is actually a failure case that I'm not handling here, which is what happens when the value or key fails to parse as an Int. For that we'd use reads instead of read, but let's ignore it for now. We can then map this function over our cut up rows, something along the lines of: map readRow (cutUp text) at which point we'll have a list of (Int, Entry) pairs. We then want to fill up our Entries Map with those, and we want to combine them as we go using the combine function: entryMap text = M.fromListWith combine (map readRow (cutUp text)) Some final changes we could consider would be putting more of the error handling into readRow itself: if it was to return a singleton Map rather than an (Int, Entry) pair, then it could return the empty Map on failure, and the results would then be combined using the function M.unionsWith combine. We could move the length 4 test out of cutUp then, and just make it the fall-through case in readRow. I'll also use reads, which returns a list of (parse,rest-of-string) pairs, to handle the failure cases where the numbers don't parse, by just treating those rows as nonexistent: readRow :: [String] -> M.Map Int Entry readRow [n, k, f, v] = case reads k of [] -> M.empty -- the key didn't parse (k',_):_ -> if f == "occupation" then M.singleton k' (emptyEntry { occupation = Just v }) else case reads v of [] -> M.empty -- the value didn't parse (v',_):_ -> M.singleton k' (emptyEntry { survey = M.singleton f v' }) readRow xs = M.empty -- this handles the case when the list is any length but 4 cutUp text = tail (map (\x -> split x '\t') (lines text)) -- which allows cutUp to be simpler entryMap text = M.unionsWith combine (map readRow (cutUp text)) Anyway, I hope this tutorial gives some idea of how things progress, and what sort of thinking is generally involved. Note that the focus here was more on finding the right combining operations, and then using pre-existing higher-order functions to collapse the structure, than it was on recursion. Indeed, the final program there doesn't contain any explicit recursion at all! This is generally something to aim for. Using explicit recursion is generally a means of last resort. Higher order functions on data structures are our control structures. - Cale

14 15

Connection helpers: for people interested in network code
by Adam Langley 05 Mar '08

05 Mar '08

I generally find that I'm wrapping sockets in the same functions a lot and now I'm looking writings code which works with both Sockets and SSL connections. So I wrote a module, presumptuously called Network.Connection, although I'm not actually going to try and take that name (even in Hackage) unless I get a general agreement that this is a good thing. So, any comments on the interface, similar things that I should look at etc? http://www.imperialviolet.org/binary/network-connection/Network-Connection.… I made the BaseConnection an ADT, rather than a class because I wanted to avoid hitting the monomorphism restriction in code. That might have been a mistake, I'm not sure yet. If it doesn't excite anyone enough to reply, I'll change the name and put it in Hackage, mostly as is. Then I'll tie HsOpenSSL into it so that SSL connections work transparently. Cheers, AGL -- Adam Langley agl(a)imperialviolet.org http://www.imperialviolet.org

4 5

Re: [Yhc] Yhc Web Service quietly opened for public testing
by Thomas Hartman 05 Mar '08

05 Mar '08

That is seriously cool. Congratulations Dmitry! thomas. 2008/3/4, Dimitry Golubovsky <golubovsky(a)gmail.com>: > Hi, > > I finally got the Yhc Web Service (web-based front end to the > compiler) running in public testing mode. There hasn't been any > documentation written, and Haddock stuff not brought in order, but if > anyone wants to just get a taste of it, please open this hpaste entry: > > http://hpaste.org/6094 > > and follow the instructions. > > In 10 steps, you'll get Haskell to work in your web browser* ;) No > need to install anything. > > Feel free to edit the source code, and even deliberately make errors > to see how error log looks. At the moment, I do not run automatic > cleanup of failed compilations. > > This is one of my old tests, not showing any GUI interaction. However, > both documents browser and new entry form were written in Haskell > which gives some idea about what can be done. Sources of these forms > are in the Yhc repo. > > Thanks. > > ----------- > * Likely, your results will be better with Firefox than with MSIE. But > MSIE should work as well. > > > -- > Dimitry Golubovsky > > Anywhere on the Web > _______________________________________________ > Yhc mailing list > Yhc(a)haskell.org > http://www.haskell.org/mailman/listinfo/yhc >

3 2

2nd CFP: PLMMS 2008
by Jacques Carette 05 Mar '08

05 Mar '08

SECOND CALL FOR PAPERS * UPDATE: Post-workshop proceedings in Journal of Automated Reasoning * UPDATE: Invited talk by Conor McBride Second Workshop on Programming Languages for Mechanized Mathematics (PLMMS 2008) http://events.cs.bham.ac.uk/cicm08/workshops/plmms/ As part of CICM / Calculemus 2008 Birmingham, UK, 28-29 July 2008 This workshop is focused on the intersection of programming languages (PL) and mechanized mathematics systems (MMS). The latter category subsumes present-day computer algebra systems (CAS), interactive proof assistants (PA), and automated theorem provers (ATP), all heading towards fully integrated mechanized mathematical assistants that are expected to emerge eventually (cf. the objective of Calculemus). The two subjects of PL and MMS meet in the following topics, which are of particular interest to this workshop: * Dedicated input languages for MMS: covers all aspects of languages intended for the user to deploy or extend the system, both algorithmic and declarative ones. Typical examples are tactic definition languages such as Ltac in Coq, mathematical proof languages as in Mizar or Isar, or specialized programming languages built into CA systems. Of particular interest are the semantics of those languages, especially when current ones are untyped. * Mathematical modeling languages used for programming: covers the relation of logical descriptions vs. algorithmic content. For instance the logic of ACL2 extends a version of Lisp, that of Coq is close to Haskell, and some portions of HOL are similar to ML and Haskell, while Maple tries to do both simultaneously. Such mathematical languages offer rich specification capabilities, which are rarely available in regular programming languages. How can programming benefit from mathematical concepts, without limiting mathematics to the computational worldview? * Programming languages with mathematical specifications: covers advanced "mathematical" concepts in programming languages that improve the expressive power of functional specifications, type systems, module systems etc. Programming languages with dependent types are of particular interest here, as is intentionality vs extensionality. * Language elements for program verification: covers specific means built into a language to facilitate correctness proofs using MMS. For example, logical annotations within programs may be turned into verification conditions to be solved in a proof assistant eventually. How need MMS and PL to be improved to make this work conveniently and in a mathematically appealing way? These issues have a very colorful history. Many PL innovations first appeared in either CA or proof systems first, before migrating into more mainstream programming languages. Some examples include type inference, dependent types, generics, term-rewriting, first-class types, first-class expressions, first-class modules, code extraction etc. However, such innovations were never aggressively pursued by builders of MMS, but often reconstructed by programming language researchers. This workshop is an opportunity to present the latest innovations in MMS design that may be relevant to future programming languages, or conversely novel PL principles that improve upon implementation and deployment of MMS. We also want to critically examine what has worked, and what has not. Why are all the languages of mainstream CA systems untyped? Why are the (strongly typed) proof assistants so much harder to use than a typical CAS? What forms of polymorphism exist in mathematics? What forms of dependent types may be used in mathematical modeling? How can MMS regain the upper hand on issues of "genericity" and "modularity"? What are the biggest barriers to using a more mainstream language as a host language for a CAS or PA/ATP? Invited Talk ------------ Conor McBride (Alta Systems, Northern Ireland) will give an invited talk. Submission ---------- Submission works through EasyChair http://www.easychair.org/conferences/?conf=plmms2008 Two kinds of papers will be considered: * Full research papers may be up to 12 pages long. Authors of accepted papers are expected to present their work on the workshop in a regular talk. * Position papers may be up to 4 pages long. The workshop presentation of accepted position papers consists of two parts: a stimulating statement of certain issues or challenges by the author, followed by a discussion in the plenum. Papers should use the usual ENTCS style http://www.entcs.org/prelim.html (11 point version), and will be reviewed by the program committee. Informal workshop proceedings will be circulated as a technical report. Moreover there will be post-workshop proceedings of improved research papers, or position papers that have been completed into full papers, to appear in a special issue of the Journal of Automated Reasoning. There will be a separate submission and review phase for this, where papers from both PLMMS 2007 and 2008 will be considered. Programme Committee ------------------- Jacques Carette (Co-Chair) (McMaster University, Canada) John Harrison (Intel Corporation, USA) Hugo Herbelin (INRIA, Ecole polytechnique, France) James McKinna (Radboud University Nijmegen, Netherlands) Ulf Norell (Chalmers University, Sweden) Bill Page Christophe Raffalli (Universite de Savoie, France) Josef Urban (Charles University, Czech Republic) Stephen Watt (ORCCA, University of Western Ontario, Canada) Makarius Wenzel (Co-Chair) (Technische Universitaet Muenchen, Germany) Freek Wiedijk (Radboud University Nijmegen, Netherlands) Important Dates --------------- * Submission deadline - 5 May 2008 * Notification of acceptance - 6 June 2008 * Final version - 7 July 2008 (approximately) * Workshop - 28-29 July 2008

1 0

Job opening: Use Haskell to save the environment!
by Ketil Malde 05 Mar '08

05 Mar '08

Well - maybe¹. I'm not sure how relevant this is for this list, but I thought I should mention that there is an open position for a 3-year Ph.D. scolarship at IMR where I work. The work is in bioinformatics, and as I'm a happy Haskell user, I'd be happy to see qualified applicants who know Haskell as well. If you are interested, and posess a Master's degree (or equivalent education), a rough translation of the announcement is attached - the official one (in Norwegian) can be found at: http://www.imr.no/aktuelt/ledige_stillinger/stipendiat_bioinformatikk, Please contact me with any questions! -k ¹) The target of the project is the sea louse, which is a large ecological and economical problem. -- If I haven't seen further, it is by standing in the footprints of giants

1 0

Orphan instances
by Henning Thielemann 05 Mar '08

05 Mar '08

Consider the following modules module A class A t module T import A data T a module B import A import T class A t => B t instance B t => A (T t) GHC emits warning about orphan instance A (T t), since neither A nor T are defined in B. However I can't move the instance to A or T since it depends on B. Would it be fine to lift the restriction, such that it is accepted to declare the instance in a module where the type or the class or a superclass (this is new) is defined? In my example class B provides conversion toInteger (that is Integral), class A provides conversion toRational (that is Real) and T is Ratio.

2 1

Re: Exporting Haskell Libraries to C Programmers
by Bruce, Joseph R (Joe) 05 Mar '08

05 Mar '08

Don Stewart <dons <at> galois.com> writes: > > joseph.bruce: > > Hi, > > > > I have a Haskell library that I want to make available via FFI to C > > programmers on my project team. I read this thread > > (http://thread.gmane.org/gmane.comp.lang.haskell.cafe/21447) which had > > some interesting ideas, but they seemed unresolved. Or maybe it answers > > my question but I don't understand it. > > > > Is there a way I can package (ghc-)compiled Haskell code into a > > statically-linked library and not force the C programmers to include > > headers and libraries that they have no knowledge of and undefine a > > seemingly endless list of preprocessor symbols (run ghc with the verbose > > flag and look at the calls to gcc)? Can this process be automated? > > Yes, check the FFI documentation for the main story. > > In short, build the Haskell code with cabal, with your foreign export > Haskell functions in the cbits. That bundle can then be linked against > C code. > > You do need to link your app against libHSrts.a and libHSbase.a (and > other libs you use), but assuming you foreign export, the code > to call will look just like normal C stuff. > Thanks Don. I finally got back to this. I hadn't looked at CABAL before. It's a very useful tool and met all my library-forming needs. That's only half my problem though. I'm trying to make the use of this Haskell code as transparent as possible to the C programmers on the team. Telling them about the Haskell base libraries dependency or distributing those libraries with my code is not too bad, but the list of -u flags that the linker needs is brutal. Is there a way to avoid it, or embed it in the package? Ex (using ghc-6.8.2 -v): ... gcc -v -o primes Primes.o ./Primes_stub.o hs_primes_wrapper.o cprimes.c -Bc:\ghc\ghc-6.8.2\gcc-lib/ -DDONT_WANT_WIN32_DLL_SUPPORT -Lc:/ghc/ghc-6.8.2/lib\base-3.0.1.0 -Lc:/ghc/ghc-6.8.2 -Lc:/ghc/ghc-6.8.2/gcc-lib -lHSbase-3.0.1.0 -lwsock32 -lmsvcrt -lkernel32 -luser32 -lshell32 -lHSrts -lm -lgmp -lwsock32 -u _base_GHCziBase_Izh_static_info -u _base_GHCziBase_Czh_static_info -u _base_GHCziFloat_Fzh_static_info -u _base_GHCziFloat_Dzh_static_info -u _base_GHCziPtr_Ptr_static_info -u _base_GHCziWord_Wzh_static_info -u _base_GHCziInt_I8zh_static_info -u _base_GHCziInt_I16zh_static_info -u _base_GHCziInt_I32zh_static_info -u _base_GHCziInt_I64zh_static_info -u _base_GHCziWord_W8zh_static_info -u _base_GHCziWord_W16zh_static_info -u _base_GHCziWord_W32zh_static_info -u _base_GHCziWord_W64zh_static_info -u _base_GHCziStable_StablePtr_static_info -u _base_GHCziBase_Izh_con_info -u _base_GHCziBase_Czh_con_info -u _base_GHCziFloat_Fzh_con_info -u _base_GHCziFloat_Dzh_con_info -u _base_GHCziPtr_Ptr_con_info -u _base_GHCziPtr_FunPtr_con_info -u _base_GHCziStable_StablePtr_con_info -u _base_GHCziBase_False_closure -u _base_GHCziBase_True_closure -u _base_GHCziPack_unpackCString_closure -u _base_GHCziIOBase_stackOverflow_closure -u _base_GHCziIOBase_heapOverflow_closure -u _base_GHCziIOBase_NonTermination_closure -u _base_GHCziIOBase_BlockedOnDeadMVar_closure -u _base_GHCziIOBase_BlockedIndefinitely_closure -u _base_GHCziIOBase_Deadlock_closure -u _base_GHCziIOBase_NestedAtomically_closure -u _base_GHCziWeak_runFinalizzerBatch_closure -u _base_GHCziConc_ensureIOManagerIsRunning_closure ... This particular example is a build on a windows system and makes use of the .o's directly and not the .a I create, but those are of no consequence as this is ultimately a linking issue, not a compilation issue. I don't know what these -u's are for, but I know that if I take them out, the linker fails. They do change from one system to another (this list fails with the linker on RHEL 5). But right now my solution for the C programmers is a make file with $haskell_undefine_flags = <that mess up there>, and I'd prefer something more elegant and less system dependent. I am willing to accept that there is no good way around it, but perhaps someone has dealt with this issue before. Any help? Thanks. Joe

2 1

ANN: Takusen 0.8
by Alistair Bayley 05 Mar '08

05 Mar '08

Oleg and I are pleased to announce the release of Takusen 0.8. (Don Stewart did an interim 0.7 release for us a few weeks ago, and added us to Hackage. This release is a tidy-up of some loose ends, and some bug fixes. Hence, I've summarise the changes since the 0.6 release.) Changes since 0.6: - ODBC support. This still has a few gaps (and probably bugs and rough edges) but should be fairly usable. - support for reusable/persistent sessions, so you can hang onto the connection object between invocations of withSession (this was in release 0.6 but omitted from the release notes). - improvements to the Cabal Setup scripts, which should give better experiences for ghc-6.4, ghc-6.6, and ghc-6.8. The (eventual) 1.4 release of Cabal should be able to build our haddock docs, too. - improved UTF8 decoder (marshals directly from buffer). The release bundle: http://hackage.haskell.org/packages/archive/Takusen/0.8/Takusen-0.8.tar.gz The latest code: darcs get http://darcs.haskell.org/takusen Docs: http://darcs.haskell.org/takusen/doc/html/index.html A comprehensive description of API usage can be found in the documentation for module Database.Enumerator (look for the Usage section): http://darcs.haskell.org/takusen/doc/html/Database-Enumerator.html Future plans: - FreeTDS backend (Sybase and MS Sql Server) - support for Blobs and Clobs For those of you unfamiliar with Takusen, here is our HCAR blurb: Takusen is a library for accessing DBMS's. Like HSQL, we support arbitrary SQL statements (currently strings, extensible to anything that can be converted to a string). Takusen's `unique-selling-point' is safety and efficiency. We statically ensure all acquired database resources - such as cursors, connection and statement handles - are released, exactly once, at predictable times. Takusen can avoid loading the whole result set in memory, and so can handle queries returning millions of rows in constant space. Takusen also supports automatic marshalling and unmarshalling of results and query parameters. These benefits come from the design of query result processing around a left-fold enumerator. Currently we fully support ODBC, Oracle, Sqlite, and PostgreSQL.

1 1