December 2005 - Haskell

Announcing Djinn, version 2004-12-11, a coding wizard
by Lennart Augustsson 07 Apr '11

07 Apr '11

Howdy, y'all! I've written a small program that takes a (Haskell) type and gives you back a function of that type if one exists. It's kind of fun, so I thought I'd share it. It's probably best explained with a sample session. calvin% djinn Welcome to Djinn version 2005-12-11. Type :h to get help. # Djinn is interactive if not given any arguments. # Let's see if it can find the identity function. Djinn> f ? a->a f :: a -> a f x1 = x1 # Yes, that was easy. Let's try some tuple munging. Djinn> sel ? ((a,b),(c,d)) -> (b,c) sel :: ((a, b), (c, d)) -> (b, c) sel ((_, v5), (v6, _)) = (v5, v6) # We can ask for the impossible, but then we get what we # deserve. Djinn> cast ? a->b -- cast cannot be realized. # OK, let's be bold and try some functions that are tricky to write: # return, bind, and callCC in the continuation monad Djinn> type C a = (a -> r) -> r Djinn> returnC ? a -> C a returnC :: a -> C a returnC x1 x2 = x2 x1 Djinn> bindC ? C a -> (a -> C b) -> C b bindC :: C a -> (a -> C b) -> C b bindC x1 x2 x3 = x1 (\ c15 -> x2 c15 (\ c17 -> x3 c17)) Djinn> callCC ? ((a -> C b) -> C a) -> C a callCC :: ((a -> C b) -> C a) -> C a callCC x1 x2 = x1 (\ c15 _ -> x2 c15) (\ c11 -> x2 c11) # Well, poor Djinn has a sweaty brow after deducing the code # for callCC so we had better quit. Djinn> :q Bye. To play with Djinn do a darcs get http://darcs.augustsson.net/Darcs/Djinn or get http://darcs.augustsson.net/Darcs/Djinn/Djinn.tar.gz Then just type make. (You need a Haskell 98 implementation and some libraries.) And then start djinn. For the curious, Djinn uses a decision procedure for intuitionistic propositional calculus due to Roy Dyckhoff. It's a variation of Gentzen's LJ system. This means that (in theory) Djinn will always find a function if one exists, and if one doesn't exist Djinn will terminate telling you so. This is the very first version, so expect bugs. :) Share and enjoy. -- Lennart

8 13

Haskell-mode 2.0
by Stefan Monnier 02 Feb '09

02 Feb '09

I have recently taken over maintainership of Haskell-mode, and after making a bunch of changes, I figured it would be a good idea to make a new release. You can find this new release at: http://www-perso.iro.umontreal.ca/~monnier/elisp/ If you think it should also be found at http://www.haskell.org/haskell-mode/, then please tell John Peterson to get back to me (my email to him seem to go straight to the bitbucket. John?). This release has several changes that have all been only lightly tested, especially w.r.t compatibility with various Emacsen. See appended the NEWS file that describes some of the notewirthy changes. Stefan Changes since 1.45: * keybindings C-c <char> have been replaced by C-c C-<char> so as not to collide with minor modes. * The following modules are now automatically activated without having to add anything to haskell-mode-hook: haskell-font-lock (just turn on global-font-lock-mode). haskell-decl-scan (just bind `imenu' to some key). * In recent Emacsen, haskell-doc hooks into eldoc-mode. * haskell-hugs and haskell-ghci are superceded by inf-haskell. * Indentation rules have been improved when using layout inside parens/braces. * Symbols like -> and \ can be displayed as actual arrows and lambdas. See haskell-font-lock-symbols. * Tweaks to the font-lock settings. Among other things paren-matching with things like \(x,y) should work correctly now. * New maintainer <monnier(a)gnu.org>.

3 6

ANN: HDBC (Haskell Database Connectivity)
by John Goerzen 14 Jan '06

14 Jan '06

