- Haskell-Cafe - Haskell.org

An idea to document inter department dependencies in Haskell
by C K Kashyap 14 Mar '12

14 Mar '12

My dear Haskell folks, I work in a software company where I develop components that go into a really complex system that's built of several components developed by different teams that are geographically distributed. The components themselves run in a distributed manner across client and several servers. All our design documents are in wiki's (fashionably so). As a result of the above situation and the fact that our code base is not in Haskell, we are almost always dealing with "Oh I did not know this would effect that" and "Oh I have no clue what all this change will impact". I've been wondering if it would be a good idea to try and create a spec for the system in Haskell, such that would could get a better handle on the dependencies. Perhaps an EDSL, that would allow Product Managers to introduce new requirements - compilation failures would indicate the areas that would need to be touched. How is it different from having a spec in a diagram - well, in that case, we are requiring humans to look at the diagram to detect dependencies instead of the compiler telling me about the dependencies. I am about to start off with some implementation to capture my idea - I can articulate it better then. However, I just wanted to throw it out there to check if anyone's had some thought in this direction or if there is some prior art here. Regards, Kashyap

2 2

Is there a better way to subtyping?
by Jeff Shaw 14 Mar '12

14 Mar '12

More specifically, if I have a record type from which I construct multiple sub-record types, and I want to store these in a collection which I want to map over while preserving the ability to get at the sub-fields, is there a better way to do it than to have an enumeration for the sub-types and then use Dynamic? I also have a nastier version that doesn't require the enumeration, which throws an exception when fromDynamic can't return a value with one of the expected types. {-# LANGUAGE Rank2Types, DeriveDataTypeable #-} module Super where import Data.Dynamic import Data.Typeable import Data.Maybe data Super a = Super { commonFields :: (), subFields :: a } deriving Typeable data SubTypes = SubA | SubB | SubC data A = A { aFields :: () } deriving Typeable data B = B { bFields :: () } deriving Typeable data C = C { cFields :: () } deriving Typeable doSomethingWithSubType :: (Super A -> ()) -> (Super B -> ()) -> (Super C -> ()) -> (SubTypes, Dynamic) -> Maybe () doSomethingWithSubType a _ _ (SubA, dynamic) = fromDynamic dynamic >>= return . a doSomethingWithSubType _ b _ (SubB, dynamic) = fromDynamic dynamic >>= return . b doSomethingWithSubType _ _ c (SubC, dynamic) = fromDynamic dynamic >>= return . c doSomethingWithSubType2 :: (Super A -> ()) -> (Super B -> ()) -> (Super C -> ()) -> Dynamic -> () doSomethingWithSubType2 a b c dynamic = let dynamicAsA = fromDynamic dynamic :: Maybe (Super A) dynamicAsB = fromDynamic dynamic :: Maybe (Super B) dynamicAsC = fromDynamic dynamic :: Maybe (Super C) in head $ catMaybes [ dynamicAsA >>= return . a , dynamicAsB >>= return . b , dynamicAsC >>= return . c]

5 4

Adding type annotations to an AST?
by Stephen Tetley 14 Mar '12

14 Mar '12

Hello All How do I add type annotations to interior locations in an abstract syntax tree? I have a small ML language where programs are a single expression, but the expression type has let-rec so it supports recursive function definitions. Source programs have no type annotations. I want to annotate the lec-rec with type annotations, but my type inference is a simple implementation of Algorithm J so it seems "monolithic" to me - i.e. the type it infers is the type of the whole program, I would also like the types of any internal let-rec definitions so I can label my AST. What is the idiom for accomplishing this? I'm using Eijiro Sumii's MinCaml as reference - this embeds mutable references for types in the AST. So this appears a non-starter. My other thought is to uniquely label all type locations during parsing then collect them in a map (location -> type) whilst computing the outermost type - I presume I can identify inner types as they are resolved during Algorithm J's run... Any solutions? Many thanks Stephen

2 3

Unable to call function from DLL using FFI
by rajendra prasad 14 Mar '12

14 Mar '12

Hi, I am new to Haskell and I need to call a c function by loading dynamic link library in Haskell. I started with very simple code to create a dll in visual studio 2008 and then trying to load it in haskell. I am listing here the steps I follwed to achieve this: *Step 1: * My c++ code(HelloWorld.cpp) looks like this: __declspec(dllexport) int doubleMe(int a) { return 2*a; } I created the dll using following command: cl /D_USRDLL /D_WINDLL HelloWorld.cpp /link /dll /out:LoadDLL.dll *Step 2:* My Haskell code(Main.hs) looks like this: {-# LANGUAGE ForeignFunctionInterface #-} module Main where import Foreign import Foreign.C foreign import ccall "LoadDLL doubleMe" twice :: CInt -> IO (CInt) main = do let x = 4 y <- twice x print y I am compling haskell code using following command: ghci Main.hs -L. -lLoadDLL I am finally getting the following error: During interactive linking, GHCi couldn't find the following symbol: doubleMe This may be due to you not asking GHCi to load extra object files, archives or DLLs needed by your current session. Restart GHCi, specifying the missing library using the -L/path/to/object/dir and -lmissinglibname flags, or simply by naming the relevant files on the GHCi command line. Alternatively, this link failure might indicate a bug in GHCi. If you suspect the latter, please send a bug report to: glasgow-haskell-bugs(a)haskell.org Please help me in identifying the mistake I am doing. If possible please let me know the exact steps to be followed to solve this issue. Thank you so much in advance, Regards, Rajendra

2 1

Why so many strings in Network.URI, System.Posix and similar libraries?
by Jason Dusek 14 Mar '12

14 Mar '12

The content of URIs is defined in terms of octets in the RFC, and all Posix interfaces are byte streams and C strings, not character strings. Yet in Haskell, we find these objects exposed with String interfaces: > :info Network.URI.URI data URI = URI {uriScheme :: String, uriAuthority :: Maybe URIAuth, uriPath :: String, uriQuery :: String, uriFragment :: String} -- Defined in Network.URI > :info System.Posix.Env.getEnvironment System.Posix.Env.getEnvironment :: IO [(String, String)] -- Defined in System.Posix.Env But there is no law that environment variables must be made of characters: :; export x=$'\xFF' ; echo -n $x | xxd -p ff :; locale LANG="en_US.UTF-8" That the relationship between bytes and characters can be confusing, both in working with UNIX and in dealing with web protocols, is undeniable -- but it seems unwise to limit the options available to Haskell programmers in dealing with these systems. -- Jason Dusek pgp // solidsnack // C1EBC57DC55144F35460C8DF1FD4C6C1FED18A2B

5 10

Re: [Haskell-cafe] using mutable data structures in pure functions
by Ryan Ingram 14 Mar '12

14 Mar '12

On Sun, Mar 11, 2012 at 8:38 PM, E R <pc88mxer(a)gmail.com> wrote: > A pure function can allocate and modify memory as long as a) it never > returns a reference to the memory or b) it never again modifies the > memory once it returns (i.e. it returns an immutable object). > That's a reasonable first approximation to the problem, yes. It gets a bit more complicated due to laziness (what if the mutation gets delayed until some later part of the output is examined?) So, again, what is the Haskell philosophy towards using mutable data > structures in pure functions? Is it: > > 1. leave it to the compiler to find these kinds of opportunities > 2. just use the immutable data structures - after all they are just as > good (at least asymptotically) > 3. you don't want to use mutable data structures because of _____ > 4. it does happen, and some examples are ______ > There are two ways in which Haskell encourages the use of mutable data structures in a pure way. The first is in the inherent mutation caused by laziness. For example: type Positive = Integer -- trie of binary representation of positive number -- [1] -> tOne -- x ++ [0] -> lookup x . tEven -- x ++ [1] -> lookup x . tOdd data Trie a = Trie { tOne :: a, tEven :: NatTrie a, tOdd :: NatTrie a } lookupTrie :: Trie a -> Positive -> a lookupTrie t 1 = tOne t lookupTrie t n | even n = lookupTrie (tEven t) (n `div` 2) | otherwise = lookupTrie (tOdd t) (n `div` 2) -- div drops remainder makeTrie :: (Positive -> a) -> Trie a makeTrie f = Trie (f 1) e o where e = makeTrie $ \n -> f (2*n) o = makeTrie $ \n -> f (2*n + 1) memoize :: (Positive -> a) -> (Positive -> a) memoize = lookupTrie . makeTrie collatz_rec :: (Positive -> Integer) -> Positive -> Integer collatz_rec f 1 = 0 collatz_rec f n | even n = 1 + f (n `div` 2) | otherwise = 1 + f (3*n + 1) collatz = memoize (collatz_rec collatz) In this case, makeTrie creates a thunk, and it's only evaluated where requested by lookupTrie. You can call collatz at many different values and later calls will be much faster, as the mutation caused by lazy evaluation 'remembers' the values. The second is by explicitly documenting that you are using a temporarily mutable structure, which is the ST monad: instance Monad (ST s) newSTRef :: a -> ST s (STRef s a) readSTRef :: STRef s a -> ST s a writeSTRef :: STRef s a -> a -> ST s () -- and similar interface for mutable STArrays runST :: (forall s. ST s a) -> a -- note higher rank type A computation in the ST monad is an impure computation that can modify memory, but only memory allocated within that same computation. The higher rank type in runST makes it safe to do so--references from one ST computation cannot escape to any other ST computation. So even though internally some pure value might rely on an impure computation, it's safe to do so in a pure context. Here's a sample implementation of ST: -- DO NOT EXPORT THESE CONSTRUCTORS newtype ST s a = ST (IO a) newtype STRef s a = STRef { getRef :: IORef a } runST :: (forall s. ST s a) -> a runST (ST act) = unsafePerformIO act -- Actually safe! newSTRef :: a -> ST s (STRef s a) newSTRef a = ST $ liftM STRef (newIORef a) readSTRef :: STRef s a -> ST s a readSTRef (STRef r) = ST $ readIORef r writeSTRef :: STRef s a -> a -> ST s () writeSTRef (STRef r) a = ST $ writeIORef r a There's some usage examples at http://www.haskell.org/haskellwiki/Monad/ST -- ryan

