- Haskell-Cafe - Haskell.org

How does the RTS "know" about ExitCode
by Georgi Lyubenov 16 Jul '20

16 Jul '20

Hi! I'm wondering how values stored in ExitCode "get to" the RTS (i.e. actually make the program exit with the given number). As far as I can tell ExitCode is used as an everyday normal-looking exception (which are defined entirely in "library code", by using the raise#/catch# primitives), without any direct link to the RTS. What am I missing? ====== Georgi

2 2

setting ISO-8859-1 encoding on Raspbian for GHC
by Henning Thielemann 16 Jul '20

16 Jul '20

On Raspbian Buster I get: pi@raspberrypi:~ $ LANG=de_DE ghc -e 'print System.IO.localeEncoding' UTF-8 pi@raspberrypi:~ $ LANG=de_DE.iso88591 ghc -e 'print System.IO.localeEncoding' UTF-8 pi@raspberrypi:~ $ LANG=de_DE@euro ghc -e 'print System.IO.localeEncoding' UTF-8 Which is not, what I want. On Debian Buster it is correct: $ LANG=de_DE ghc -e 'print System.IO.localeEncoding' ISO-8859-1 How can I check whether this is a GHC problem and has anyone an idea how to fix it?

3 4

Second call for draft papers for IFL 2020 (Implementation and Application of Functional Languages)
by Jurriaan Hage 15 Jul '20

15 Jul '20

Hello, Please, find below the second call for draft papers for IFL 2020. 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 ================================================================================ IFL 2020 32nd Symposium on Implementation and Application of Functional Languages venue: online 2nd - 4th September 2020 https://www.cs.kent.ac.uk/events/2020/ifl20/ ================================================================================ ### 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 2020 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 specialisation - run-time code generation - partial evaluation - (abstract) interpretation - meta-programming - 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 ### Post-symposium peer-review Following IFL tradition, IFL 2020 will use a post-symposium review process to produce the formal proceedings. Before the symposium authors submit draft papers. These draft papers will be screened by the program chair to make sure that they are within the scope of IFL. The draft papers will be made available to all participants at the symposium. Each draft paper is presented by one of the authors at the symposium. After the symposium every presenter is invited to submit a full paper, incorporating feedback from discussions at the symposium. Work submitted to IFL may not be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy. 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 for the formal proceedings. We plan to publish these proceedings in the International Conference Proceedings Series of the ACM Digital Library, as in previous years. ### Important dates Submission deadline of draft papers: 17 August 2020 Notification of acceptance for presentation: 19 August 2020 Registration deadline: 31 August 2020 IFL Symposium: 2-4 September 2020 Submission of papers for proceedings: 7 December 2020 Notification of acceptance: 3 February 2021 Camera-ready version: 15 March 2021 ### 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 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honoured 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. ### Programme committee Kenichi Asai, Ochanomizu University, Japan Olaf Chitil, University of Kent, United Kingdom (chair) Martin Erwig, Oregon State University,United States Daniel Horpacsi, Eotvos Lorand University, Hungary Zhenjiang Hu, Peking University, China Hans-Wolfgang Loidl, Heriot-Watt University, United Kingdom Neil Mitchell, Facebook, UK Marco T. Morazan, Seton Hall University, United States Rinus Plasmeijer, Radboud University, Netherlands Colin Runciman, University of York, United Kingdom Mary Sheeran, Chalmers University of Technology, Sweden Josep Silva, Universitat Politecnica de Valencia, Spain Jurrien Stutterheim, Standard Chartered, Singapore Josef Svenningsson, Facebook, UK Peter Thiemann, University of Freiburg, Germany Kanae Tsushima, National Institute of Informatics, Japan. Marcos Viera, Universidad de la Republica, Montevideo, Uruguay Janis Voigtlander, University of Duisburg-Essen, Germany ### Virtual symposium Because of the Covid-19 pandemic, this year IFL 2020 will be an online event, consisting of paper presentations, discussions and virtual social gatherings. Registered participants can take part from anywhere in the world. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organisers for their work, which is reused here.

1 0

containers-0.6.3.1
by David Feuer 15 Jul '20

15 Jul '20

