- Haskell-Cafe - Haskell.org

[Job] Formal Tech is hiring
by Iavor Diatchki 04 Aug '16

04 Aug '16

Hello, Formal Tech, a Galois spin-off, is looking for a mid to senior level engineer to work on CyberChaff ( https://formal.tech/products/cyberchaff/) Applicants should be proficient in Haskell and at least one other programming language. This is a full time position with benefits. If you are interested, please send your resume to careers(a)formal.tech Cheers, -Iavor

1 0

Measuring allocations with 'weigh' - what about thunks?
by Mitchell Rosen 03 Aug '16

03 Aug '16

weigh (https://www.fpcomplete.com/blog/2016/05/weigh-package) is a library measures how much allocation evaluating a function causes. It's basically a nice interface to GHC.Stats.getGCStats. Here is an example that measures *\n -> n+1*: import Weigh main :: IO () main = mainWith (func "+1" plusOne 5) plusOne :: Int -> Int plusOne = \n -> n + 1 which prints Case Bytes GCs Check +1 16 0 OK when run (64 bit machine; allocating 1 Int = 16 bytes). So my question is, what about the thunk allocated by *(+)*? My rough understanding of the heap is this: Code Heap ---- ---- 1 1 1 1 1 plusOne 1 +-------+----------+----+ +----+---+ | THUNK | reserved | --|--> | I# | 5 | +-------+----------+----+ +----+---+ 1 1 1 1 1 deepseq it +-------+----------+----+ +----+---+ | IND | | --|--> | I# | 5 | +-------+-----|----+----+ +----+---+ | 1 1 `------------> +----+---+ | I# | 6 | +----+---+ 1 1 GC +----+---+ | I# | 6 | +----+---+ So haven't we allocated 5 bytes, not two? Three for the GC'd thunk, and two for the new Int? Any clarification or pointers (heh) to some GHC reading would be greatly appreciated! Thanks, Mitchell

1 0

[ANN] HaRe 0.8.3.0 Released
by Alan & Kim Zimmerman 03 Aug '16

03 Aug '16

Now that ghc-mod 5.6.0.0 is out, I have been able to release HaRe for GHC 8.0.1 There are no functional changes, this release just adds support for GHC 8.0.1. Just a heads up for anyone who is interested, my plans for the near future are 1. Complete adding default annotations to ghc-exactprint. This will allow pretty printing a GHC AST that has been generated via some process other than parsing source, by adding annotations to it. 2. Return to haskell-ide-engine The initial focus will be on enabling the remote ghci mode into it. In general, my focus is on improving the tooling experience around GHC. Alan

1 0

What's the state of programming on the Xeon Phi with Haskell?
by Jules Mazur 03 Aug '16

03 Aug '16

I recently gained access to a Xeon Phi (Knights Corner edition, a bit dated but useful to play around with), and I'm interested in using Haskell to program for the Phi platform. Sadly, the only lead I've got about working with both technologies is a 2014 paper by Liu, et al. at Intel Research (available via [this site](https://www.researchgate.net/publication/262310691_The_Intel_Labs_Has…) In a 3-month-old [Reddit thread](https://www.reddit.com/r/haskell/comments/4hokvy/is_there_any_way_t…, one of the authors mentions that the compiler may be released at a future date, but implied that it will likely have some degree of instability. Are there any libraries or compilers, or even extensions or modifications for GHC or other existing compilers, that allow compilation for the Xeon Phi?

1 0

ANN: haskell-src-exts-simple
by Bertram Felgenhauer 02 Aug '16

02 Aug '16

Dear all, I've just released haskell-src-exts-simple 1.18.0.0 on hackage [1]. (This is the first release. The first two components of the version follow haskell-src-exts.) >From the README: This package provides a shim for haskell-src-exts, exposing the same AST but without annotations. This package is useful for synthesizing and manipulating HSE ASTs that don't carry source location information. It may also aid in porting packages from haskell-src-exts 1.17 to 1.18, but it is not a drop-in replacement for the old annotation-free AST. See [2] for details. Happy hacking, Bertram [1] https://hackage.haskell.org/package/haskell-src-exts-simple [2] https://github.com/int-e/haskell-src-exts-simple/blob/master/COMPATIBILITY.…

1 1

Haskell in Leipzig 2016: Call for Participation
by Joachim Breitner 02 Aug '16

02 Aug '16

Haskell in Leipzig September 14-15, 2016 HTKW Leipzig, Germany http://hal2016.haskell.org/ We have received many interesting submissions for HAL and were able to assemble a great program, which you can find here: http://hal2016.haskell.org/program.html Abstracts and final schedule will be added soonish™. As you can see, we have an interesting program spanning from practical, real-word uses of Haskell over data structures and libraries to game- and music programming. Besides the 12 talks, there are three tutorials to attend. As a special treat, on the evening of September 14, Anton Kholomiov will give a live music coding performance! If you are interested in attending, please head over to http://nfa.imn.htwk-leipzig.de/LDEC2016/registration/ and follow the instructions. HAL is cheap, and even cheaper for students, and yet cheaper if you pay by the early registration deadline of August 15¹ Also check out the other two conferences of LDEC (WLP and WLFP), and if you like them, make it a week full of functional programming! Thanks, Joachim Breitner on behalf of the program committee ¹ Note that the early registration deadline is for the money, so make sure you allow for the bank to transfer it in time. -- Dr. rer. nat. Joachim Breitner Wissenschaftlicher Mitarbeiter http://pp.ipd.kit.edu/~breitner

1 0

PEPM 2017 Second Call for Papers
by Jeremy Yallop 02 Aug '16

02 Aug '16

SECOND CALL FOR PAPERS Workshop on PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM 2017) NEWS: Keynote talk by Neil Jones, DIKU (see below). http://conf.researchr.org/home/PEPM-2017 Paris, France, January 16th - 17th, 2017 (co-located with POPL 2017) PEPM is the premier forum for discussion of semantics-based program manipulation. The first ACM SIGPLAN PEPM symposium took place in 1991, and meetings have been held in affiliation with POPL every year since 2006. PEPM 2017 will be based on a broad interpretation of semantics-based program manipulation, reflecting the expanded scope of PEPM in recent years beyond the traditionally covered areas of partial evaluation and specialization. Specifically, PEPM 2017 will include practical applications of program transformations such as refactoring tools, and practical implementation techniques such as rule-based transformation systems. In addition, the scope of PEPM covers manipulation and transformations of program and system representations such as structural and semantic models that occur in the context of model-driven development. In order to maintain the dynamic and interactive nature of PEPM and to encourage participation by practitioners, we also solicit submissions of short papers, including tool demonstrations, and of posters. Scope ----- Topics of interest for PEPM 2017 include, but are not limited to: * Program and model manipulation techniques such as: supercompilation, partial evaluation, fusion, on-the-fly program adaptation, active libraries, program inversion, slicing, symbolic execution, refactoring, decompilation, and obfuscation. * Program analysis techniques that are used to drive program/model manipulation such as: abstract interpretation, termination checking, binding-time analysis, constraint solving, type systems, automated testing and test case generation. * Techniques that treat programs/models as data objects including metaprogramming, generative programming, embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation. * Application of the above techniques including case studies of program manipulation in real-world (industrial, open-source) projects and software development processes, descriptions of robust tools capable of effectively handling realistic applications, benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, embedded and resource-limited computation, and security. This list of categories is not exhaustive, and we encourage submissions describing applications of semantics-based program manipulation techniques in new domains. If you have a question as to whether a potential submission is within the scope of the workshop, please contact the programme chairs. Submission categories and guidelines ------------------------------------ Three kinds of submissions will be accepted: Regular Research Papers, Short Papers and Posters. * Regular Research Papers should describe new results, and will be judged on originality, correctness, significance and clarity. Regular research papers must not exceed 12 pages in ACM Proceedings style (including appendix). * Short Papers may include tool demonstrations and presentations of exciting if not fully polished research, and of interesting academic, industrial and open-source applications that are new or unfamiliar. Short papers must not exceed 6 pages in ACM Proceedings style (including appendix). * Posters should describe work relevant to the PEPM community, and must not exceed 2 pages in ACM Proceedings style. We invite poster submissions that present early work not yet ready for submission to a conference or journal, identify new research problems, showcase tools and technologies developed by the author(s), or describe student research projects. At least one author of each accepted contribution must attend the workshop and present the work. In the case of tool demonstration papers, a live demonstration of the described tool is expected. Suggested topics, evaluation criteria, and writing guidelines for both research tool demonstration papers will be made available on the PEPM 2017 web site. Student participants with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses and other support. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC programme, see its web page. Publication and special issue ----------------------------- All accepted papers, short papers and posters included, will appear in formal proceedings published by ACM Press. Accepted papers will be included in the ACM Digital Library. Authors of selected papers from PEPM 2016 and PEPM 2017 will also be invited to expand their papers for publication in a special issue of the journal Computer Languages, Systems and Structures (COMLAN, Elsevier). Keynote ------- Neil Jones (DIKU) will give the PEPM keynote talk, titled Compiling Untyped Lambda Calculus to Lower-level Code by Game Semantics and Partial Evaluation Best paper award ---------------- PEPM 2017 continues the tradition of a Best Paper award. The winner will be announced at the workshop. Submission ---------- Papers should be submitted electronically via HotCRP. https://pepm17.hotcrp.com/ Authors using LaTeX to prepare their submissions should use the new improved SIGPLAN proceedings style, and specifically the sigplanconf.cls 9pt template. Important Dates --------------- For Regular Research Papers and Short Papers: * Abstract submission : Tuesday 13th September 2016 * Paper submission : Friday 16th September 2016 * Author notification : Monday 24th October 2016 * Camera ready : Monday 28th November 2016 For Posters: * Poster submission : Sunday 30th October 2016 * Author notification : Friday 10th November 2016 * Camera ready : Monday 28th November 2016 PEPM workshop: * Workshop : Monday 16th - Tuesday 17th January 2017 The proceedings will be published 2 weeks pre-conference. AUTHORS TAKE NOTE: The official publication date is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of your conference. The official publication date affects the deadline for any patent filings related to published work. (For those rare conferences whose proceedings are published in the ACM Digital Library after the conference is over, the official publication date remains the first day of the conference.). PEPM'17 Programme Committee --------------------------- Elvira Albert (Complutense University of Madrid, Spain) Don Batory (University of Texas at Austin, USA) Martin Berger (University of Sussex, UK) Sebastian Erdweg (TU Delft, Netherlands) Andrew Farmer (Facebook, USA) Matthew Flatt (University of Utah, USA) John Gallagher (Roskilde University, Denmark) Robert Glück (DIKU, Denmark) Jurriaan Hage (Utrecht University, Netherlands) Zhenjiang Hu (National Institute of Informatics, Japan) Yukiyoshi Kameyama (University of Tsukuba, Japan) Ilya Klyuchnikov (Facebook, UK) Huiqing Li (EE, UK) Annie Liu (Stony Brook University, USA) Markus Püschel (ETH Zurich, Switzerland) Ryosuke SATO (University of Tokyo, Japan) Sven-Bodo Scholz (Heriot-Watt University, UK) Ulrik Schultz (co-chair) (University of Southern Denmark) Ilya Sergey (University College London, UK) Chung-chieh Shan (Indiana University, USA) Tijs van der Storm (Centrum Wiskunde & Informatica, Netherlands) Jeremy Yallop (co-chair) (University of Cambridge, UK)

1 0

FINAL CALL FOR TALKS (Aug 8 deadline): Haskell Implementors Workshop 2016, Sep 24, Nara
by Edward Z. Yang 02 Aug '16

02 Aug '16

Deadline is in a week! Submit your talks! Call for Contributions ACM SIGPLAN Haskell Implementors' Workshop http://haskell.org/haskellwiki/HaskellImplementorsWorkshop/2016 Nara, Japan, 24 September, 2016 Co-located with ICFP 2016 http://www.icfpconference.org/icfp2016/ Important dates --------------- Proposal Deadline: Monday, 8 August, 2016 Notification: Monday, 22 August, 2016 Workshop: Saturday, 24 September, 2016 The 8th Haskell Implementors' Workshop is to be held alongside ICFP 2016 this year in Nara. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure, to share their work and discuss future directions and collaborations with others. Talks and/or demos are proposed by submitting an abstract, and selected by a small program committee. There will be no published proceedings; the workshop will be informal and interactive, with a flexible timetable and plenty of room for ad-hoc discussion, demos, and impromptu short talks. Scope and target audience ------------------------- It is important to distinguish the Haskell Implementors' Workshop from the Haskell Symposium which is also co-located with ICFP 2016. The Haskell Symposium is for the publication of Haskell-related research. In contrast, the Haskell Implementors' Workshop will have no proceedings -- although we will aim to make talk videos, slides and presented data available with the consent of the speakers. In the Haskell Implementors' Workshop, we hope to study the underlying technology. We want to bring together anyone interested in the nitty-gritty details behind turning plain-text source code into a deployed product. Having said that, members of the wider Haskell community are more than welcome to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Talks ----- At this stage we would like to invite proposals from potential speakers for talks and demonstrations. We are aiming for 20 minute talks with 10 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Please submit a talk title and abstract of no more than 300 words. Submissions should be made via HotCRP. The website is: https://icfp-hiw16.hotcrp.com/ We will also have a lightning talks session which will be organised on the day. These talks will be 5-10 minutes, depending on available time. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Organisers --- End forwarded message ---

1 0

Re: [Haskell-cafe] [ANN] hgmp-0.1.0.0
by Claude Heiland-Allen 02 Aug '16

02 Aug '16

Hi Sergey, café, On 01/08/16 21:13, Sergey Bushnyak wrote: > Nice work! How it differs from > https://hackage.haskell.org/package/integer-gmp ? Good question! integer-gmp is a binding of enough of GMP to make implementing Integer possible. It is very low level in the GHC package heirarchy, so trying to make it provide high level code is painful, if not impossible. It exposes the bare minimum of functionality to let most of Integer be implemented by the base package. hgmp uses the public integer-gmp internal details (also ghc-prim for the lower level stuff like copying byte arrays to/from Haskell heap / foreign memory) to expose helpers using Integer and Rational for interacting with foreign code that expects mpz_t and mpq_t data structures. So the package heirarchy is something like this diagram (fixed width font recommended): hgmp -- Integer and Rational FFI helpers for libgmp API / | \ | | base -- Integer numeric instances, the standard Prelude, etc | | | : | integer-gmp -- bindings for Integer implementation (bare minimum) | | / ghc-prim -- very low level compiler specifics hgmp eventually should also contain bindings to the functions in GMP, I'm considering the best way to go about it. My current thought is to generate raw and higher-level bindings semi-automatically from the C API header file gmp.h - any other suggestions? Claude > On 08/01/2016 10:57 PM, Claude Heiland-Allen wrote: >> Hi all, >> >> hgmp 0.1.0.0 is released! [0] >> >> hgmp is a Haskell interface to GMP[1] (for GHC with the default >> integer-gmp implementation of Integer). Contains type definitions and >> marshalling functions, to be able to write FFI bindings using >> Haskell's Integer and Rational types. Function bindings may come in a >> future version. >> >> A simple example illustrating binding to GMP's next probable-prime >> function: >> >> {-# LANGUAGE ForeignFunctionInterface #-} >> >> import Foreign.Ptr (Ptr(..)) >> import Numeric.GMP.Types (MPZ) >> import Numeric.GMP.Utils (withInInteger, withOutInteger_) >> import System.IO.Unsafe (unsafePerformIO) >> >> foreign import ccall safe "__gmpz_nextprime" >> mpz_nextprime :: Ptr MPZ -> Ptr MPZ -> IO () >> >> nextPrime :: Integer -> Integer >> nextPrime n = >> unsafePerformIO $ >> withOutInteger_ $ \rop -> >> withInInteger n $ \op -> >> mpz_nextprime rop op >> >> You can cabal install (or otherwise get it) from Hackage[2], or get >> (or browse[3]) the freshest sources from git: >> >> git clone https://code.mathr.co.uk/hgmp.git >> >> Any and all feedback welcome! I'm sure there are some things that >> could be improved, and ideas for future versions will be appreciated too. >> >> [0] https://mathr.co.uk/blog/2016-08-01_hgmp_0_1_0_0_released.html >> [1] https://gmplib.org/ >> [2] http://hackage.haskell.org/package/hgmp >> [3] https://code.mathr.co.uk/hgmp >> >> Thanks, >> >> >> Claude > -- https://mathr.co.uk

1 0

[ANN] hgmp-0.1.0.0
by Claude Heiland-Allen 02 Aug '16

02 Aug '16

Hi all, hgmp 0.1.0.0 is released! [0] hgmp is a Haskell interface to GMP[1] (for GHC with the default integer-gmp implementation of Integer). Contains type definitions and marshalling functions, to be able to write FFI bindings using Haskell's Integer and Rational types. Function bindings may come in a future version. A simple example illustrating binding to GMP's next probable-prime function: {-# LANGUAGE ForeignFunctionInterface #-} import Foreign.Ptr (Ptr(..)) import Numeric.GMP.Types (MPZ) import Numeric.GMP.Utils (withInInteger, withOutInteger_) import System.IO.Unsafe (unsafePerformIO) foreign import ccall safe "__gmpz_nextprime" mpz_nextprime :: Ptr MPZ -> Ptr MPZ -> IO () nextPrime :: Integer -> Integer nextPrime n = unsafePerformIO $ withOutInteger_ $ \rop -> withInInteger n $ \op -> mpz_nextprime rop op You can cabal install (or otherwise get it) from Hackage[2], or get (or browse[3]) the freshest sources from git: git clone https://code.mathr.co.uk/hgmp.git Any and all feedback welcome! I'm sure there are some things that could be improved, and ideas for future versions will be appreciated too. [0] https://mathr.co.uk/blog/2016-08-01_hgmp_0_1_0_0_released.html [1] https://gmplib.org/ [2] http://hackage.haskell.org/package/hgmp [3] https://code.mathr.co.uk/hgmp Thanks, Claude -- https://mathr.co.uk

1 0