- Haskell-Cafe - Haskell.org

Turning off warning in ghc-mod (in vim)
by Magnus Therning 06 Jan '14

06 Jan '14

On the command line I can do the following: % ghc-mod check -g -isrc -g dist/build/autogen src/Main.hs | grep Top-level Binary file (standard input) matches % ghc-mod check -g -isrc -g dist/build/autogen -g -fno-warn-missing-signatures src/Main.hs | grep Top-level % That is, there is no output on the second call, just as expected. However, I can't work out out to turn off the warning in Vim. AFAIU the following should work: g:ghcmod_ghc_options = ['-isrc', '-idist/build/autogen', '-fno-warn-missing-signatures'] but it doesn't. I'm obviously missing something, but what? /M -- Magnus Therning OpenPGP: 0xAB4DFBA4 email: magnus(a)therning.org jabber: magnus(a)therning.org twitter: magthe http://therning.org/magnus Beauty is more important in computing than anywhere else in technology because software is so complicated. Beauty is the ultimate defence against complexity. -- David Gelernter

1 1

preprocessor, how to?
by Kees Bleijenberg 06 Jan '14

06 Jan '14

In a program I use a lot of hamlet files. All these hamlet files are in a submap of the source map. In code: allHtml = Mconcat [ $(hamletFile "hamlet\\belastingen.hamlet") renderUrl ,$(hamletFile "hamlet\\winddruk.hamlet") renderUrl .. ,$(hamletFile "hamlet\\berekeningDruk.hamlet") renderUrl ,$(hamletFile "hamlet\\drukNaarBuigTrek.hamlet") renderUrl] This is a Windows program. For another project I want to use this piece of code on Linux. The code should now be: .. $(hamletFile "hamlet/winddruk.hamlet") renderUrl I can't use pathSeparator here, because this is all happening at compile time. So I think I need a preprocessor. I would like to have a kind of hamletDir macro and change the code to something like: #ifdef Win32 hamletDir = "hamlet\\" #else hamletDir = "hamlet/" #endif ... $(hamletFile "{hamletDir}winddruk.hamlet") renderUrl Is it possible in Haskell and how do I it? All examples of preprocessing in Haskell I found are something like this: #ifdef xxx aaaa #else Bbbbb #endif I could use that. But a user defined macro is less code. Kees

1 0

hackage build failure (?) - but no log
by Rogan Creswick 06 Jan '14

06 Jan '14

Mateusz Kowalczyk's recent message about fixing hackage documentation made me realize that one of my packages (chatter) has no build log, and indeed, the documentation was not showing up on hackage. Is there any way to figure out what is causing the failure? Chatter has no non-Haskell dependencies, and it builds just fine in a sandbox on the major three architectures (including building documentation on at least two of them - I haven't tested haddock on Windows). Manually posting the documentation is more than a little inconvenient at the moment, and given the nature of the library, I'm pretty surprised this is an issue. (I did post the docs for chatter-0.0.0.3 manually, if you're wondering why they appear despite my complaints...) Does anyone have suggestions? Thanks! Rogan

1 0

Intercept stdin in Haskell
by Andrew Gibiansky 06 Jan '14

06 Jan '14

Hello all, I need to do something strange and terrible in Haskell: intercept `stdin`. In other words, I need to detect (in another thread, probably?) when my running program is trying to read from `stdin`, and then feed it some data. I know I can use `hDupTo` and other similar things to replace the stdin handle with my own handle, and I know I could probably use `createPipe` or similar from the `unix` package in order to write things to these handles, but I have no idea how I might go about detecting that a handle is being read from. Any ideas? I've racked my brain and cannot come up with a way to do this. I am using the GHC API elsewhere if that leads to any sort of crazy hackery that might save the day. -- Andrew

6 14

[ANN] vim-hsimport - automatically create Haskell import statements
by Daniel Trstenjak 05 Jan '14

05 Jan '14

Hi all, vim-hsimport is a Vim plugin that automatically creates import statements for Haskell source files for the symbol/identifier under the cursor. vim-hsimport can create import statements for the whole module, for only the desired symbol/indentifier and is also able to create qualified module import statements. By using hdevtools in conjunction with a cabal sandbox, dynamically only the modules of packages are considered, which your project depends on. vim-hsimport does also consider the modules of your current project. If the symbol/identifier is contained in multiple modules, then a selection dialog is shown. In conjunction to the hsimport command the Vim plugin also uses the command hdevtools and the Vim plugin vim-hdevtools. Currently you need to use forks of hdevtools and vim-hdevtools to get a working version of vim-hsimport, please see the installation section for details. Currently the biggest issue is if and how modules of your current project are considered for the import, please see the issues section. https://github.com/dan-t/vim-hsimport Greetings, Daniel

