- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Explicitly calling syntactic equality on datatypes
by Olaf Klinke 18 Sep '19

18 Sep '19

IMHO Tom's suggestion is the way to go, because: (1) The normalized values form a sub-set of the general ones. If you have just one data type for both, then you'll have no static guarantee of normalization, and this will lead to mistakes once you fail to track the normalize calls. (2) Since the normalized values are a sub-set, coercing a normalized value back into the super-type is cheap. (3) Two distinct types guarantee that you won't do the same work twice. Your proposal of (==) `on` normalize will re-calculate the normalization every time you call (==), if no memoization happens. (4) The existing machinery of the compiler suffices to do what you want. If you consider the two forms semantically equal then maybe the non-normalized form should be represented as a thunk. Isn't that what the ShowS type is about? Just my 2 cents. Olaf

2 1

Explicitly calling syntactic equality on datatypes
by Juan Casanova 18 Sep '19

18 Sep '19

Hello, Pretty simple question here really. I think I've searched for it several times in the past and ended up surprised I did not find an answer. Simple example: sum expressions. One way to define this, one that is comfortable to construct new sums, would be: data Sum = Value Int | Sum Sum Sum Another one, one that is comfortable to check equality with (and other similar things that rely on some notion of normal form), would be (essentially non-empty lists of ints): data Sum = Value Int | Sum Int Sum Now, in many cases you really want to go with the first one for several reasons. You just do not care about normalization in most cases, or maybe you do something more abstract and complicated on top of it that delays the possibility or the sensibility of normalization until something else happens later. So say, that I have the first definition. But then, I want to define equality semantically. An obvious way to go is to produce a function that normalizes Sums (from the first definition) to guarantee that the first sub-sum is always going to be a value, and then check that these two are "equal". And this is where my question comes in, because, of course, the following is infinite recursion: instance Eq Sum where a == b = (normalize a) == (normalize b) What I'd like is to be able to override the default implementation of Eq, but be able to *explicitly* call syntactic equality in calculating it, so that I can do: instance Eq Sum where a == b = (syntacticEq (normalize a) (normalize b)) So, I can see how this is not as straightforward as a function. You cannot correctly produce a polymorphic function syntacticEq :: a -> a -> Bool that works on the SYNTAX of a because it is hidden inside the polymorphic function. What (deriving Eq) does (as I understand it) is to produce an instance at compilation time by looking at how the specific type is presented. But that same compilation time producing could be done to produce it as a function instead of as an implementation of Eq, so that syntacticEq would not be an actual function, but some sort of "macro" that, on compile time, creates the default implementation of equality, but instead of defining it as (==) it defines it as a new function that is only used there. Of course, I can just implement syntactic equality myself explicitly, but when I have to do this for 3, 4, 7 types, some of which have many cases, and a lot of these are polymorphic, so that I have to put all the (Eq arg1, Eq arg2, Eq arg3, ...) => constraints before all of them, it gets old quick. So, is there something like this? Am I saying something really dumb? Of course, I am thinking about equality here, but the same could be said for any standard derivation of classes, like Functor, Show, etc. ALL of them sound like I've wanted to do them at some point in the past. Thanks, Juan. -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

4 8

Practical Aspects of Declarative Languages PADL2020: 2nd CFP
by Ekaterina Komendantskaya 18 Sep '19

18 Sep '19

22nd International Symposium on Practical Aspects of Declarative Languages (PADL 2020) <https://popl20.sigplan.org/home/PADL-2020#22nd-international-symposium-on-p…> <https://popl20.sigplan.org/home/PADL-2020#httpspopl20sigplanorghomepadl-2020> https://popl20.sigplan.org/home/PADL-2020,20-21 January 2020, New Orleans, Louisiana, United States <https://popl20.sigplan.org/home/PADL-2020#20-21-january-2020-new-orleans-lo…>Co-located with ACM POPL 2020 ( <https://popl20.sigplan.org/home/PADL-2020#co-located-with-acm-popl-2020-htt…> https://popl20.sigplan.org/) ------------------------------ *Declarative languages* is an umbrella term that include functional, logic, and constraint programming languages. These languages have been successfully applied to many different real-world situations, ranging from database management to active networks to software engineering to decision support systems. New developments in theory and implementation have opened up new application areas. At the same time, applications of declarative languages to challenging problems raise intriguing research questions, such as scalable design and implementation, language extensions for application deployment, and programming environments. PADL is a well-established forum for researchers and practitioners to present original work emphasizing novel applications and implementation techniques for all forms of declarative programming, including functional and logic programming, database and constraint programming, and theorem proving. Topics of interest include, but are not limited to: - Innovative applications of declarative languages - Declarative domain-specific languages and applications - Practical applications of theoretical results - New language developments and their impact on applications - Declarative languages for software engineering - Evaluation of implementation techniques on practical applications - Practical experiences and industrial applications - Novel uses of declarative languages in the classroom - Practical languages and extensions such as probabilistic and reactive languages *PADL 2020* especially welcomes new ideas and approaches pertaining to applications, design and implementation of declarative languages going beyond the scope of the past PADL symposia, for example, advanced database languages and contract languages, as well as verification and theorem proving methods that rely on declarative languages. Important Dates and Submission Guidelines: <https://popl20.sigplan.org/home/PADL-2020#important-dates-and-submission-gu…> - Abstracts due: 11 October 2019 - Papers due: 18 October 2019 - Notification to authors: 18 November 2019 - Camera-ready: 29 November 2020 - Symposium dates: 20 - 21 January 2020 Submission instructions can be found at: https://popl20.sigplan.org/home/PADL-2020#Call-for-Papers Looking forward to receiving your submission, PADL19 PC members: https://popl20.sigplan.org/home/PADL-2020#About