Hi, I'm pleased to announce the first alpha release (I could call it a "developer's preview", but then I don't wear a suit) of HDBC. HDBC is the Haskell Database Connectivity library. It is patterned after Perl's DBI. I wrote it from scratch -- this is not a reimplementation of HSQL -- because several design decisions in HSQL have been causing me trouble. I am also announcing the first alpha release of the Sqlite3 backend driver for HDBC. I anticipate writing backend drivers for the same databases HSQL supports (though probably not Sqlite2), but it should be easier for others to write HDBC drivers as well. To answer a potential FAQ, HDBC does not attempt to do what HaskellDB does, though HDBC could potentially replace HSQL as the underlying layer of choice in HaskellDB. I'm including the README below, which goes into a bit more detail. To get HDBC: darcs get --partial http://darcs.complete.org/hdbc To get the Sqlite3 driver: darcs get --partial http://darcs.complete.org/hdbc-sqlite3 Welcome to HDBC, Haskell Database Connectivity. HDBC is modeled loosely on Perl's DBI interface, though it has also been influenced by Python's DB-API v2, JDBC in Java, and HSQL in Haskell. Features of HDBC ---------------- HDBC provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with any number of backend SQL databases (MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.) HDBC is a from-scratch effort. It is not a reimplementation of HSQL, though its purpose is the same. Some features HDBC has which HSQL lacks include: * Ability to use replacable parameters to let one query be executed multiple times (eliminates the need for an "escape" function) * Ability to access returned rows by column number * Ability to read data from the SQL server on-demand rather than reading the entire result set up front * HUnit testsuite for each backend driver * Well-defined standard API and easy backend driver implementation Features on the TODO list which will appear shortly include: * Support for translation between Haskell and SQL types * Lazy reading of the entire result set (think hGetContents, but for the results of SELECT) * Support for querying metadata (column names, types, etc.) * Additional infrastructure for querying database server properties * Add-on package to integrate with MissingH (filesystem in a database, backend for AnyDBM, etc.) HDBC Drivers ------------ The following HDBC drivers exist: Sqlite v3, darcs get --partial http://darcs.complete.org/hdbc-sqlite3 More will be coming shortly. -- John Goerzen December 20, 2005

8 19

Re: Haskell Digest, Vol 28, Issue 22
by Paul Johnson 31 Dec '05

31 Dec '05

Cale Gibbard wrote: >If something looks like 'article' material, you should feel free to >edit however you like, but usually you should try not to outright >remove valid content. In any event, all the old versions are kept, so >it's no big deal if something goes missing for a while. > Could I also point out the slowly developing WikiBook on Haskell at http://en.wikibooks.org/wiki/Programming:Haskell If what you are writing has a tutorial flavour then see if it would fit there. Paul.

1 0

modern Arrays documented?
by Bulat Ziganshin 31 Dec '05

31 Dec '05

Hello haskell, i'm ready to write my own guide to using modern Arrays library (i mean MArray/IArray machinery, unboxed arrays, diff. arrays and parallel arrays). but may be there is already some docs on this topic (i don't count contents of modules itself)? -- Best regards, Bulat mailto:bulatz@HotPOP.com

1 0

RE: [Haskell] Boxing (Day) Question
by Simon Peyton-Jones 29 Dec '05

29 Dec '05

