September 2019 - Haskell-Cafe

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

[ANN] lzlib bindings in Haskell
by Vanessa McHale 15 Sep '19

15 Sep '19

Hi all, I have released a library containing a high-level API for lzlib (and bindings to the full lzlib), viz. http://hackage.haskell.org/package/lzlib Cheers, Vanessa McHale

1 0

parallele tolistM of the pipes module
by PICCA Frederic-Emmanuel 12 Sep '19

12 Sep '19

Hello, I would like to know how to write a parallele version of the pipes function: toListM :: Monad m => Producer a m () -> m [a] toListM = fold step begin done where step x a = x . (a:) begin = id done x = x [] {-# INLINABLE toListM #-} I want to extract all the a from th epipes but concurrently. is it possible ? Cheers Frederic

1 0

[POPL2020] Call for student volunteers
by Hanneli Tavante 11 Sep '19

11 Sep '19

Hello! The call for Student Volunteers at POPL2020 is opened until October 17th! The 2020 edition will be in New Orleans, USA, January19th-25th. More information here: https://popl20.sigplan.org/attending/students We encourage all the students to apply - with or without experience, local and non-local, undergrads and graduate students.

1 0

Taking over regex-base on Hackage
by Troels Henriksen 10 Sep '19

10 Sep '19

regex-base is at the bottom of the regex-* package hierarchy and has remarkably remained unchanged and working since the last release in 2010. Alas, the MonadFail change in GHC 8.8 breaks it and the maintainer, Christopher Kuklewicz, seems to have been absent for a while. Most of his other packages have long since been taken over by others. I would like to take over regex-base in order to patch it to work with GHC 8.8. -- \ Troels /\ Henriksen

2 1

Concurrent reads, ordered writes?
by amindfv＠gmail.com 09 Sep '19

09 Sep '19

I've implemented a solution for this problem, but it seems a bit less clean than it could be, which leaves me wondering if there's a data structure or algorithm specifically for this purpose: We've got multiple concurrent thereads reading items from a (TBQueue A), calling f :: A -> B, and writing to a (TBQueue B). We must, though, write items into the (TBQueue B) in the order that the corresponding As were read (the order they were put in the (TBQueue A)). Are there existing libraries which solve this or a similar problem? Ideally with niceties like configuring whether the pending out-of-order writes block the worker threads, and a way of signalling there's no more work to perform. Thanks! Tom

3 3