1 0

Re: [Haskell-cafe] Attach a finalizer to a FunPtr
by Roman Cheplyaka 17 Sep '19

17 Sep '19

On 17/09/2019 10.50, Shao Cheng wrote: > Hi Roman, > > mkWeak# 's "key" and "value" arguments must both be lifted types, see https://gitlab.haskell.org/ghc/ghc/blob/master/rts/PrimOps.cmm#L699. Your code directly passes the raw Addr# which is not a managed pointer, thus the segfault. Ah, that makes sense — thanks Cheng (and Matthew). I modeled my code after mkWeakIORef, and I assumed that MutVar# and Addr# were in the same category. > I recommend using ForeignPtr in this case. You can add finalizers to ForeignPtr properly, and coerce from ForeignPtr to FunPtr when using it, since they're both containing the Addr# under the hood. I considered doing that, but that'd require quite a bit of code to be constantly converting between ForeignPtr and FunPtr and also converting IO () finalizers to FunPtr (...) finalizers. System.Mem.Weak looks like a better fit because it uses IO () finalizers. I think I'll try attaching a finalizer to ForeignPtr itself and be careful to retain a pointer to ForeignPtr (perhaps with the help of a StablePtr) while it's in use. Or, if that doesn't work, I might implement a reference counter instead. Roman

3 2

[ANN] Call for Contributions: BOB 2020 [Feb 28, Deadline Nov 8]
by Stefan Wehr 17 Sep '19

17 Sep '19

BOB Conference 2020 "What happens when we use what's best for a change?" http://bobkonf.de/2020/cfc.html Berlin, February 28 Call for Contributions Deadline: November 8, 2019 You are actively engaged in advanced software engineering methods, implement ambitious architectures and are open to cutting-edge innovation? Attend this conference, meet people that share your goals, and get to know the best software tools and technologies available today. We strive to offer a day full of new experiences and impressions that you can use to immediately improve your daily life as a software developer. If you share our vision and want to contribute, submit a proposal for a talk or tutorial! NOTE: The conference fee will be waived for presenters. Travel expenses will not be covered (for exceptions see "Speaker Grants"). Speaker Grants BOB has Speaker Grants available to support speakers from groups under-represented in technology. We specifically seek women speakers and speakers who are not be able to attend the conference for financial reasons. Shepherding ----------- The program committee offers shepherding to all speakers. Shepherding provides speakers assistance with preparing their sessions, as well as a review of the talk slides. Topics ------ We are looking for talks about best-of-breed software technology, e.g.: - functional programming - persistent data structures and database - event-based modelling and architectures - types - formal methods for correctness and robustness - abstractions for concurrency and parallelism - metaprogramming - probabilistic programming - math and programming - controlled side effects - beyond REST and SOAP - effective abstractions for data analytics - ... everything really that isn’t mainstream, but you think should be. Presenters should provide the audience with information that is practically useful for software developers. We're especially interested in experience reports. Other topics are also relevant, e.g.: - introductory talks on technical background - overviews of a given field - demos and how-tos Requirements ------------- We accept proposals for presentations of 45 minutes (40 minutes talk + 5 minutes questions), as well as 90 minute tutorials for beginners. The language of presentation should be either English or German. Your proposal should include (in your presentation language of choice): - An abstract of max. 1500 characters. - A short bio/cv - Contact information (including at least email address) - A list of 3-5 concrete ideas of how your work can be applied in a developer's daily life - additional material (websites, blogs, slides, videos of past presentations, …) Submit here: https://bobcfc.active-group.de/en/bob2020/cfp Organisation ------------ - Direct questions to contact at bobkonf dot de - Proposal deadline: November 8, 2019 - Notification: November 22, 2019 - Program: December 6, 2019 Program Committee ----------------- (more information here: https://bobkonf.de/2020/programmkomitee.html) - Matthias Fischmann, Wire - Matthias Neubauer, SICK AG - Nicole Rauch, Softwareentwicklung und Entwicklungscoaching - Michael Sperber, Active Group - Stefan Wehr, factis research Scientific Advisory Board - Annette Bieniusa, TU Kaiserslautern - Torsten Grust, Uni Tübingen - Peter Thiemann, Uni Freiburg