Ashley I think Lennart answered your question rather well. As he says, the restriction is that an unboxed type must not instantiate a polymorphic type variable (and that polymorphic type variables may not have an unboxed kind). You may like to read the paper "Unboxed types as first-class citizens", which explains some of it, I think. http://research.microsoft.com/%7Esimonpj/Papers/unboxed-values.ps.Z The .NET CLR lifts the restriction by specialising code, so that it can adapt to whether it is moving Int# or Double# values around. In Haskell, though, it's not possible to statically generate all the instances you need, so you'd need run-time code generation to do this. It's a real restriction, and sometimes very tiresome, but I'm not planning to fix it soon, unless I have a brilliant idea for how to do it easily. Simon | -----Original Message----- | From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On Behalf Of Ashley Yakeley | Sent: 26 December 2005 08:49 | To: haskell(a)haskell.org | Subject: [Haskell] Boxing (Day) Question | | As I understand it, with unboxing switched on (->) actually has this | kind: | | (->) :: ? -> ? -> * | | Reading the Core specification, GHC has a particular kind of | "polykindism" which introduces kind "?", and defines specialisation such | that "?" may be replaced by "*" or "#" inside any kind. Accordingly, | (->) may be specialised: | | (->) :: * -> * -> * | (->) :: # -> * -> * | (->) :: * -> # -> * | (->) :: # -> # -> * | | Examples: | | module Boxing where | import GHC.Exts | | fooSS :: (->) Int Int | fooSS 3 = 5 | fooSS _ = 2 | | fooHS :: (->) Int# Int | fooHS 3# = 5 | fooHS _ = 2 | | fooSH :: (->) Int Int# | fooSH 3 = 5# | fooSH _ = 2# | | fooHH :: (->) Int# Int# | fooHH 3# = 5# | fooHH _ = 2# | | type Fun = (->) | | fooHH' :: Fun Int# Int# | fooHH' 3# = 5# | fooHH' _ = 2# | | Do any other type constructors or symbols have a kind with "?" in it? | | I like the "kind" approach to unboxed types. It automatically rules out | "[Int#]" by kind mismatch, for instance. But I was disappointed I | couldn't do this with GHC 6.4.1: | | data MyC s = MkMyC (s Int# Int) | | or | | class C s where | c :: s Int# Int | | (in either case: "Kind error: Expecting kind `k_a19o', but `Int#' has | kind `#' In the class declaration for `C'") | | There's no kind mismatch here, merely a restriction that the kinds of | arguments to classes be #-free. I can't do this, either: | | newtype MyD (u :: #) = MkMyD (u -> Bool) | | GHC actually complains about parsing the kind signature. | | Would Bad Things Happen if this restriction were lifted? I don't have a | pressing need for it actually, though this might be useful: | | class Boxed (b :: *) (u :: #) | b -> u, u -> b where | box :: u -> b | unbox :: b -> u | | In case you're worried, lifting the restriction would NOT allow | uncompilable things such as | | newtype MyE (u :: #) = MkMyE u | | ...simply because there's already a straightforward restriction that | values in type constructors have types of kind "*". It is merely the | notion of "#-freeness" that seems unnecessary. It would, however, allow | this: | | newtype Box (u :: #) = MkBox (() -> u) | | ...and quite possibly this: | | newtype Value (x :: ?) = MkValue (() -> x) | | I believe these can be compiled safely? | | -- | Ashley Yakeley, Seattle WA | | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell

2 1

ANN: hdbc-missingh
by John Goerzen 29 Dec '05

29 Dec '05

Hello, I'm pleased to announce the first release of HDBC-MissingH, a library to add database features to MissingH. At the present time, this allows any HDBC database to act as a backend for the MissingH.AnyDBM architecture. As such, you can use a SQL database as storage for a simple DBM-like key/value interface. This is particularly interesting with Sqlite3, which is an embedded SQL engine that stores its data in a single file (similar to *dbm). Download from: http://quux.org/devel/hdbc Darcs repo: darcs get --partial http://darcs.complete.org/hdbc-missingh -- John

1 0

A few newbie questions about tracing/debugging and order of execution
by Hunter Kelly 29 Dec '05

29 Dec '05