4 6

(automatically) adding import statements in vim
by cdep.illabout＠gmail.com 04 Jan '14

04 Jan '14

Are there any tools or vim-plugins that will automatically add import statements? For instance, I have the following code: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError) import Text.Printf (printf) ... parseMyString :: String -> Either ParseError String parseMyString stringToParse = parse myParser "(unknown)" stringToParse Here's what I want to have happen. I put my cursor over "parse" and press some keystroke. It automatically adds the parse function to the list of import statements from the Text.ParserCombinators.Parsec module (hopefully sorted alphabetically). So the import statements end up looking like this: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError, parse) import Text.Printf (printf) ... The haskellmode vim plugin (https://github.com/lukerandall/haskellmode-vim) has functionality similar to this, but it can only add new import lines. It can't add functions/types to existing import lines. The best it can do is something like this: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError) import Text.Printf (printf) import Text.ParserCombinators.Parsec (parse) ... This is alright, but I have to go back and edit it by hand to make it look like the above. Are there any tools or vim-plugins that can do this automatically?

5 6

An Invitation to Gordian Knot, a mathematics and computing problem solving contest
by Threads 04 Jan '14

04 Jan '14

Hello everyone! Felicity, the annual festival of IIIT Hyderabad, brings to you Felicity Threads 2014, the tenth annual edition of the celebration of spirit of computing and engineering. We bring to you a wide range of online contests in various fields of programming and mathematics. Our series of online events includes contests on algorithmic programming (Codecraft), parallel programming (Kernel Cruise), combinatorial search and game playing bot design (Strange Loop), and a CTF-style security contest (Break In). Our first event, Gordian Knot, a Project Euler-inspired contest full of mathematical problems, starts TODAY at 1600 Hrs (IST), and will run for atleast a day. Being a mathematics and computing contest, Gordian Knot challenges you to come up with solutions to problems and untangle complex yet elegant knots, using any methods and computational tools at your disposal. http://www.felicity.iiit.ac.in/threads/gordian-knot/ [1] The only prerequisite to participate is the urge to learn. Let us learn and rejoice the spirit of computing and engineering together. There are exciting prizes for the event too! So let the mathematician inside you come out and to know more about Threads, visit us at : http://felicity.iiit.ac.in/threads/ [2] Sincerely, Threads 2014 Team Links: ------ [1] http://www.felicity.iiit.ac.in/threads/gordian-knot/ [2] http://felicity.iiit.ac.in/threads/

1 0

Designing somewhat-type-safe RPC
by Nicolas Trangez 03 Jan '14

03 Jan '14

Hi, While working on the design of an RPC library (for an existing protocol), I got somewhat stuck. The system is fairly simple: for some call, a client first sends an identifier of the call, followed by a serialized form of the argument. Then the server returns some serialized result. A server exposes several procedures, all taking a certain argument type and returning a certain result type. Below is some code which sketches my current approach. The 'client' side seems straight-forward and working (hence 'runCall'), but I didn't manage to implement the server side as I imagine it to be (i.e. the parts commented out). Any pointers would be appreciated. Thanks, Nicolas {-# LANGUAGE GADTs, RankNTypes, OverloadedStrings, KindSignatures, ScopedTypeVariables #-} module RPC where import Data.Word (Word32) import Data.Binary (Binary, decode, encode) class RPC (a :: * -> * -> *) where rpcProcedureId :: a req res -> Word32 {- rpcProcedure :: Word32 -> Maybe (a req res) -} data Service req res where Ping :: Service () () Add :: Service (Word32, Word32) Word32 instance RPC Service where rpcProcedureId p = case p of Ping -> 1 Add -> 2 {- rpcProcedure i = case i of 1 -> Just Ping 2 -> Just Add _ -> Nothing -} runCall :: forall call req res. (RPC call, Binary req, Binary res) => call req res -> req -> IO res runCall call req = do let bs = encode req idx = rpcProcedureId call -- Send idx & bs to network, read stuff from network and interpret s <- return $ encode (3 :: Word32) return $ decode s runServer :: (RPC call, Binary req, Binary res) => (call req res -> req -> IO res) -> IO () {- runServer handler = do i <- return 2 -- Read from network case rpcProcedure i of Nothing -> error "No such procedure" Just (call :: call req res) -> do -- Read request from network s <- return $ encode (1 :: Word32, 2 :: Word32) let (req :: req) = decode s (res :: res) <- handler call req -- Send reply to network let res' = encode res return () -} runServer handler = undefined main :: IO () main = do runCall Ping () >>= print runCall Add (1, 2) >>= print {- runServer handler where handler :: Service req res -> req -> IO res handler c (r :: req) = case c of Ping -> return () Add -> case r of (a, b) -> return (a + b) -}

