November 2014 - Haskell-Cafe

[ANN]json-autotype: Tool generating JSON parsers and type declarations from example documents...
by Michal J Gajda 04 Nov '14

04 Nov '14

Dear Fellow Haskellers, I've just published a beta version of a tool facilitating generation of Haskell type declarations from example JSON documents. It is supposed to simplify implementing large JSON-based interfaces, without necessity of writing any boilerplate code. USAGE: ====== After installing with `cabal install json-autotype`, you might generate stub code for the parser: $ json-autotype input.json -o MyFormat.hs Then you might test the parser by running it on an input file: $ runghc MyFormat.hs input.json If everything is correct, then feel free to inspect the data structure generated automatically for you! The goal of this program is to make it easy for users of big JSON APIs to generate entries from example data. Occasionally you might find a valid JSON for which `json-autotype` doesn't generate a correct parser. You may either edit the resulting file _and_ send it to the author as a test case for future release. HOW IT WORKS: ============== The program uses union type unification to trim output declarations. The types of same attribute tag and similar attribute set, are automatically unified using recognition by attribute set matching. (This option can be optionally turned off, or a set of unified types may be given explicitly.) Either alternatives is used to assure that all JSON inputs seen in example input file are handled correctly. Details on official releases are on Hackage [1] 1. https://hackage.haskell.org/package/json-autotype Patches and suggestions are most welcome. -- Best regards Michał J. Gajda

3 3

Inlinable vs inline
by Charles Durham 04 Nov '14

04 Nov '14

Hi, I wanted to get some clarifications on how inlinable and inline behave. One particular case is where you have a module exporting some functions with helper functions that are not exported. You go ahead and add inlinable to the exported functions so that the call site can specialize on them. Is there any penalty to adding inline vs inlinable to the helper functions? For example, are there cases where a helper function will not inline and thus can not be specailized at the call site and it would be better to declare the helper function inlinable? I would be interested to hear any nuances related to the differences and practical consequences of these pragmas. Thanks! Charlie Durham

1 0

Code review request: Library and executable to read USB temperature device
by Bram Neijt 03 Nov '14

03 Nov '14

Dear reader, I have written a small executable and library to read values from a USB device and would like someone with more knowledge then hlint to review my code. If you find the time to read https://github.com/bneijt/temper/blob/master/src/lib/Temper.hs please consider placing comments/issues on Github or mailing the list or me directly with your comments. I also have the following doubts about the code: - It has some bit-shifting code on line 18 to 20. Is there a nicer "unpack two bytes to an integer" method? - I'm using test-framework with test-framework-hunit but it feels clunky, is hspec a more common approach to testing? - I'm ignoring a lot of return values between lines 61 to 70. In a language like Python or Java I would add assert statements or checks with exceptions there. How should I go about that in Haskell? Greetings, Bram

1 0

New Functional Programming Job Opportunities
by Functional Jobs 03 Nov '14

03 Nov '14

Here are some functional programming job opportunities that were posted recently: Senior Software Engineer at Soda Software Labs http://functionaljobs.com/jobs/8758-senior-software-engineer-at-soda-softwa… Cheers, Sean Murphy FunctionalJobs.com

1 0

Pattern variables in Template Haskell
by Alejandro Serrano Mena 03 Nov '14

03 Nov '14

Dear Haskell-cafe, I'm trying to use Template Haskell to generate patterns in Haskell code, but after a couple of days of trying, I have not come with a solution. I hope somebody could help me. My problem is basically that I want something like: example :: Maybe a -> a example $(j "x") = x to work correctly. The idea of this simple quoter is to generate code similar to: example :: Maybe a -> a example (Just x_123) = x_123 that is, to create the "Just" pattern, and to make "x" bind to the same element. Right now my code reads: j :: String -> Q Pat j s = return (ConP 'Just [VarP (mkName s)]) which generated a new variable "x" each time, thus unable to match with the "x" in the RHS. I have also tried with lookupValueName. Note that my problem is a bit more complicated, with variable names coming from a different source. However, I think that if I solve this problem where I can make variables in a pattern and in an expression match, I should be able to use them in my complete solution. Thanks in advance.