At long last, we have released containers-0.6.3.1. The most important changes in this release are bug fixes for IntMap traversals: * Fix traverse and traverseWithKey for IntMap, which would previously produce invalid IntMaps when the input contained negative keys (Thanks, Felix Paulusma). * Fix the traversal order of various functions for Data.IntMap: traverseWithKey, traverseMaybeWithKey, filterWithKeyA, minimum, maximum, mapAccum, mapAccumWithKey, mapAccumL, mapAccumRWithKey, mergeA (Thanks, Felix Paulusma, Simon Jakobi). These now traverse in key order; previously they would traverse non-negative keys before negative keys. If you traverse any IntMaps, please take note of these changes. We also have several additions to the API: * Add compose for Map and IntMap (Thanks, Alexandre Esteves). * Add alterF for Set and IntSet (Thanks, Simon Jakobi). * Add Data.IntSet.mapMonotonic (Thanks, Javran Cheng). * Add instance Bifoldable Map (Thanks, Joseph C. Sible). Performance improvements of note: * Make (<*) for Data.Sequence incrementally asymptotically optimal (Thanks, David Feuer). This finally completes the task, begun in December 2014, of making all the Applicative methods for sequences asymptotically optimal even when their results are consumed incrementally. Many thanks to Li-Yao Xia and Bertram Felgenhauer for helping to clean up and begin to document this rather tricky code. * Speed up fromList and related functions in Data.IntSet, Data.IntMap and Data.IntMap.Strict (Thanks, Bertram Felgenhauer). * Use count{Leading,Trailing}Zeros in Data.IntSet internals (Thanks, Alex Biehl). There are also numerous documentation improvements and packaging updates. Please see the changelog for full details. Thanks to all the contributors, The containers team

2 1

Call for Participation: ICFP 2020
by Sam Tobin-Hochstadt 15 Jul '20

15 Jul '20

===================================================================== Call for Participation ICFP 2020 25th ACM SIGPLAN International Conference on Functional Programming and affiliated events August 23 - August 28, 2020 Online http://icfp20.sigplan.org/ Early Registration until August 8! The ICFP Programming Contest starts on July 17! ===================================================================== ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. The conference covers the entire spectrum of work, from practice to theory, including its peripheries. This year, the conference will be a virtual event. All activities will take place online. The ICFP Programming competition will be July 17th through 20th, 2020! The main conference will take place from August 24-26, 2020 during two time bands. The first band will be 9AM-5:30PM New York, and will include both technical and social activities. The second band will repeat (with some variation) the technical program and social activities 12 hours later, 9AM-5:30PM Beijing, the following day. We’re excited to announce our two invited speakers for 2020: Evan Czaplicki, covering the Elm programming language and hard lessons learned on driving adoption of new programming languages; and Audrey Tang, Haskeller and Taiwan’s Digital Minister, on how software developers can contribute to fighting the pandemic. ICFP has officially accepted 37 exciting papers, and (as a fresh experiment this year) there will also be presentations of 8 papers accepted recently to the Journal of Functional Programming. Co-located symposia and workshops will take place the day before and two days immediately after the main conference. Registration is now open. The early registration deadline is August 8th, 2020. Registration is not free, but is significantly lower than usual. Students who are ACM or SIGPLAN members may register for FREE before the early deadline. https://regmaster.com/2020conf/ICFP20/register.php New this year: Attendees will be able to sign-up for the ICFP Mentoring Program (either to be a mentor, receive mentorship or both). * Overview and affiliated events: http://icfp20.sigplan.org/home * Accepted papers: http://icfp20.sigplan.org/track/icfp-2020-papers#event-overview * JFP Talks: https://icfp20.sigplan.org/track/icfp-2020-jfp-talks#event-overview * Registration is available via: https://regmaster.com/2020conf/ICFP20/register.php Early registration ends 8 August, 2020. * Programming contest: https://icfpcontest2020.github.io/ The Programming Contest begins July 17th! * Student Research Competition: https://icfp20.sigplan.org/track/icfp-2020-Student-Research-Competition * Follow us on Twitter for the latest news: http://twitter.com/icfp_conference This year, there are 10 events co-located with ICFP: * Erlang Workshop (8/23) * Haskell Implementors' Workshop (8/28) * Haskell Symposium (8/27-8/28) * Higher-Order Programming with Effects (8/23) * miniKanren Workshop (8/27) * ML Family Workshop (8/27) * OCaml Workshop (8/28) * Programming Languages Mentoring Workshop (8/23) * Scheme Workshop (8/28) * Type-Driven Development (8/23) ### ICFP Organizers General Chair: Stephanie Weirich (University of Pennsylvania, USA) Program Chair: Adam Chlipala (MIT, USA) Artifact Evaluation Co-Chairs: Brent Yorgey (Hendrix College, USA) Ben Lippmeier (Ghost Locomotion, Australia) Industrial Relations Chair: Alan Jeffrey (Mozilla Research, USA) Programming Contest Organizer: Igor Lukanin (Kontur, Russia) Publicity and Web Chair: Sam Tobin-Hochstadt (Indiana University, USA) Student Research Competition Chair: Youyou Cong (Tokyo Institute of Technology, Japan) Workshops Co-Chair: Jennifer Hackett (University of Nottingham, UK) Leonidas Lampropoulos (University of Pennsylvania, USA) Video Chair: Leif Andersen (Northeastern University, USA) Student Volunteer Co-Chair: Hanneli Tavante (McGill University, Canada) Victor Lanvin (IRIF, Université Paris Diderot, France)

