January 2014 - Haskell-Cafe

[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 03 Jan '14

03 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

Standard way to translate Haskell to other languages?
by Joey 02 Jan '14

02 Jan '14

I'm looking at writing a simple Haskell to Elm translator. Thankfully, the Elm compiler is in Haskell, so I'm just trying transforming syntax trees. I'm wondering, is there a standard way to do this sort of thing? Template Haskell looked promising, but it seems there isn't much of a way to do introspection on function definition. Has there been any work/progress on this? The GHC API seemed useful for compiling, but it seems tricky to use, and I haven't been able to find many tutorials for this sort of thing. I could just be looking in the wrong place. What are the ways I could go about this? Are there any similar projects I could use as reference? What packages are useful for generating and manipulating Haskell ASTs? Does anybody have experience in this area they could share? I've posted a similar question to the Haskell Reddit at http://www.reddit.com/r/haskell/comments/1u55rl/standard_way_to_translate_h…. Thanks! Joey Eremondi

4 6

Fwd: HFuse Patch
by Diony Rosa 01 Jan '14

01 Jan '14

I was told to email this list: Hello, I wish to become maintainer of the HFuse (FUSE bindings for Haskell) package on hackage. The package's github URL and email are both dead, and the package doesn't compile under GHC7. I've gotten the package to work under GHC7 with a patch, and have gotten permission from the original maintainer to take over. My hackage username is dhrosa, and here's the package page: http://hackage.haskell.org/package/HFuse , and the referenced patch is here: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=703417 Are there any objections? ---------- Forwarded message ---------- From: Paul van der Walt <Paul.vanderWalt(a)inria.fr> Date: Wed, Jan 1, 2014 at 7:06 PM Subject: Re: HFuse Patch To: Diony Rosa <dhrosa(a)mit.edu> On Wed, Jan 01, 2014 at 19:00:18 -0500, quoth Diony Rosa: In that case, may I take it over? I know how to fix it and am interested in > this package. > That would suit me down to the ground! Feel free to remove all references to me, my name or my website! Thank you very much! Paul

1 0

Consistency issue with type level numeric literals
by oleg＠okmij.org 01 Jan '14

01 Jan '14

GHC 7.6.3 has quite convenient type-level numeric literals. We can use numbers like 1 and 2 in types. However, using the type level numeral has been quite a bit of a challenge, illustrated, for example, by the following SO question. http://stackoverflow.com/questions/20809998/type-level-nats-with-literals-a… It seems the challenge has the reason: the type level numerals and their operations provided in GHC.TypeLits have a consistency issue. The following code demonstrates the issue: it constructs two distinct values of the type Sing 2. Singletons aren't singletons. {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} module NotSing where import GHC.TypeLits -- GHC strangely enough lets us define instances for (+) type instance 1 + 1 = 0 type instance 0 + 1 = 2 -- A singular representative of 1::Nat s1 :: Sing 1 s1 = withSing id -- A singular representative of 2::Nat s2 :: Sing 2 s2 = withSing id is2 :: IsZero 0 is2 = IsSucc s1 tran :: IsZero 0 -> Sing 2 tran (IsSucc x) = case isZero x of IsSucc y -> case isZero y of IsZero -> x -- Another singular representative of 2::Nat -- A singular representative of 2::Nat s2' :: Sing 2 s2' = tran is2 {- *NotSing> s2 2 *NotSing> s2' 1 -}

3 3

Get expected type of expression using GHC API?
by Patrick Hurst 01 Jan '14

01 Jan '14

Using the GHC API, you can get the inferred type of an `LHsExpr Id` via a `TypecheckedModule`, as hdevtools does[1]. Is there any way to get the expected type? This would be useful for cases where the expected type is much more polymorphic than the inferred type (or possibly for debugging type errors with -fdefer-type-errors, depending on what GHC does in that case). [1] https://github.com/bennofs/hdevtools/blob/master/src/Info.hs#L133

1 0