1 0

Polymorphic addition function with variable number of arguments?
by Some One 13 Mar '12

13 Mar '12

Dear Haskellers, I'm trying to define a polymorphic "add" function which takes a variable number of arguments (instance of Num) and returns their sum. I don't want to specify the types of the arguments while calling the function, I just want to , at most, specify the return type (*it should infer that the return type is the type of the arguments*). class Add a b where add :: a -> b instance Num a => Add a a where add = id instance (Num a, Add a b) => Add (a -> b) where add x y = add (x + y) Can someone tell me why this is not working and propose a fix for this, if possible? Thanks in advance

2 3

Inecxact map?
by Morten Olsen Lysgaard 13 Mar '12

13 Mar '12

I'm running a project where i want to generate a map of a rather large data collection. The map is if the form: Data.Map.Map String a I'd like to be able to do inexact lookups on the map. Firstly, ignore the difference between upper lower case, that's easy. But secondly, have a function: search :: (Num b) => Data.Map.Map String a -> String -> b -> [a] This function is like the normal lookup, but it takes an extra argument b. B is the allowed character error rate. That is the Levenstein distance divided on the length. It should return all the strings that has an error rate lower that b and in a ordered manner, best first. Is it possible to design such a datastructure efficiently? Does there already exist something like this? If not, where would i begin to create this? Any advices or knowledge appreciated. -- Morten