1 0

Re: [Haskell-cafe] Caching functions compiled with llvm-hs
by Tom Westerhout 12 Jul '20

12 Jul '20

On 11/07/2020, Georgi Lyubenov <godzbanebane(a)gmail.com> wrote: > Is there something wrong with your idea? (other than ideological issues > with unsafePerformIO - I guess then the standard approach would be to use > some State holding your compiled functions or a Reader over an MVar holding > your compiled functions) The part that feels wrong here is that one has to create a new Module for every single function. I always thought of LLVM Modules as kind of compilation units. Or is this an okay-ish approach? > > The only thing you should make sure to do is add a NOINLINE to wherever the > unsafePerformIO is, so that it doesn't get inlined and executed more than > once. Oh I totally forgot! Thank you for reminding! Cheers, Tom

2 2

Caching functions compiled with llvm-hs
by Tom Westerhout 12 Jul '20

12 Jul '20

Hello, Suppose I've written some function f :: Foo -> Bar using LLVM IR. Now I'd like to compile it on first invocation with llvm-hs and cache the obtained function pointer. Basically something like this f :: Foo -> Bar f x = fImpl x where fImpl = unsafePerformIO $ flag <- isAlreadyCompiled -- check the cache if flag fetchFunc -- get the compiled code from cache else compileWithLLVM -- build LLVM IR, compile it, and update the cache A very primitive JIT compiler. What is the best way to do this with llvm-hs? All standard examples using LLVM.OrcJIT or LLVM.ExecutionEngine show how to compile a function and then immediately execute it. I can't quite figure out a safe way to keep the FunPtr... Big code bases like Accelerate or JuliaLang do achieve this somehow, but are quite difficult to understand for the uninitiated. Any advice is highly appreciated! Cheers, Tom

2 2

Re: [Haskell-cafe] Test on identity?
by Olaf Klinke 11 Jul '20

11 Jul '20

