- Haskell-Cafe - Haskell.org

ANN: exference: a different djinn
by lennart spitzner 27 Apr '15

27 Apr '15

Hello folks, Exference[1] is a Haskell tool for generating expressions from a type, e.g. Input: (Show b) => (a -> b) -> [a] -> [String] Output: \ b -> fmap (\ g -> show (b g)) In contrast to Djinn, the well known tool with the same general purpose, Exference supports a larger subset of the haskell type system - most prominently type classes. (Djinn's environment many contain type classes, but using them in queries will not really work.) This comes at a cost, however: Exference makes no promise regarding termination. Where Djinn tells you "there are no solutions", Exference will keep trying, sometimes aborting a non-ending search with "i could not find any solutions". See [2] for a report about the implementation, capabilities and limitations. [1] https://github.com/lspitzner/exference [2] https://github.com/lspitzner/exference/raw/master/exference.pdf Lennart

3 4

Improved Hackage Security document
by Michael Snoyman 27 Apr '15

27 Apr '15

To try and clarify a number of the points brought up in discussion around Hackage security in the past few weeks, Mathieu and I have put some time into trying to organize the information around this a bit. The result is the following page: https://github.com/commercialhaskell/commercialhaskell/blob/master/proposal… Contributions by others are very welcome. If you send a pull request, odds are you'll end up with commit access too.

1 0

[ANN] FLOPS CFP 2016
by oleg＠okmij.org 27 Apr '15

27 Apr '15

FLOPS 2016: 13th International Symposium on Functional and Logic Programming March 3-6, 2016, Kochi, Japan Call For Papers http://www.info.kochi-tech.ac.jp/FLOPS2016/ Writing down detailed computational steps is not the only way of programming. The alternative, being used increasingly in practice, is to start by writing down the desired properties of the result. The computational steps are then (semi-)automatically derived from these higher-level specifications. Examples of this declarative style include functional and logic programming, program transformation and re-writing, and extracting programs from proofs of their correctness. FLOPS aims to bring together practitioners, researchers and implementors of the declarative programming, to discuss mutually interesting results and common problems: theoretical advances, their implementations in language systems and tools, and applications of these systems in practice. The scope includes all aspects of the design, semantics, theory, applications, implementations, and teaching of declarative programming. FLOPS specifically aims to promote cross-fertilization between theory and practice and among different styles of declarative programming. Scope FLOPS solicits original papers in all areas of the declarative programming: * functional, logic, functional-logic programming, re-writing systems, formal methods and model checking, program transformations and program refinements, developing programs with the help of theorem provers or SAT/SMT solvers; * foundations, language design, implementation issues (compilation techniques, memory management, run-time systems), applications and case studies. FLOPS promotes cross-fertilization among different styles of declarative programming. Therefore, submissions must be written to be understandable by the wide audience of declarative programmers and researchers. Submission of system descriptions and declarative pearls are especially encouraged. Submissions should fall into one of the following categories: * Regular research papers: they should describe new results and will be judged on originality, correctness, and significance. * System descriptions: they should contain a link to a working system and will be judged on originality, usefulness, and design. * Declarative pearls: new and excellent declarative programs or theories with illustrative applications. System descriptions and declarative pearls must be explicitly marked as such in the title. Submissions must be unpublished and not submitted for publication elsewhere. Work that already appeared in unpublished or informally published workshops proceedings may be submitted. See also ACM SIGPLAN Republication Policy. The proceedings will be published by Springer International Publishing in the Lecture Notes in Computer Science (LNCS) series, as a printed volume as well as online in the digital library SpringerLink. Post-proceedings: The authors of 4-7 best papers will be invited to submit the extended version of their FLOPS paper to a special issue of the journal Science of Computer Programming (SCP). Important dates Monday, September 14, 2015 (any time zone): Submission deadline Monday, November 16, 2015: Author notification March 3-6, 2016: FLOPS Symposium March 7-9, 2016: PPL Workshop Submission Submissions must be written in English and can be up to 15 pages long including references, though pearls are typically shorter. The formatting has to conform to Springer's guidelines. Regular research papers should be supported by proofs and/or experimental results. In case of lack of space, this supporting information should be made accessible otherwise (e.g., a link to a Web page, or an appendix). Papers should be submitted electronically at https://easychair.org/conferences/?conf=flops2016 Program Committee Andreas Abel Gothenburg University, Sweden Lindsay Errington USA Makoto Hamana Gunma University, Japan Michael Hanus CAU Kiel, Germany Jacob Howe City University London, UK Makoto Kanazawa National Institute of Informatics, Japan Andy King University of Kent, UK (PC Co-Chair) Oleg Kiselyov Tohoku University, Japan (PC Co-Chair) Hsiang-Shang Ko National Institute of Informatics, Japan Julia Lawall Inria-Whisper, France Andres Löh Well-Typed LLP, UK Anil Madhavapeddy Cambridge University, UK Jeff Polakow PivotCloud, USA Marc Pouzet École normale supérieure, France Vítor Santos Costa Universidade do Porto, Portugal Tom Schrijvers KU Leuven, Belgium Zoltan Somogyi Australia Alwen Tiu Nanyang Technological University, Singapore Sam Tobin-Hochstadt Indiana University, USA Hongwei Xi Boston University, USA Neng-Fa Zhou CUNY Brooklyn College and Graduate Center, USA Organizers Andy King University of Kent, UK (PC Co-Chair) Oleg Kiselyov Tohoku University, Japan (PC Co-Chair) Yukiyoshi Kameyama University of Tsukuba, Japan (General Chair) Kiminori Matsuzaki Kochi University of Technology, Japan (Local Chair) flops2016 at logic.cs.tsukuba.ac dot jp

1 0

Munich Haskell Meeting, 2015-04-30 @ 19:30
by Christian Neukirchen 27 Apr '15

27 Apr '15

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Thursday, April 30 at Cafe Puck at 19h30. For details see here: http://www.haskell-munich.de/dates If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-apr-2015/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Ord for partially ordered sets
by Ivan Lazar Miljenovic 27 Apr '15

27 Apr '15

What is the validity of defining an Ord instance for types for which mathematically the `compare` function is partially ordered? Specifically, I have a pull request for fgl [1] to add Ord instances for the graph types (based upon the Ord instances for Data.Map and Data.IntMap, which I believe are themselves partially ordered), and I'm torn as to the soundness of adding these instances. It might be useful in Haskell code (the example given is to use graphs as keys in a Map) but mathematically-speaking it is not possible to compare two arbitrary graphs. What are people's thoughts on this? What's more important: potential usefulness/practicality or mathematical correctness? (Of course, the correct answer is to have a function of type a -> a -> Maybe Ordering :p) [1]: https://github.com/haskell/fgl/pull/11 -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

13 30

Haskell Data.Vector, huge memory leak
by Florian Gillard 27 Apr '15

27 Apr '15

Hi, I am trying to make a basic 2D engine with haskell and the SDL1.2 bindings (for fun, I am just learning). Ideally the world is to be procedurally generated, chunk by chunk, allowing free exploration. Right now my chunk is composed of 200*200 tiles which I represent using a type: Mat [Tile] = Vec.Vector (Vec.Vector [Tile]) and these functions: fromMat :: [[a]] -> Mat a fromMat xs = Vec.fromList [Vec.fromList xs' | xs' <- xs] (§) :: Mat a -> (Int, Int) -> a v § (r, c) = (v Vec.! r) Vec.! c I am using cyclic list of tiles in order to allow for sprite animation, and later for dynamic behaviour. Each frame of the game loop, the program reads the part of the vector relevant to the current camera position, display the corresponding tiles and return a new vector in which every of these cyclic lists has been replaced by it's tail. Here is the code responsible for this: applyTileMat :: Chunk -> SDL.Surface -> SDL.Surface -> IO Chunk applyTileMat ch src dest = let m = chLand $! ch (x,y) = chPos ch wid = Vec.length (m Vec.! 0) - 1 hei = (Vec.length m) - 1 (canW,canH) = canvasSize ch in do sequence $ [ applyTile (head (m § (i,j))) (32*(j-x), 32*(i-y)) src dest | i <- [y..(y+canH)], j <- [x..(x+canW)]] m' <-sequence $ [sequence [(return $! tail (m § (i,j))) | j <- [0..wid]] | i <- [0..hei]] --weird :P return ch { chLand = fromMat m' } the first sequence does the display part, the second one returns the new vector m'. At first I was using the following comprehension to get m' let !m' = [id $! [(tail $! (m § (i,j))) | j <- [0..wid]] | i <- [0..hei]] but doing so results in ever increasing memory usage. I think it has to do with lazy evaluation preventing the data to be properly garbage collected, but I don't really understand why. In this particular case, it doesn't really mater since I have to look at the whole vector. But I don't know how I should do if I wanted to only "update" part of my chunk each frame, thus making a new chunk with only part of the data from the previous one. I am probably not using Data.Vector the way it's intended, but it's the simplest data structure I found with O(n) random access. The whole code is there: https://github.com/eniac314/wizzard/blob/master/tiler.hs

3 2

ANN: getopt-generics - easily create command line parsers by declaring a data type
by shahn 27 Apr '15

27 Apr '15

Hi all, getopt-generics is an experimental library that uses generic programming to automatically create command line parsers given a data type. For an example please refer to the README: [1]. You can also browse the API on hackage: [2]. The primary use-case for getopt-generics is to allow to create proper command line interfaces with as little code as possible. Any feedback appreciated! Cheers, Sönke [1] https://github.com/zalora/getopt-generics#getopt-generics [2] http://hackage.haskell.org/package/getopt-generics/docs/System-Console-GetO…

1 0

Function hanging in infinite input
by martin 26 Apr '15

26 Apr '15

Hello all, I was trying to implement >>= (tBind) on my "Temporal" data type and found that it hangs on an operation like takeInitialPart $ infiniteTemporal >>= (\x -> finiteTemporal) I am pretty sure the result is well defined and by no means infinite. Also the code works on finite Temporals. How does one address such problems? I attach the relevant pieces of code, in case someone would be so kind and inspect or run it. Feel free to point out any flaws as I might be completely off-track. If you call ex10 in GHCI, you get no result. The line marked with "< here" is executed over and over, but apparently without contributing to the result. The debugger shows, that "hd" does have a correct, finite value each time and that "tpr" is consumed as expected. -- -- -- -- -- -- -- -- -- examples -- -- -- -- -- -- -- ex1 = Temporal [(DPast, 1), (T 3,3), (T 7, 7)] :: Temporal Int ex10 = tUntil (T 5) $ outer `tBind` \_ -> ex1 :: Temporal Int where outer = Temporal $ (DPast,0):[(T (fromIntegral t), t)| t <- [5,10 ..]] -- -- -- -- -- -- -- -- -- tBind -- -- -- -- -- -- -- -- -- Changed (Temporal a) to (Temporal Int) for debugging tBind :: (Temporal Int) -> (Int -> Temporal Int) -> Temporal Int tBind tpr f -- tpr is infinite in this example, let's forget these cases -- | tNull tpr = error "empty Temporal" -- | tNull (tTail tpr) = laties | otherwise = let hd = (tUntil (tTt tpr) laties) in hd `tAppend` (tTail tpr `tBind` f) -- < here where laties = switchAt (tTh tpr) ( f (tVh tpr)) tTail (Temporal xs) = Temporal (tail xs) tAppend (Temporal as) (Temporal bs) = Temporal (as ++ bs) switchAt t tpx | tNull (tTail tpx) = Temporal (tot tpx) | between t (tTh tpx) (tTt tpx) = Temporal (tot tpx) | otherwise = switchAt t (tTail tpx) where tot (Temporal ((ty,vy):xs)) = ((max t ty, vy):xs) between t x y = t >= x && t < y -- -- -- -- -- -- -- -- -- helpers -- -- -- -- -- -- -- -- data Time = DPast | T Integer deriving (Eq, Show) -- DPast is "distant past" instance Ord Time where compare DPast DPast = EQ compare DPast _ = LT compare _ DPast = GT compare (T t1) (T t2) = compare t1 t2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- data Temporal a = Temporal [(Time, a)] deriving (Eq, Show) tVh :: Temporal a -> a tVh = snd . head . toList -- value head tTt, tTh :: Temporal a -> Time tTt = fst . head . tail . toList -- time tail tTh = fst . head . toList -- time head tNull = null . toList tUntil :: Time -> Temporal a -> Temporal a tUntil t (Temporal xs) = Temporal $ (takeWhile (\(tx, vx) -> tx > t)) xs toList :: Temporal a -> [(Time, a)] toList (Temporal xs) = xs

4 8

503 on upload to Hackage?
by Magnus Therning 26 Apr '15

26 Apr '15

Yesterday and today I made a few releases of a package to Hackage. On each upload I get a 503 error. This is the text: ~~~ Error 503 backend read error backend read error Guru Mediation: Details: cache-fra1229-FRA 1430030130 1668038750 Varnish cache server ~~~ I'm guessing this isn't expected behaviour. Has anyone else seen this? /M -- Magnus Therning OpenPGP: 0xAB4DFBA4 email: magnus(a)therning.org jabber: magnus(a)therning.org twitter: magthe http://therning.org/magnus Finagle's Second Law: Always keep a record of data -- it indicates you've been working.

2 2

Re: [Haskell-cafe] GHCi shows result of (IO a) only if (a) is in class Show
by Sumit Sahrawat, Maths & Computing, IIT (BHU) 26 Apr '15

26 Apr '15

On 26 April 2015 at 06:10, Alexey Vagarenko <vagarenko(a)gmail.com> wrote: > Yes, but ghci shows an error if it can't print a value, except when the > value is in IO monad. Compare: > Prelude> id > <interactive>:6:1: > No instance for (Show (a0 -> a0)) > (maybe you haven't applied enough arguments to a function?) > arising from a use of `print' > In a stmt of an interactive GHCi command: print it > Prelude> > > and > > Prelude> return id > Prelude> > This behavior is necessary. For example, if we used any function with result of type IO (), such as writeFile, we don't want an error as we are interested in the side-effects only. > > воскресенье, 26 апреля 2015 г., 5:48:55 UTC+6 пользователь Sumit Sahrawat, > Maths & Computing, IIT (BHU) написал: >> >> If something can't be shown (converted to a string), then it can't be >> printed (as a string). >> >> On 25 April 2015 at 17:51, Daniel van den Eijkel <dv...@gmx.net> wrote: >> >>> I wrote a parser and it took me a while to realize why GHCi suddenly did >>> not show any result nor an error message anymore. >>> >>> My parsing function has type (IO Expression), Expression is in class >>> Show. >>> >>> After changing the parser to (IO Declaration), it did not show anything >>> anymore, because Declaration was not in class Show. >>> >>> When I typed (parseFile "input.txt" >>= print), I got the error message >>> and understood what was going on. But for I while I was really confused >>> what's happening. >>> >>> Just wanted to share this. >>> >>> Best, >>> Daniel >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskel...@haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >>> >> >> >> >> -- >> Regards >> >> Sumit Sahrawat >> > -- Regards Sumit Sahrawat

1 1