2 2

Re: [Haskell-cafe] SYB supports genuine gmap
by oleg＠okmij.org 03 Jan '14

03 Jan '14

For the record, I have described the implementation of generic map (which is fmap implemented generically, once and for all). http://okmij.org/ftp/Haskell/generics.html#gmap The article stresses a drawback of a fake gmap in terms of gfoldl: a fake gmap is non-parametric. It fails the law gmap f . gmap g == gmap (f.g). OTH, the genuine gmap satisfies the law, as behooves to the generic version of fmap. Although gmap is implemented in terms of the parametricity-breaking type-introspecting SYB, the gmap is parametric nevertheless.

1 0

Re: [Haskell-cafe] Designing somewhat-type-safe RPC
by oleg＠okmij.org 03 Jan '14

03 Jan '14

The remote procedure call is obviously a partial function: first of all, it may fail because of various network problems. It may also fail if a client and a server disagree on the types of the arguments and the results of the function call. For example, the client may think that "Add" service adds integers while the server takes "Add" to sum floats. There is nothing in the type system that can enforce the agreement between distributed entities. So, we are liable to get serialization/deserialization errors. It is inevitable that the communication part is a big "Dynamic", and getting data from that Dynamic may fail because of `type' errors (the data were serialized at a different type than expected, or the data were corrupted in transit). With these assumptions, the implementation is straightforward (enclosed). Both the server and the client operations are typed (but the middle part, the communication, is necessarily `untyped'). Incidentally, some three years ago I wrote a quite more advanced RPC library, in OCaml. It didn't use any GADTs and other bleeding stuff (first, OCaml did not have GADTs at the time; second, I'm minimalist). It did much more, including semi-automatic request batching and some fairly complex server programs including conditionals. It already does more than X protocol and Java RPC. If I added server-side loops, it would do even more. Alas, I didn't have time to come back to that project since. http://okmij.org/ftp/meta-future/meta-future.html {-# LANGUAGE ExistentialQuantification #-} module RPC where import System.IO import qualified Data.Map as M -- identifiers of functions to call type ServiceID = String -- ------------------------------------------------------------------------ -- Server part -- For simplicity, we use Read for deserialization and Show for -- serialization. Binary would've been a better choice for both -- All functions are supposed to be uncurried. -- ServerFn essentially packs a function together with the serializer -- of the result and the deserializer for arguments. data ServerFn = forall a b. (Read a, Show b) => ServerFn (a->b) type Services = M.Map ServiceID ServerFn -- For simplicity, we handle just one request, which we read from -- the handle. We write the result to stdio. It is easy to generalize: -- write the result to an output handle and loop. runServer :: Services -> Handle -> IO () runServer services h = do service_id <- hGetLine h putStrLn $ service_id args <- hGetLine h maybe (fail $ "no such service: " ++ service_id) (handle args) $ M.lookup service_id services where handle sargs (ServerFn f) = do let args = read sargs print $ f args -- Sample services services :: Services services = M.fromList [ ("Ping", ServerFn (\ () -> ())), ("Add", ServerFn (\ (x,y) -> x + y :: Int)) ] -- ------------------------------------------------------------------------ -- Client part -- Stubs of server fn -- ClientFn a b represents a function a->b to be executed by a server data ClientFn a b = ClientFn ServiceID ping :: ClientFn () () ping = ClientFn "Ping" add :: ClientFn (Int,Int) Int add = ClientFn "Add" -- the set of functions is open; more can be added at any time -- Do the remote function application rpc :: (Show a, Read b) => Handle -> ClientFn a b -> a -> IO b rpc h (ClientFn fid) x = do hPutStrLn h fid hPutStrLn h (show x) -- read the result: currently stabbed result_str <- return "stubbed" return $ read result_str -- ------------------------------------------------------------------------ -- Test comm_file = "/tmp/connection" main = do h <- openFile comm_file WriteMode -- send the request down to h. In this example, the return communication -- is not implemented res <- rpc h add (2::Int,3::Int) -- don't look at the result: it this example, it is undefined hClose h h <- openFile comm_file ReadMode runServer services h

1 0