> Am 09.07.20 um 20:26 schrieb Olaf Klinke: > > Joachim Durchholz wrote: > >> This "identity is equality under change" definition captures not > >> just > >> two objects at identical addresses, but also proxies, network > >> objects, > >> files, and whatever there is. > >> > >> Step 3: Realize that if you have an immutable object, there is no > >> relevant difference between equality and identity anymore. (You > can > >> make > >> various formal statements about this.) > > > > Is that what is called "extensional equality"? Values a,b :: A are > > extensionally equal if they behave the same in all contexts. > > To fully treat this, you have to explore some pretty interesting > waters. > > First, "all contexts" can mean pretty different things. > E.g. in Haskell (without unsafe* and similar), everything is > immutable, > so you have contexts that exist in languages with mutability but not > in > Haskell, and you'd have to define what "all contexts" means for a > general term like "extensional equality". > > Second, "behave the same" means that for all functions, the result it > equal. > That's a recursive definition. You need fixed-point theory to turn > that > statement into an actual definition. > And that's surprisingly tricky. > > One fixed point is to say "the largest set of equal objects", which > means everything is equal to everything - fits the above definition > (applying any function to anything will trivially return results > that > are equal under this definition), but is obviously not what we > wanted. > > Another one would be to have what we'd intuitively define as > equality. > Say, in Haskell, the minimum set of equalities that makes different > constructor calls unequal. (Plus a handful of clerical definitions > to > catch special cases like integers.) > > Another one would be to have what we'd intuitively define as > identity. > > Plus various other fixed points. > > For example, consider proxies - say, an object that talks to a > remote > machine to produce its function results. > Now if you assume a proxy for integer values, is the proxy equal to > an > arbitrary integer you may have locally? > Again, this depends on what fixed point you choose for your equality > definition. You can define that as an exception, you consider two > objects equal if their functions return equal results, except for > those > that inspect the proxy-specific state; then proxy and local value > are > equal. Or you don't make an exception, then the two are not equal. > From a mathematical standpoint, either fixed point will satisfy the > above recursive definition (definition template, if you will). From > a > computing standpoint, you'll find that depending on context, you > want > one or the other! > > There are different types of proxy objects, and you can have > different > kinds of equality depending on how you treat them. > > That multitude of equality functions is pretty useless in a > programming > context; nobody wants to mentally deal with a gazillion of subtly > different equalities! > So I belive what one should do in practice is to have converter > functions. E.g. one that turns an Int proxy into an Int, merely by > stripping the proxy-specific functions. > That keeps the special cases to the place where they belong - all > those > types that have funky special kinds of equality. > Mutable data is another case of this. The equality of a mutable > object > can be defined as identity, and a converter function returns an > immutable copy so that equality is what's usually considered "value > equality" (equals() in Java). > (Languages that do not cleanly separate mutable and immutable types > will > still have to deal with two equalities, value equality and > identity... > well, the above is type and language design theory, practical > languages > are always a set of trade-offs, restricted by the limited knowledge > and > experience of the language designer. I guess that's why we have so > many > programming languages.) > I find it easier to intuitively define what extensional inequality means: As a domain theorist I declare two values unequal if there is an open set (a semi-decidable property) containing one but not the other value. For pure types t (not involving IO) that means there is a function semidecide :: t -> () that returns () for the one value and bottom for the other. I can not say how this would extend to impure types and I tend to agree with you that the notion of equality then depends on the intended semantics. Below the semidecision would have type t -> I0 () However, using StableName (thanks, Zemyla and Viktor!) indeed one is able to detect sharing. It works only after forcing the values, though. Apparently StableName does not work on thunks. Olaf ghci> import System.Mem.StableName ghci> import Control.Applicative ghci> data Ex = Val Int | Add Ex Ex deriving (Show) ghci> a = Add (Val 1) (Val 1) ghci> b = let v = Val 1 in Add v v ghci> show a "Add (Val 1) (Val 1)" ghci> show b "Add (Val 1) (Val 1)" ghci> let f :: Ex -> IO Bool; f (Val _) = return False; f (Add x y) = liftA2 eqStableName (makeStableName x) (makeStableName y) ghci> f a False ghci> f b True

1 0

Re: [Haskell-cafe] Test on identity?
by Johannes Waldmann 10 Jul '20

10 Jul '20

> Stable names are great! ... > I think they’re also used in eds ersatz package sortah. Yes. This is the package https://hackage.haskell.org/package/ersatz This is where they are used https://github.com/ekmett/ersatz/blob/master/src/Ersatz/Problem.hs#L149 - J.W.

1 0

Re: [Haskell-cafe] Test on identity?
by Olaf Klinke 10 Jul '20

10 Jul '20

Joachim Durchholz wrote: > This "identity is equality under change" definition captures not > just > two objects at identical addresses, but also proxies, network > objects, > files, and whatever there is. > > Step 3: Realize that if you have an immutable object, there is no > relevant difference between equality and identity anymore. (You can > make > various formal statements about this.) Is that what is called "extensional equality"? Values a,b :: A are extensionally equal if they behave the same in all contexts. That is, there is no type X and no function f :: A -> X such that f a can be observed to be different from f b, e.g. f a throws an exception and f b does not, or X is in Eq and f a /= f b. Can one write a function (even using reallyUnsafePtrEquality#) that distinguishes the following? a = Add (Val 1) (Val 1) b = let v = Val 1 in Add v v I tried: import GHC.Exts peq :: a -> a -> Bool peq x y = I# (reallyUnsafePtrEquality# x y) == 1 f :: Ex -> Bool f (Val _) = False f (Add x y) = peq x y But I get (even when I make the fields of Add strict): peq a a == True f a == False f b == False Olaf

5 4