- Haskell-Cafe - Haskell.org

Unfolding alongside folding
by David Feuer 19 Aug '19

19 Aug '19

Thinking about fusing indexed maps for lists led me to consider the following function, which generalizes mapWithIndex to allow arbitrary stateful computation foldWithUnfold :: (a -> s -> Maybe (b, s)) -> [a] -> s -> [b] foldWithUnfold f = go where go (a : as) s | Just (b, s') <- f a s = b : go as s' go _ _ = [] which we can fit into fold/build fusion like so: foldWithUnfold f as s0 = build $ \c n -> let go a k s | Just (b, s') <- f a s = b `c` k s' | otherwise = n in foldr go (const n) as s0 Does a function of this general nature exist in some package already? Also, I see that the type can be expressed foldWithUnfoldS :: (a -> StateT s Maybe b) -> [a] -> s -> [b] Is that a better or worse way to say it?

1 0

MPC 2019 - Call for Participation
by Graham Hutton 19 Aug '19

19 Aug '19

Dear all, Registration is now open 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 ====================================================================== *** 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] express-0.1.2: manipulate dynamically typed Haskell expressions
by Rudy Matela 18 Aug '19

18 Aug '19

Hello Haskell-Café, I am happy to announce the [Express] library for Haskell. https://github.com/rudymatela/express Express allows manipulation of dynamically typed Haskell expressions. It is similar to Data.Dynamic but with support for encoding applications and variables. It provides an Expr type and over a hundred functions for building, evaluating, comparing, folding, canonicalizing and matching Exprs. [Express' Haddock documentation] is pretty comprehensive. The project [README] has a few examples showing how to use Express to: * create heterogeneous lists; * list valid applications between expressions; * generalize counterexamples; * automatically generate test properties. This library has its origins as an internal module of [Speculate] and [Extrapolate], I am now releasing it separetely hoping that it could be used for other purposes. To install it, just: $ cabal update $ cabal install express Then you're ready to use it: $ ghci > import Data.Express > let true = val True > :t true true :: Expr > print true True :: Bool > eval False true True -- Rudy [Express]: https://github.com/rudymatela/express [Express' Haddock documentation]: https://hackage.haskell.org/package/express/docs/Data-Express.html [README]: https://github.com/rudymatela/express#readme [Speculate]: https://github.com/rudymatela/speculate [Extrapolate]: https://github.com/rudymatela/extrapolate

1 0

PhD position at Imperial College London
by Wu, Nicolas G 16 Aug '19

16 Aug '19

# PhD Position in Functional Programming: Effect Handlers at Imperial College London Applications are invited for a PhD student in Functional Programming under the supervision of Dr Nicolas Wu at Imperial College London. The project aims to enhance the applications of effects and handlers by developing scoped contextual operations and effects. There are two main interrelated topics: 1. Developing the foundations of operations and effects that are confined within a scope and that are sensitive to context, thus widening the applications of effect handlers. 2. Producing efficient implementations and demonstrating applications that allow programmers to combine and use such effects. Addressing these topics will deliver both theoretical insight to the academic community and practical benefits to software engineers. To apply for this position, you will need to have a strong background in at least one of the following areas: functional programming, programming language design, compilers, algebraic effects. A working understanding of Haskell is essential. Applicants are expected to have a First Class or Distinction Masters level degree, or equivalent, in a relevant scientific or technical discipline, such as computer science or mathematics. Applicants must be fluent in spoken and written English. The position is fully funded, covering tuition fees, travel funds and a stipend/bursary. The position is available to home, EU and overseas students. Studentship: Untaxed bursary of £17,009 per annum (2018/19 figure including London weighting plus home/EU fees) For more details on how to apply, please see the advertisement here: http://www.imperial.ac.uk/computing/prospective-students/courses/phd/schola… listed under "PhD Position in Functional Programming: Effect Handlers". Early applications are strongly encouraged. Please be in touch with informal inquiries about the position with Dr Nicolas Wu (n.wu(a)imperial.ac.uk)

1 0

[TFP'20] first call for papers: Trends in Functional Programming 2020, 13-14 February, Krakow, Poland
by Peter Achten 15 Aug '19

15 Aug '19

------------------------------------------------------------------------- First call for papers 21st Symposium on Trends in Functional Programming tfp2020.org ------------------------------------------------------------------------- The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. * TFP is moving to new winter dates, to provide an FP forum in between the annual ICFP events. * TFP offers a supportive reviewing process designed to help less experienced authors succeed, with two rounds of review, both before and after the symposium itself. Authors have an opportunity to address reviewers' concerns before final decisions on publication in the proceedings. * TFP offers two "best paper" awards, the John McCarthy award for best paper, and the David Turner award for best student paper. * This year we are particularly excited to co-locate with Lambda Days in beautiful Krakow. Lambda Days is a vibrant developer conference with hundreds of attendees and a lively programme of talks on functional programming in practice. TFP will be held in the same venue, and participants will be able to session-hop between the two events. Important Dates --------------- Submission deadline for pre-symposium review: 15th November, 2019 Submission deadline for draft papers: 10th January, 2020 Symposium dates: 13-14th February, 2020 Visit tfp2020.org for more information.

1 0

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ář 07 Aug '19

07 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