Heya, I decided to play around with Haskell and see what it's like. I used a small problem to explore it. Basically, given two words, find the least number of 1 letter changes that will go from one word to the other (e.g. for "fig" and "dog" either fig -> fog -> dog or fig -> dig -> dog). I came up with a solution, but I have to say it was quite difficult to get any debugging information, and when I did, the result was fairly surprising! Here's the out put I got: dagger:~/stuff$ ./figt /usr/share/dic/twords fig dog Word: dog visited: ["bit","bin","bid","bib","bug","bog","beg","bag","fix","fit","fir","fin","fie","fib","fog","fag","wig","rig","pig","jig","gig","dig","big","fig"] Word: dig visited: ["big","fig"] Word: fig visited: [] fig -> dig -> dog The first thing I found surprising was that the debug output comes in the "reverse" order - I would have expected it to be the output for fig, then dig, then dog. Secondly, I'm not entirely sure why I only got output for the statements along the "solution" path. If I try a combination that has no solution, I get no output at all. I got the program working, and I'm quite intrigued, but I figure it's probably important to figure out why the above things happen... I'm using GHC 6.4.1, but I get the same thing if I use runhugs. Thanks! --------- figt.hs -------------- import System import System.IO import Data.Set import Debug.Trace type Word = String data Path = None | Path Word Path instance Show Path where showsPrec _ path = showsPath path where showsPath :: Path -> ShowS showsPath None = ("<None>"++) showsPath (Path w None) = (w ++) showsPath (Path w p) = (showsPath p) . ((" -> " ++ w)++) findPath :: Word -> Word -> Set String -> Path findPath orig target allWords = let gen = singleton orig in iteratePath [(Path orig None)] gen [] where iteratePath :: [Path] -> Set String -> [String] -> Path iteratePath [] _ _ = None iteratePath (None: _) _ _ = None iteratePath (fullPath@(Path w _):remain) generated visited = let allPossibilities = findPossibleWords w existant = Prelude.filter (\p -> member p allWords) allPossibilities new = Prelude.filter (\e -> not (member e generated)) existant marked = foldl (\x y -> insert y x) generated new thingum = trace ("Word: " ++ w ++ "\n\tvisited: " ++ (show visited) ++ "\n") fullPath todo = remain ++ Prelude.map (\u -> (Path u thingum)) new in if target == w then thingum else if length todo > 0 then iteratePath todo marked (w:visited) else None findPossibleWords :: String -> [String] findPossibleWords word = concatMap enumChars (splits) where enumChars (prefix, _:cs) = Prelude.map (\c -> prefix ++ [c] ++ cs) ['a'..'z'] splits = Prelude.map (\x -> splitAt x word) [0..((length word) -1)] findAllWordsSizeN :: String -> Int -> Set String findAllWordsSizeN content wordLength = fromDistinctAscList (Prelude.filter (\x -> wordLength == (length x)) (lines content)) main :: IO () main = do [wordsFile, orig, target] <- getArgs contents <- readFile wordsFile allWordsSizeN <- (return (findAllWordsSizeN contents (length orig))) putStrLn (show (findPath orig target allWordsSizeN ))

4 5

more newbie questions regarding do syntax, mondic context & Data.HashTable
by Hunter Kelly 29 Dec '05

29 Dec '05

