August 2019 - Haskell-Cafe

[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

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

06 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