2 2

Nomyx (Beta 7): win 10000 Blings!
by Corentin Dupont 03 Nov '14

03 Nov '14

Join us on Nomyx: www.nomyx.net It's a unique game where you can change the rules of the game, while playing it. Log in, and you'll understand better what the title means (check rule 44 proposed by me in the game)! Cheers, Corentin

2 2

ANN: Released new version of Haskell plugin for IntelliJ
by Rik van der Kleij 03 Nov '14

03 Nov '14

Hi everyone, I'm glad to announce version 0.2. It's available in Jetbrains plugin repository. Besides improvements and minor changes, version 0.2 has support for HLint inspection and quick fixes based on HLint suggestions. For more information, see change notes. Complete feature list is now: - Syntax highlighting (which can be customized); - Error/warning highlighting; - Find Usages of identifiers; - Resolving references of identifiers (also to library code if library source code is added to project and resolves inside import declaration); - Code completion by resolving references; - Renaming variables (which first shows preview so refactoring scope can be adjusted); - View type info from (selected) expression; - View expression info; - View quick documentation; - View quick definition; - Structure view; - Navigate to declaration (called `Class` in IntelliJ menu); - Navigate to identifier (called `Symbol` in IntelliJ menu); - Code completion by looking to import declarations; - Simple form of code formatting; - Inspection by HLint; - Quick fixes for HLint suggestions; - View error, action to view formatted message from ghc-mod. Especially useful in case message consists of multiple lines (Ctrl-F10, Meta-F10 on Mac OSX); See for more information and getting started: https://github.com/rikvdkleij/intellij-haskell Any feedback is welcome! Regards, Rik

1 0

<|> that short-circuits in IO ?
by Semen Trygubenko / Семен Тригубен ко 02 Nov '14

02 Nov '14

Dear Haskell-Cafe, Is there a way to get Control.Applicative.<|> to short-circuit when combining two IO actions? E.g. > let a = putStrLn "A" >> return (Left "hehe") > let b = putStrLn "B" >> return (Right 42) > Prelude> liftA2 (<|>) a b A B Right 42 > liftA2 (<|>) b a B A Right 42 (In the latter case I don't want A in the output…) Many thanks for your help, Semen -- Семен Тригубенко http://trygub.com

4 6

How to use randomized algorithm within the implementation of pure data structures?
by Hiromi ISHII 01 Nov '14

01 Nov '14

Hi cafe, I'm currently implementing the data structure representing algebraic numbers. Implementing algebraic number arithmetic requires polynomial factorisation. Pure algorithm for factoring (Berlekamp's algorithm) is more expensive than the randomized one (Cantor-Zassenhaus algorithm) , so I want to use the latter algorithm. Since C-Z algorithm is a randomized algorithm, we have to have an access for random number generator when calculating algebraic number arithmetics e.g. writing Num instance for algebraic numbers. Here is the problem: how to pass-around random number generator throughout pure computaion? I think one immediate solution is to create global state with `newStdGen` and `unsafePerformIO` like below: ``` randSrc :: IORef StdGen randSrc = unsafePerformIO $ newIORef =<< newStdGen {-# NOINLINE randSrc #-} getRand :: IO Int getRand = atomicModifyIORef' randSrc (swap . next) -- We can probably use the following function to avoid calling -- `unsafePerformIO` whenever calling 'getRand`, -- assuming some optimization flag enabled: getRandUnsafe :: Int getRandUnsafe = unsafePerformIO getRand {-# NOINLINE getRandUnsafe #-} {-# RULES "getRandUnsafe" getRandUnsafe = unsafePerformIO getRand #-} ``` But this hack seems rather dirty and unsafe. Is there any workaround to achieve the same thing? -- Hiromi ISHII konn.jinro(a)gmail.com

4 4