- Haskell-Cafe - Haskell.org

LAST CALL for draft papers for presentation at IFL 2018 (deadline this week)
by Jurriaan Hage 12 Jul '18

12 Jul '18

Hello, Please, find below the last call for draft papers for presentation for IFL 2018. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- Call for Draft papers for presentations ============================================================ ==================== IFL 2018 30th Symposium on Implementation and Application of Functional Languages University of Massachusetts Lowell, MA, USA September 5th-7th, 2018 http://iflconference.org ============================================================ ==================== ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2018 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications ### Keynote Speakers * Adam Chlipala, Massachusetts Institute of Technology CSAIL * Arjun Guha, University of Massachusetts Amherst ### Submissions and peer-review Differently from previous editions of IFL, IFL 2018 solicits two kinds of submissions: * Regular papers (12 pages including references) * Draft papers for presentations ('weak' limit between 8 and 15 pages) Regular papers will undergo a rigorous review by the program committee, and will be evaluated according to their correctness, novelty, originality, relevance, significance, and clarity. A set of regular papers will be conditionally accepted for publication. Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. Regular papers not accepted for publication will be considered as draft papers, at the request of the author. Draft papers will be screened to make sure that they are within the scope of IFL, and will be accepted for presentation or rejected accordingly. Prior to the symposium: Authors of conditionally accepted papers and accepted presentations will submit a pre-proceedings version of their work that will appear in the draft proceedings distributed at the symposium. The draft proceedings does not constitute a formal publication. We require that at least one of the authors present the work at IFL 2018. After the symposium: Authors of conditionally accepted papers will submit a revised versions of their paper for the formal post-proceedings. The program committee will assess whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. Our interest is to ultimately accept all conditionally accepted papers. If you are an author of a conditionally accepted paper, please make sure that you address all the concerns of the reviewers. Authors of accepted presentations will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal post-proceedings. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected. ### Publication The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication ### Important dates Submission of regular papers: May 25, 2018 [PASSED!] Submission of draft papers: July 17, 2018 [UPCOMING!] Regular and draft papers notification: July 20, 2018 Deadline for early registration: August 8, 2018 Submission of pre-proceedings version: August 29, 2018 IFL Symposium: September 5-7, 2018 Submission of papers for post-proceedings: November 7, 2018 Notification of acceptance: December 22, 2018 Camera-ready version: February 10, 2019 ### Submission details All contributions must be written in English. Papers must use the ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2018 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jay McCarthy & Matteo Cimini, University of Massachusetts Lowell, USA Program Committee: * Arthur Chargueraud, Inria, FR * Ben Delaware, Purdue University, USA * Christos Dimoulas, Northwestern University, USA * David Darais, University of Vermont, USA * Dominic Orchard, University of Kent, UK * Ekaterina Komendantskaya, Heriot-Watt University, UK * Garrett Morris, University of Kansas, USA * Heather Miller, EPFL & Northeastern University, CH & USA * Jeremy Yallop, University of Cambridge, UK * Keiko Nakata, SAP Innovation Center Potsdam, DE * Laura Castro, University of A Coruna, ESP * Magnus Myreen, Chalmers University of Technology, SWE * Natalia Chechina, Bournemouth University, UK * Peter Achten, Radboud Universiteit Nijmegen, NL * Peter-Michael Osera, Grinnell College, USA * Richard Eisenberg, Bryn Mawr College, USA * Trevor McDonell, University of New South Wales, AUS * Yukiyoshi Kameyama, University of Tsukuba, JAP ### Venue The 30th IFL is organized by the University of Massachusetts Lowell. The City of Lowell is located at the heart of the Merrimack Valley just 30 miles northwest of Boston. Lowell can be easily reached by train or taxi. See the website for more information on the venue. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organizers for their work, which is reused here. A part of IFL 2018 format and CFP language that describes conditionally accepted papers has been adapted from call-for-papers of OOPSLA conferences.

1 0

higher kind in parametric type
by Olaf Klinke 11 Jul '18

11 Jul '18