Hi there, I'm having some trouble trying to get information out of a HashTable. I'm using it to represent a set (I'm using a hash table for O(1) speed reasons to compare against Data.Sets O(lgN) operations). I'm trying to write a simple function, member, which returns whether or not a key is in the HashTable. I've tried the following: member :: HashTable String Int -> String -> Bool member hash x = let r = do return (Data.HashTable.lookup hash x ) in case r of Nothing -> False (Just v) -> True But this seems to always return True. I _think_ the type of r here is IO (Maybe Int), but I'm trying to unwrap the IO part. However, if I try: member :: HashTable String Int -> String -> Bool member hash x = let r = do Data.HashTable.lookup hash x in case r of Nothing -> False (Just v) -> True I get the following error: figt.hs:46:31: Couldn't match `IO (Maybe Int)' against `Maybe a' Expected type: IO (Maybe Int) Inferred type: Maybe a When checking the pattern: Nothing In a case alternative: Nothing -> False How can I get at the underlying value? Can I only access it from within a "do" construct? Is there anyway to get at this function to return just True or False? Or has using something that uses an IO monad "polluted" everything else that depends on the answer? H

3 2

RE: [Haskell] A question about fundeps <-> GADT interaction
by Simon Peyton-Jones 29 Dec '05

29 Dec '05

Tomasz Intriguing! I'm afraid it'll be some time before your code works, though. First I have to get GADTs and type classes to play together nicely, which I am hoping to do during Jan/Feb. Then I'll have to think about the interaction between GADTs and fundeps. As of today, if it works at all, it's quite amazing. Simon | -----Original Message----- | From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On Behalf Of Tomasz | Zielonka | Sent: 22 December 2005 14:16 | To: Haskell Mailing List | Subject: [Haskell] A question about fundeps <-> GADT interaction | | Hello! | | (This message is a literate Haskell module) | | > {-# OPTIONS -fglasgow-exts -fno-warn-missing-methods #-} | > module Term where | | The papers on GADTs have an example showing how you can transform, | traverse and evaluate ASTs (or terms) with more type safety. I've | used such an approach in one of my applications and it works remarkably | well. | | However, I would like to be able to "turn off" that type-safety | in some parts of code, for example to separate parsing from typing. | I thought I found a way to do this, because I was able to create Typed | (with all consistency checking) and Untyped (without consistency | checking) terms. Unfortunately I seem to be unable to write any useful | function on such terms - GHC complains that there are type errors. | | I think this is because of the known problem with current GADT | implementation in GHC, namely - bad GADT / type-classes interaction. I | would be very happy to hear that it will be solved in GHC 6.6. | | I use an additional type parameter for Term that determines whether | the Term is used as Typed or Untyped. Typed terms will have types | (Term Typed Int), (Term Typed Bool), ..., but Untyped terms only | one type: (Term Untyped ()) | | I use a multiparameter type-class with fundeps to describe a relation | between the Typed/Untyped tag used, the types actually used in data | constructors and the resulting "phantom" type. | | > class F f a b | f a -> b where | > -- these methods are just for experiments in GHCi | > a2b :: f -> a -> b | > b2a :: f -> b -> a | | > data Typed = Typed | > instance F Typed a a where | | > data Untyped = Untyped | > instance F Untyped a () where | | > data Term f a where | > Lit :: (F f Int int) => | > Int -> Term f int | > Succ :: (F f Int int) => | > Term f int -> Term f int | > IsZero :: (F f Int int, F f Bool bool) => | > Term f int -> Term f bool | > If :: (F f Bool bool, F f a a') => | > Term f bool -> Term f a' -> Term f a' -> Term f a' | | Some examples: | | a typeable term | | > ex1 :: Term Untyped () | > ex1 = | > If (IsZero (Succ (Lit 0))) | > (Lit 1) | > (Lit 2) | | the same as ex1, but Typed | | > ex1' :: Term Typed Int | > ex1' = | > If (IsZero (Succ (Lit 0))) | > (Lit 1) | > (Lit 2) | | a term that has type bug, but will be accepted as Untyped | | > ex2 :: Term Untyped () | > ex2 = | > If (IsZero (Succ (Lit 0))) | > (Lit 1) | > (IsZero (Lit 2)) | | Here is the function that doesn't type check (you can comment it out to | get the rest of code to compile). | | > -- A simple cast from typed terms to untyped terms | > untype :: Term Typed a -> Term Untyped () | > untype (Lit x) = Lit x | > untype (IsZero t) = IsZero (untype t) | > untype (Succ t) = Succ (untype t) | > untype (If c t e) = If (untype c) (untype t) (untype e) | | The error given by GHC (for the commented "untype" function) is: | | T.hs:52:8: | Couldn't match the rigid variable `a' against `Int' | `a' is bound by the type signature for `untype' | Expected type: Int | Inferred type: a | When using functional dependencies to combine | F Typed a a, arising from the instance declaration at T.hs:13:0 | F Typed Int a, | arising from the pattern for `Lit' at T.hs:52:8-12 at T.hs:52:8-12 | In the definition of `untype': untype (Lit x) = Lit x | Failed, modules loaded: none. | | So it seems it can't infer that the 'a' in (F Typed Int a) is Int. | At the same time... | | *T> :t a2b | a2b :: (F f a b) => f -> a -> b | *T> :t a2b Untyped | a2b Untyped :: a -> () | *T> :t a2b Typed | a2b Typed :: b -> b -- see? it knows a and b are equal! | *T> :t b2a Typed | b2a Typed :: b -> b | | If there is another way to do this right now (conveniently, Oleg! ;-), I | would be more than happy to hear about it. | | If this worked, it would be a cool trick and a nice example for GADT | use. Let me know if it was proposed before. | | Best regards | Tomasz | | -- | I am searching for a programmer who is good at least in some of | [Haskell, ML, C++, Linux, FreeBSD, math] for work in Warsaw, Poland | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell

3 3