- Haskell-Cafe - Haskell.org

Research Associate at Kent in Trustworthy Refactoring
by Simon Thompson 12 Aug '19

12 Aug '19

We are seeking to recruit an enthusiastic Research Associate to join the final year of the EPSRC project “Trustworthy Refactoring”. The overall goal of this project is to investigate the design and construction of trustworthy refactoring tools: this means that when refactorings are performed, the tools will provide strong evidence that the refactoring has not changed the behaviour of the code, built on a solid theoretical understanding of the semantics of the language, thus establishing a step change in the practice of refactoring. If you have have a PhD in Computer Science, awarded or nearing completion, experience in functional programming (e.g. Haskell/ML/Erlang/…) and experience of using a proof assistant (e.g. Coq/Isabelle/HOL/…), you have what we’re looking for. More details about the project are here: https://jobs.kent.ac.uk/vacancy.aspx?ref=STM-047-19 If you have any questions about the post do contact one of us by email: Scott Owens (s.a.owens(a)kent.ac.uk) and Simon Thompson (s.j.thompson(a)kent.ac.uk) : we look forward to hearing from you. Scott and Simon Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

PADL 2020 (co-allocated with POPL 2020): first call for papers
by Ekaterina Komendantskaya 12 Aug '19

12 Aug '19

22nd International Symposium on Practical Aspects of Declarative Languages (PADL 2020)https://popl20.sigplan.org/home/PADL-2020,20-21 January 2019, New Orleans, Louisiana, United StatesCo-located with ACM POPL 2020 ( https://popl20.sigplan.org/) ------------------------------ *Declarative programming languages* is an umbrella term for functional, logic, answer-set and constraint-solving programming paradigms, as well as a range of verification and theorem proving methods that rely on such languages. These languages have been successfully applied to many different real-world situations, ranging from data base management and active networks to software engineering and 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 new intriguing research questions, such as scalable design and implementation, language extensions for application deployment, and programming environments. Thus, applications drive the progress in the theory and implementation of declarative systems, and benefit from this progress as well. PADL is a well-established forum for researchers and practitioners to present original work emphasising novel applications and implementation techniques for all forms of declarative programming, including functional and logic programming, data-base and constraint programming, 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 database languages and contract languages.* Important Dates and Submission Guidelines: - Abstracts due: 11 October 2019 - Papers due: 18 October 2019 - Notification to authors: 18 November 2019 - Camera-ready: 29 November 2020 Authors should submit an electronic copy of the full paper in PDF using the Springer LNCS format. The submission will be done through EasyChair conference system: https://easychair.org/conferences/?conf=padl2020 All submissions must be original work written in English. Submissions must be unpublished and not submitted for publication elsewhere. Work that already appeared in unpublished or informally published workshops proceedings may be submitted but the authors should notify the program chair about the place on which it has previously appeared. PADL 2020 will accept both technical and application papers: *Technical papers* must describe original, previously unpublished research results. Technical papers must not exceed 15 pages (plus one page of references) in Springer LNCS format. *Application papers* are a mechanism to present important practical applications of declarative languages that occur in industry or in areas of research other than Computer Science. Application papers are expected to describe complex and/or real-world applications that rely on an innovative use of declarative languages. Application descriptions, engineering solutions and real-world experiences (both positive and negative) are solicited. The limit for application papers is 8 pages in Springer LNCS format but such papers can also point to sites with supplemental information about the application or the system that they describe. *The proceedings of PADL 2020 will appear in the LNCS series of Springer Verlag: https://www.springer.com/gp/computer-science/lncs <https://www.springer.com/gp/computer-science/lncs>.* ************************************************************* For further questions, please contact the conference chairs: Ekaterina Komendantskaya <ek19(a)hw.ac.uk> and Annie Liu <liu(a)cs.stonybrook.edu >

1 0

Unifying an IO read into a TChan?
by Adam 09 Aug '19

09 Aug '19

Hello Café! It's my first post here so do tell me if I get something wrong :) I'm in the process of writing an event database; it should adhere to ACID principles and is specifically aimed at persisting then broadcasting events in some event-driven system. The code is up on GitHub and I expect to build a Hackage package soon, for now I'm prototyping with Stack generating the .cabal file, but this will change when things settle down. My question is about a function I have: readEvents :: Word64 -> Connection -> IO ([IndexedEvent], TChan IndexedEvent) readEvents from conn = do (ec, chan) <- atomically $ (,) <$> (readTVar $ evCount conn) <*> (dupTChan $ readSubs conn) evsFromDisk <- readEventsRange from ec conn pure (evsFromDisk, chan) For context please see the whole file: https://github.com/ahri/eventdb/blob/4747afb/src/Database/EventDB.hs#L172-L… 1. What I'd like to understand is how I might unify the return type into a single `TChan IndexedEvent` which would contain first the `evsFromDisk` and then pull from the broadcast channel `chan`. The only way I can think to do it is to fork a thread to write to a new broadcast channel - which might be unexpected for a client of my API and seems quite heavyweight. I have a connected couple of questions too, related to lazy IO as I'm still learning Haskell! 2. does my `readEventsRange` function pull all events into memory or does lazy IO magically avoid this by streaming the data through from the disk? 3. if I did fork a thread and write the `evsFromDisk` and the sit in a ` forever` reading off `chan` and onto my new broadcast channel, would this result in all the written events being read into memory or does the laziness spread so that only when the client does a `readTChan` will the data flow through from the disk/`chan`? Thanks for reading, Adam