3 2

cabal test-suite library recompilation
by Ozgur Akgun 13 Mar '12

13 Mar '12

Hi all, I've recently started to move my tests to use the new cabal test-suite framework. Old setup: The cabal file compiles one library + a few executables. The library contains almost all of the code and exposes the necessary modules for use by the executables. The executables mainly consist of one main file. This way, the library is only compiled once and used multiple times by the executables. Great. One of the executables compile a test runner, and is handled similarly. New setup, using test-suite: I've deleted the executable section for the test runner and added a test-suite section instead. To my surprise, the library is compiled twice now. Hence, it takes twice as long. And it is a clear regression compared to my old setup. While waiting for a build to finish [ :) ], I just wanted to write an email and check if this is intentional or only an oversight. Or maybe a technical limitation for the time being? Thanks, Ozgur

2 2

ANNOUNCE: join (UHac <$> DHD)
by Sean Leather 13 Mar '12

13 Mar '12

You can still join us at the DHD >>= UHac, but the time is running out. http://www.haskell.org/haskellwiki/DHD_UHac Deadline: April 1 (no fooling!) We've also have a few updates: * We put the DHD program up, at least as much of it as we have. http://www.haskell.org/haskellwiki/DHD_UHac/DHD_Program * As you can see from the program, there is still room for more speakers. In particular, we'd like to hear from people coming outside Utrecht and the Netherlands. We'd also like to see more lightning talks. Send Sean an email with your idea: leather(a)cs.uu.nl * UHac on Friday has moved to a "new" location. Actually, it's the same location as on Saturday and Sunday, so that should make things easier. See you in Utrecht! The Organizers: Sean Leather Jurriën Stutterheim Jurriaan Hage P.S. Make sure your Monad is also a Functor. P.P.S. Apologies for multiple copies.

1 0