1 0

Class of ordered tuples
by Olaf Klinke 17 Sep '19

17 Sep '19

Dear Cafe, I had a lengthy discussion with GHC but so far it won't let me do the following. (Code below is simplified to transport the idea. Type families don't seem to do the trick, either.) A finite set of types A, B, C, ... is totally ordered. This can be expressed e.g. by a multi-parameter type class and type-level natural numbers: instance Index A 0 where instance Index B 1 where etc. Now I want a type class Range and an appropriate set of instance declarations that has A, B, (A,B), (A,C), (A,(B,C)) etc. as members but not (B,A) or (C,C). That is, each type appears at most once and in the defined order. The problem is overlapping instances of the base case with the inductive case. instance Index a n => Range a n n instance (Range a x y, Range b x' y', y < x') => Range (a,b) x y' Then the compiler rightfully complains that someone could write an instance Index (a,b) n which would lead to conflicting instances of Range (a,b) n n. I can not make either of the type classes Index nor Range closed because there will be several of those sets of types. This problem is like smart constructors for ordered lists, but on the type level. Thanks in advance for any hints. Olaf

2 2

Attach a finalizer to a FunPtr
by Roman Cheplyaka 17 Sep '19

17 Sep '19

Hi all, I'd like to attach a finalizer to FunPtrs (which point to JIT-compiled functions that need to be deallocated). However, the act of running the finalizer (no matter what it does) results in a segfault. Here's a minimal example: {-# LANGUAGE UnboxedTuples, MagicHash #-} import GHC.Exts (FunPtr(..)) import GHC.Base import Foreign.Ptr import System.Mem attachFinalizer :: FunPtr a -> IO () -> IO () attachFinalizer fptr@(FunPtr addr) (IO fin) = IO $ \s0 -> case mkWeak# addr fptr fin s0 of (# s1, _ #) -> (# s1, () #) foreign import ccall "wrapper" mkIO :: IO () -> IO (FunPtr (IO ())) main = do fptr <- mkIO $ return () attachFinalizer fptr $ do -- The exact contents of the finalizer doesn't seem to matter putStrLn "+++ finalizer ran" freeHaskellFunPtr fptr putStrLn "+++ attached successfully" performGC Is there a proper way to do this? (GHC 8.6.5) Roman

3 2

Fusion & Laziness
by Hilco Wijbenga 17 Sep '19

17 Sep '19

Hi all, I'd like to have a better understanding of fusion and (maybe?) laziness. Let's say I have an (exported) type "data EndResult = ... !(Vector Thing) ..." and an intermediate, unexported type "data IntermediateResult = ... !(Vector Thing) ...". (I suppose it doesn't need to be Vector, it could be Set, or some other data structure that (I imagine) is relatively expensive to map over, unlike, say [].) [To start off, I want to state my, possibly incorrect, understanding of fusion and how it does not (in my expectation) apply to Vector, Set, et cetera. A List can essentially disappear as it's replaced by a loop but a Vector would not: the executing code would create and garbage collect multiple intermediate Vectors before finally returning the end result.] Assume that I need my algorithm to go from initial input to IntermediateResult to subsequent IntermediateResult (a few times) to EndResult. In my case, each subsequent IntermediateResult is a bit smaller than the previous one but that's probably irrelevant. Should I prefer IntermediateResult to be lazy? Should I use [] instead of Vector in the IntermediateResult? What about the functions that actually operate on IntermediateResult, should I prefer to use [] or Vector there? I'm currently able to use Data.Vector.concatMap in some places, is that just as optimized? I realize that the correct answer more than likely is "don't worry about it". And that I'm being very vague. :-) I'm not looking for anything definitive, I'm just hoping to improve my understanding and intuition. What should I consider when thinking about these types of things? If I don't want to create two separate implementations and profile them, are there "obvious" signs one way or another? Cheers, Hilco

3 2

Default "type" in type class
by Hilco Wijbenga 16 Sep '19

16 Sep '19

Hi all, I'm trying to create a "HasToList" type class. It starts off really simple: class HasToList collection where toList ∷ collection element → [element] instance HasToList Set where toList = Data.Set.toList Unfortunately, this breaks down with Data.EnumSet.EnumSet. So instance HasToList EnumSet where toList = Data.EnumSet.toList doesn't compile and I could not find a way to add "Enum a =>" to either the instance or "toList". (Well, not without making the compiler upset.) With the aid of ConstraintKinds and TypeFamilies (and not much understanding on my end, obviously) I created class HasToList collection where type Requirement collection element :: Constraint toList ∷ Requirement collection element => collection element → [element] instance HasToList Set where type Requirement Set a = () toList = Data.Set.toList instance HasToList EnumSet where type Requirement EnumSet a = Enum a toList = Data.EnumSet.toList This works but now I have to add the constraint to every instance even though only a tiny minority actually need it. Is there a way to add a default "type implementation"? I tried the obvious type Requirement collection element :: Constraint = () and type Requirement collection element :: Constraint type Requirement collection element :: Constraint = () but neither compiles. Another problem is that the compiler can't compile something like this: isteps ∷ HasToList collection ⇒ collection String → [(Int, String)] isteps steps = Data.List.Index.indexed (toList steps) because it doesn't know which constraint to apply ("Could not deduce: Requirement hasToList String"). That seems fair but also irrelevant at this point. I feel like this is all far too complicated for what I'm trying to accomplish. :-) While I would like to have an answer to the questions above, I guess what I really want is a simpler way to implement HasToList. Cheers, Hilco

2 2

MPC 2019 - final call for participation
by Graham Hutton 16 Sep '19

16 Sep '19

Dear all, Final call for participation for the Mathematics of Program Construction (MPC) conference in Portugal. MPC 2019 will feature 15 research papers and 4 keynotes, and is co-located with Formal Methods 2019 and many other events. See you in Porto! https://tinyurl.com/MPC-Porto Best wishes, Graham Hutton Program Chair, MPC 2019 ====================================================================== *** FINAL CALL FOR PARTICIPATION -- MPC 2019 *** 13th International Conference on Mathematics of Program Construction 7-9 October 2019, Porto, Portugal Co-located with Formal Methods 2019 https://tinyurl.com/MPC-Porto ====================================================================== PROGRAM: https://tinyurl.com/yxvvc5vb ACCEPTED PAPERS: https://tinyurl.com/yyuhy8ze REGISTRATION AND TRAVEL: https://tinyurl.com/y4uetlsr KEYNOTE SPEAKERS: Assia Mahboubi (MPC) INRIA, France Annabelle McIver (MPC) Macquarie University, Australia Tony Hoare (UTP) Oxford University, UK Shriram Krishnamurthi (FM) Brown University, USA BACKGROUND: The International Conference on Mathematics of Program Construction (MPC) aims to promote the development of mathematical principles and techniques that are demonstrably practical and effective in the process of constructing computer programs. MPC 2019 will be held in Porto, Portugal from 7-9 October 2019, and is co-located with the International Symposium on Formal Methods, FM 2019. Previous conferences were held in Königswinter, Germany (2015); Madrid, Spain (2012); Québec City, Canada (2010); Marseille, France (2008); Kuressaare, Estonia (2006); Stirling, UK (2004); Dagstuhl, Germany (2002); Ponte de Lima, Portugal (2000); Marstrand, Sweden (1998); Kloster Irsee, Germany (1995); Oxford, UK (1992); Twente, The Netherlands (1989). PROGRAM COMMITTEE: Patrick Bahr IT University of Copenhagen, Denmark Richard Bird University of Oxford, UK Corina Cîrstea University of Southampton, UK Brijesh Dongol University of Surrey, UK João F. Ferreira University of Lisbon, Portugal Jennifer Hackett University of Nottingham, UK William Harrison University of Missouri, USA Ralf Hinze University of Kaiserslautern, Germany Zhenjiang Hu National Institute of Informatics, Japan Graham Hutton (chair) University of Nottingham, UK Cezar Ionescu University of Oxford, UK Mauro Jaskelioff National University of Rosario, Argentina Ranjit Jhala University of California, USA Gabriele Keller Utrecht University, The Netherlands Ekaterina Komendantskaya Heriot-Watt University, UK Chris Martens North Carolina State University, USA Bernhard Möller University of Augsburg, Germany Shin-Cheng Mu Academia Sinica, Taiwan Mary Sheeran Chalmers University of Technology, Sweden Alexandra Silva University College London, UK Georg Struth University of Sheffield, UK For any queries about the program please contact the program chair, Graham Hutton <graham.hutton(a)nottingham.ac.uk>. CONFERENCE VENUE: The conference will be held at the Alfândega Porto Congress Centre, a 150 year old former custom's house located in the historic centre of Porto on the bank of the river Douro. The venue was renovated by a Pritzer prize winning architect and has received many awards. LOCAL ORGANISER: José Nuno Oliveira University of Minho, Portugal For any queries about local issues please contact the local organiser, José Nuno Oliveira <jno(a)di.uminho.pt>. ====================================================================== This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law.

1 0