1 0

Ambiguous types
by Dušan Kolář 08 Aug '19

08 Aug '19

Dear Café, I'm trying to solve a couple of examples and exercises just for me. I've come to the point, when I'm trying working code manipulating lists rewrite to work on Foldable (etc.). Nevertheless, I must be doing some mistake, overlooking something, as simple code like this: chkDup [] = False chkDup (0:ns) = chkDup ns chkDup (n:ns) = elem n ns || chkDup ns which works fine, type-checks, can be used within other code, I'm trying to replace with more generic, but probably less efficient and wrong code: chkDup ns = fst $ foldr f (False,mempty) ns where f _ res@(True,_) = res f v res@(_,vs) = if v==0 then (False, vs) else (elem v vs, pure v <> vs) which does not even type-check. Nevertheless, the error message is not too helpful, searching the Internet just confirms it's wrong and that adding AllowAmbiguousTypes would not work. The error message is: helper.hs:49:1: error: • Could not deduce (Foldable f0) from the context: (Eq a, Num a, Foldable t, Foldable f, Applicative f, Monoid (f a)) bound by the inferred type for ‘chkDup’: forall a (t :: * -> *) (f :: * -> *). (Eq a, Num a, Foldable t, Foldable f, Applicative f, Monoid (f a)) => t a -> Bool at helper.hs:(49,1)-(53,80) The type variable ‘f0’ is ambiguous • In the ambiguity check for the inferred type for ‘chkDup’ To defer the ambiguity check to use sites, enable AllowAmbiguousTypes When checking the inferred type chkDup :: forall a (t :: * -> *) (f :: * -> *). (Eq a, Num a, Foldable t, Foldable f, Applicative f, Monoid (f a)) => t a -> Bool | 49 | chkDup ns = | ^^^^^^^^^^^... So is there a nicer and working way, how to change my simple example? Is there a way, how to make it compile? Or is it useless to do that, original function is just fine... Best regards, Dušan

6 11

Evaluating an AST with GADTs (and Type Families?)
by Hilco Wijbenga 07 Aug '19

07 Aug '19

Hi all, I'm trying to implement an evaluator with GADTs. This is about as far as I've gotten: https://pastebin.com/XjWBzgw7 . data Value = ValueBool Bool | ValueText String | ValueObject (Map String Value) data Expr t where ExprBool :: Bool -> Expr Bool ExprBoolOr :: Expr Bool -> Expr Bool -> Expr Bool ExprText :: String -> Expr String ExprTextAppend :: Expr String -> Expr String -> Expr String ExprObject :: Map String Value -> String -> Expr Value eval :: Expr t -> t eval (ExprBool value) = value eval (ExprBoolOr lft rgt) = eval lft || eval rgt eval (ExprText value) = value eval (ExprTextAppend lft rgt) = eval lft <> eval rgt eval (ExprObject map fieldName) = map ! fieldName Note that the Value data type was just an attempt and not (necessarily) what I'm looking for. And I'm ignoring all error handling for the moment to keep the example small. This compiles but obviously the object type is completely separate from the Expr Bool and Expr String types. Apparently, Type Familiies might help here? I could not find anything relevant that really explained it. I've been thinking about changing ExprObject to something like ExprObjectBool :: Map String Value -> String -> Expr Bool ExprObjectString :: Map String Value -> String -> Expr String ExprObjectObject :: Map String Value -> String -> Expr ??? but I can't figure out what ??? would be. And this would seem to explode if I add more "primitive" types, especially if I want to support lists and maps as well. (Maps and objects are very similar but not the same.) How would I go about making the object type useful here? Or should I go back to plain "Expr" and just error out when trying to, e.g., "or" 2 Strings? Cheers, Hilco

2 1

cabal: Could not resolve dependencies
by Henk-Jan van Tuyl 07 Aug '19

07 Aug '19