Dear cafe, I am writing a library for parsing higher-kinded data, based on the czipwith package [1]. I ran into the following problem. I have a type class class Config p f | f -> p where f :: (* -> *) -> * is the higher-kinded data and p :: * -> * is the associated parser type. I want to add a class member that does not mention f in its type, e.g. heading :: p String Naturally, this would lead to ambiguity checks to fail, as the usage of heading does not tell which Config instance to use. My usual workaround would be to wrap `heading` in a phantom type, e.g. data Heading f p = Heading (p String) and give `heading` the type Heading f p. However, ghc-8.0.2 complains about f not being a type: • Expecting one more argument to ‘f’ Expected a type, but ‘f’ has kind ‘(* -> *) -> *’ • In the first argument of ‘Heading’, namely ‘f’ In the type signature: heading :: Heading f p In the class declaration for ‘Config’ Is there a restriction of the kinds that can be used in parametric types? Cheers, Olaf [1] http://hackage.haskell.org/package/czipwith

4 4

What is your favourite Haskell "aha" moment?
by Olaf Klinke 11 Jul '18

11 Jul '18

Dear Simon, since you'll be talking to genomics people, you might want to look at a Bachelor thesis about sequence alignment [1]. The author is a PhD student in Cambridge now. In a nutshell, the ListT monad transformer [2] is a good abstraction for full-text index structures [*] that are in heavy use among the genomics people. ListT represents the basic state transformation when a symbol is added to the query string. It also facilitates alignment of sequences with uncertain values [+]. Swapping out the monad lets you change the model of uncertainty, but you write your algorithm only once. I can provide code if required. The edit distance algorithm [3] might also go down well at Sanger. It is an example where lazyness and subtle re-arrangement turns a quadratic algorithm into an optimal one. Olaf [1] https://pp.ipd.kit.edu/uploads/publikationen/kuhnle13bachelorarbeit.pdf [2] http://hackage.haskell.org/package/list-t [3] http://users.monash.edu/~lloyd/tildeStrings/Alignment/92.IPL.html [*] Burrows-Wheeler transform, FM-index, suffix arrays, suffix trees, etc. [+] Current index structures hold only one sequence, while known genomic polymorphisms are stored separately.

1 0

Re: [Haskell-cafe] What is your favourite Haskell "aha" moment?
by Johannes Waldmann 11 Jul '18

11 Jul '18

When teaching, I like to present Property based testing - because it is so useful in itself, and it shows the power of type-level computation - the compiler constructs the dictionaries, both for testing (class Testable p), and for generating test data (class Serial a), just from the type of the property to be tested. I guess that Java folks could do this via reflection? But the popular benchmark these days is not Java - it's Python? Then it's good because there's no types that would help. Exact choice of framework - (quick|small|lean)check does not matter much for an introductory presentation. I do have a preference for enumeration by size (leancheck) not by depth (smallcheck) or randomly (quick). But then, smallcheck can enumerate functions, which is useful from the beginning (if you want to show properties of higher order functions). But then, proving is better than testing, so you might want to mention "theorems for free"? But again - the JS programmer's reaction will be: obtain a theorem from a type? what's a type? - J.W.

2 1

Re: [Haskell-cafe] if-then without -else?
by Anthony Clayden 10 Jul '18

10 Jul '18

>* Why require that each "if-then" has an "else"* Never mind the semantics, this is a piece of syntactic history. ALGOL 60 allowed omitted "else". That gave ambiguity: if p then if q then ... ... else ... There was no layout rule. Does the "else" match to the outer "if-then" or the inner? BCPL ~1965 had two constructs if p then test q then ... ... else ... "if-then" has no "else". If you want an "else" use "test-then-else". AntC

1 0

Re: [Haskell-cafe] if-then without -else?
by Johannes Waldmann 09 Jul '18

09 Jul '18

> Therefore (if False then a) would give an exception. Yes. And the question is, why is possible to write this program using "case" but not with "if". For the first part (allow incomplete sets of patterns in "case"): No matter how hard we try, Haskell is not a total language - there'll always be programs that denote bottom, by raising exceptions (e.g., from incomplete patterns), or by non-termination - which cannot be prohibited statically if we want both the language to be Turing complete, and type inference to be decidable. Cf. Agda, which is total, and therefore has a coverage checker (for patterns) as well as a termination checker. But then the second part (do not allow incomplete "if") appears to be an inconsistency in the design. Mind you - I don't propose to change this. The question is just about justification for the design. Are there applications for an incomplete "if"? I can imagine something like assertions, as in "f x = if some-precondition x then some-computation x" Of course, that's only helpful if the exception contains source information. - J.W.

5 4

Announce: Haskell Platform 8.4.3
by Gershom B 09 Jul '18

09 Jul '18

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.4.3 Now available at https://www.haskell.org/platform/ This includes GHC 8.4.3, cabal-install 2.2.0.0, and stack 1.7.1. A full list of contents is available at https://www.haskell.org/platform/contents.html Outside of the update of the GHC to 8.4.3, the only substantive change in this release is to the new version of the primitive library, which includes a range of fixes and improvements. The list of GHC changes is available at: https://ghc.haskell.org/trac/ghc/blog/ghc-8.4.3-released And the list of changes to Primitive is available at: http://hackage.haskell.org/package/primitive-0.6.4.0/changelog There are (still) currently no 32 bit Windows builds available. We're looking into the issues preventing us from building an installer for that platform. The components all appear to work individually in such a case, and can be installed separately by users who so desire. Happy Haskell Hacking all, Gershom

1 1

Re: [Haskell-cafe] Bool is not...safe?!
by PY 09 Jul '18

09 Jul '18

09.07.2018 11:50, Dušan Kolář wrote: > > Hmm, but CLP has completely different way of evaluation and program > construction than Prolog has. Moreover, stating it is a Prolog is not > so much true then. That's the point as I can see it. > I got you. And this was my point, "declarative" for me, means some declarations/restrictions about answer/answers. No exact algorithm: you can even don't know how this is evaluated/executed. You only find some relations and declare them. And set of solvers tries to find solutions. So, modern Prolog/Logic systems are Prolog as DSL and set of solvers, right. For example, to find factorial as well as it's argument, you need to implement CLP library in Haskell explicitly (if you want to use CLP way). This is the Haskell tradition. Sure, you can do it in Python, in C (sure, such libraries already exist). But it's not declarative tradition: predicates calculus is based on backtracking and variables unification. Haskell, like Scheme is based on lambda calculus. So, evaluation is totally different. But more interesting here (regarding to Bool subj) is that Haskell can return to you 120 as factorial result, but Prolog will answer you (if it finds several results) "do you need next one?" and *result in Prolog is "Yes."*. This is important. Which can be imagine in terms of Haskell like you have not top-level `IO ()` but some `LogicMonad ()`. And all evaluations in Haskell will lead to Boolean (OK, truth/lie/yes/no) result. Evaluated (integers/floats/etc) result must be returned as output variables (your factorial is: `factorial(+N, -F)` i.e. it's one-directional only, so all functions in such Haskell also can return results in some reference/output var and evaluated to Bool). I can imagine this. Also if result is "No.", output variables unifications (bindings - in Haskell terms) will be dropped out. Unfortunately I dont know Curry and absolutely can not say: is it implemented in such way. But I'm sure that it's possible :) Joachim pointed out "cut" operation which leads to more effective code, but eliminates pure logic constructs. There are "green cuts" (does not change semantic) and "red cuts" and this shows that practical real world languages mostly are not pure functional/pure logical. But there is another point: it makes sense to have pure logical application which can be driven from C# or Java application (there are such puzzles and other games, on Android, Windows, tables/plane schedulers, expert systems, etc), but I can not imagine why I'll call for example, Haskell from the Java, because their area mostly are intersected in contrast with Java/Prolog, for example. This is some marker too, about which languages have similar "nature". I have already agreed that are possible another classifications coordinates as well as it's difficult to classify some languages because they are totally hybrid (I remember yet another such: Racket, Oz/Mozart). PS. I'm application developer only, not researcher, but I'm absolutely sure: there are people in the list which are totally in the subject, even may be some of them are devs of Curry or Mercury for example, and maybe they are laughing at me and my naive intuitions now :) > And it has nothing to do with Haskell extensions. In Haskell, the > principle remains the same, though. > > Dušan > > On pondělí 9. července 2018 10:22:15 CEST you wrote: > > > Hello, Dušan! > > > > > > > This is not Prolog, it is a Prolog with CLP extension over integers. > > > > > > as well as Haskell has a lot of extensions. I mentioned CLP as solver > > > but modern Prologs is not ISO only and has a lot of solvers (CHR, > > > different CLP, FuzzyLogic, Tabulating, etc). Actually CLP(x) in included > > > in most modern implementations. > > > > > > 09.07.2018 10:58, Dušan Kolář wrote: > > > > Hello PY/Paul, > > > > > > > > You are using misleading arguments! > > > > > > > > This is not Prolog, it is a Prolog with CLP extension over integers. > > > > > > > > > factorial(0, 1). > > > > > > > > > > factorial(N, F) :- > > > > > > > > > > N #> 0, > > > > > > > > > > N1 #= N - 1, > > > > > > > > > > F #= N * F1, > > > > > > > > > > factorial(N1, F1). > > > > > > > > > > > > > > > > > > > > I can call it: factorial(5, X) => X=120. > > > > > > > > > > But also: factorial(X, 120) => X=5. > > > > > > > > Pure Prolog is: > > > > > > > > factorial(0, 1) :- !. > > > > > > > > factorial(N, F) :- > > > > > > > > NN is N - 1, > > > > > > > > factorial(NN, FF), > > > > > > > > F is FF * N. > > > > > > > > which is a function, not a relation, as you write. > > > > > > > > Dušan Kolář >

1 0

Imperative vs. declarative (was: Bool is not...safe?!)
by Olaf Klinke 09 Jul '18

09 Jul '18

Although there is little to add to Joachim's patient explanations, and there are certainly better resources, here is my own attempt at a definition of imperative vs. declarative. The word "imperative" stems from Latin and means to command, to rule. Imperative programs tell the computer what to do, and when. Now allocate some memory, now assign this value to this variable, now check this condition and branch on it, etc. The word "declarative" also stems from Latin, meaning to make precise. Declarative languages tell the computer what data is, not when and how exactly to compute it. Haskell as a lazy language takes this even further - some code you have declared may actually never get executed. These decisions are abstracted away and made by the Haskell runtime system, in our case. Your own example of factorial is very much declarative in the above sense, because it only declares what the factorial function is, in terms of the relationship between factorial(n) and factorial(n-1). Of course the functional programmer must have a mental model of the runtime's behaviour in mind. (Recursively calling the function, in this case.) But what happens on the lower, imperative level when computing factorial(n) is not relevant for the definition of the function. Whether the principal programming constructs are functions or relations is not relevant to being declarative. In fact, the Prolog beginner can easily run into traps by declaring rules that make the solver (the low-level, imperative part of the execution) go into infinite loops, although all declarations are logically correct. Hence in Haskell as in Prolog, although both are declarative, the programmer must have some knowledge of the imperative nature of the runtime system. Olaf

3 2

Re: [Haskell-cafe] Bool is not...safe?!
by PY 09 Jul '18

09 Jul '18

Hello, Dušan! > This is not Prolog, it is a Prolog with CLP extension over integers. as well as Haskell has a lot of extensions. I mentioned CLP as solver but modern Prologs is not ISO only and has a lot of solvers (CHR, different CLP, FuzzyLogic, Tabulating, etc). Actually CLP(x) in included in most modern implementations. 09.07.2018 10:58, Dušan Kolář wrote: > > Hello PY/Paul, > > You are using misleading arguments! > > This is not Prolog, it is a Prolog with CLP extension over integers. > > > > > > factorial(0, 1). > > > factorial(N, F) :- > > > N #> 0, > > > N1 #= N - 1, > > > F #= N * F1, > > > factorial(N1, F1). > > > > > > I can call it: factorial(5, X) => X=120. > > > But also: factorial(X, 120) => X=5. > > > > > Pure Prolog is: > > factorial(0, 1) :- !. > > factorial(N, F) :- > > NN is N - 1, > > factorial(NN, FF), > > F is FF * N. > > which is a function, not a relation, as you write. > > Dušan Kolář >

1 0