L.S., I am trying to compile wxHaskell with GHC 8.8.0.20190721 and I get the following messages from cabal-install: > cabal new-build all --disable-documentation Resolving dependencies... cabal: Could not resolve dependencies: [__0] trying: samplesContrib-0.93.0.0 (user goal) [__1] trying: base-4.13.0.0/installed-4.1... (dependency of samplesContrib) [__2] trying: wxcore-0.93.0.0 (user goal) [__3] next goal: wxcore:setup.Cabal (dependency of wxcore) [__3] rejecting: wxcore:setup.Cabal-3.0.0.0/installed-3.0... (constraint from maximum version of Cabal used by Setup.hs requires <2.6 [...] What does this mean, how do I solve it? (There is a Setup.hs in package wxcore, but does it have its own Cabal file?) > cabal --version cabal-install version 2.4.1.0 compiled using version 2.4.1.0 of the Cabal library Regards, Henk-Jan van Tuyl -- Message from Stanford University: Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://foldingathome.stanford.edu/ -- http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

2 1

instance Monoid a => Monad ((,) a)
by Benjamin Franksen 06 Aug '19

06 Aug '19

I wanted to define a simple Monad instance for (Bool,) as instance Monad ((,) Bool) where return x = (False, x) (True, x) >>= k = (True, snd (k x)) (False, x) >>= k = k x -- or: (b, x) >>= k = let (c, y) = k x in (b||c, y) The idea was to keep track of whether functions change their input value or not. To my astonishment I found that this definition overlaps with an existing one. GHC tells me x.hs:2:10: error: • No instance for (Monoid Bool) arising from the superclasses of an instance declaration • In the instance declaration for ‘Monad ((,) Bool)’ | 2 | instance Monad ((,) Bool) where | ^^^^^^^^^^^^^^^^ x.hs:2:10: error: • Overlapping instances for Monad ((,) Bool) arising from a use of ‘GHC.Base.$dm>>’ Matching instances: instance Monoid a => Monad ((,) a) -- Defined in ‘GHC.Base’ instance Monad ((,) Bool) -- Defined at x.hs:2:10 • In the expression: GHC.Base.$dm>> @((,) Bool) In an equation for ‘>>’: (>>) = GHC.Base.$dm>> @((,) Bool) In the instance declaration for ‘Monad ((,) Bool)’ | 2 | instance Monad ((,) Bool) where | ^^^^^^^^^^^^^^^^ [one more similar overlap error elided] But I could not find the instance Monoid a => Monad ((,) a) documented anywhere in the base package. Should I look harder? Or is this instance accidentally leaking from GHC.Base? Eventually, through some experimenting I found that if I replace Bool with Any, then the existing instance seems to do what I want. Cheers Ben

7 7

Performance best practices
by Todd Wilson 04 Aug '19

04 Aug '19

Dear Cafe: I'm getting to the point in my Haskell learning curve where I'm getting more interested in the fine points of programming for performance and would be grateful for some ideas of the tools and options available for exploring this. To make this concrete, let me give a simple example. Here are two different ways of coding the same list-splitting function: import Data.List (inits,tails) splits1, splits2 :: [a] -> [([a],[a])] splits1 xs = zip (inits xs) (tails xs) splits2 [] = [([],[])] splits2 xs@(x:xs') = ([],xs) : [(x:as,bs) | (as,bs) <- splits2 xs'] For example, splits1 [1,2,3] is [([],[1,2,3]),([1],[2,3]),([1,2],[3]),([1,2,3],[])]. How do these functions compare in their actual time and space usage? It seems that, asymptotically, tails is O(n) while inits is O(n^2) in both time and space (when fully evaluated), and splits2 is also O(n^2), but how would I go about comparing them in actual usage to get a more precise comparison? What profiling or run-time statistics could I gather to make a decision about which one to use in a situation where performance mattered (assuming for the sake of discussion that such a situation existed for this simple example)? And, out of curiosity, is there an even more efficient way to code this function? Thanks, Todd Wilson

4 7

ANN: To Kata Haskellen Evangelion
by Cosmia Fu 03 Aug '19

03 Aug '19

Hi everyone, Though some of you might already knows, I'm pleased to announce a new Haskell book, *To Kata Haskellen Evangelion*. Link: https://cosmius.bitbucket.io/tkhe/ I believe that it does not have to be hard to learn Haskell. I begun to write the book in 2017 December, and... to be honest, I don't know what to write now, though I still think it incomplete. It will probably not be updated for quite a while. So I decide to announce it earlier. I am not a native English speaker, so it might be not fluent or even with a lot of grammar mistakes. It would be very nice of you if you can tell me the mistakes in it, factual, technical or grammar. And also feel free to tell me if you want to read some topic in it. Thank you ---- Cosmia Fu

4 4

Request for Comments
by ibrahim Sagiroglu 01 Aug '19

01 Aug '19

Hello all, I have an attempt to present llvm assembly in [1]. Would you consider taking some time to comment on it? [1] https://github.com/ibrahimsag/rw

2 3