- Haskell-Cafe - Haskell.org

creating dll fails: missing references
by Kees Bleijenberg 11 Jun '19

11 Jun '19

HI all, I try to create a dll with ghc (ver 8.6.5) on Windows 7 64 bits. I 'am using the dll with loadLibrary in a cpp program in Visual Studio. I create the dll with: ghc Vogels.hs ghc -c StartEnd.c ghc --make -static -shared -fPIC Vogels.o StartEnd.o -o Vogels.dll StartEnd.o defines HsStart and HsEnd to initialize and close the Haskell runtime. This works. I can create the dll and use the dll in VS. But, if I replace in Vogels.hs the line b=True with b <- doesFileExist vogelsFn, creating the dll fails with error message: Vogels.o:fake:(.text+0x35c): undefined reference to `directoryzm1zi3zi3zi2zmB9tglvOQ6L9Cf7zzVEJ1S6t_SystemziDirectory_doesFileEx ist_closure' Vogels.o:fake:(.text+0x37d): undefined reference to `directoryzm1zi3zi3zi2zmB9tglvOQ6L9Cf7zzVEJ1S6t_SystemziDirectory_doesFileEx ist_closure' Vogels.o:fake:(.data+0xd0): undefined reference to `directoryzm1zi3zi3zi2zmB9tglvOQ6L9Cf7zzVEJ1S6t_SystemziDirectory_doesFileEx ist_closure' It looks like GHC can't find the Directory package. I've installed this package. What can I do about it and how can I find out the dependencies in a *.hs or *.o file? Almost all documentation about dll's is about Linux or about using dll's in Haskell. Kees {-# LANGUAGE BlockArguments #-} {-# LANGUAGE ForeignFunctionInterface #-} module Vogels ( loadVogels ) where import System.Directory import Foreign.Ptr import Foreign.Storable import Foreign.C.String loadVogels :: String -> IO (Either String String) loadVogels vogelsFn = do -- b <- doesFileExist vogelsFn let b=True if b then return $ Left $ "Can\'t find " ++ vogelsFn else do txt <- readFile vogelsFn return $ Right txt loadVogelsFFI :: Ptr Int -> CString -> IO CString loadVogelsFFI messageKind vogelsFnFFI = do vogelsFn <- peekCString vogelsFnFFI eitherRes <- loadVogels vogelsFn case eitherRes of Left errMsg -> do poke messageKind 1 newCString errMsg Right txt -> do poke messageKind 0 newCString txt foreign export ccall loadVogelsFFI :: Ptr Int -> CString -> IO CString --- Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. https://www.avast.com/antivirus

2 1

Assistant/Associate Professorships in Nottingham
by Graham Hutton 10 Jun '19

10 Jun '19

Dear all, As part of a strategic expansion, the School of Computer Science at the University of Nottingham is seeking to make multiple new appointments at the Assistant or Associate Professor level: https://tinyurl.com/y4qfdqps https://tinyurl.com/y2uw6tsa Applications in the area of the Functional Programming (FP) lab are strongly encouraged! The FP lab is keen to receive applications from candidates with an excellent publication record (e.g. papers in leading venues such as LICS, POPL, ICFP, JFP, TOPLAS, etc) and the ability to secure external funding to support their research. Further information about the FP lab is available from: https://tinyurl.com/y2ekdkqa The deadline for applications is Monday 8th July 2019. The advert mentions some specific research areas, but the positions are open to applicants from any area of Computer Science. -- Graham Hutton and Thorsten Altenkirch 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

Re: [Haskell-cafe] conduit/pipes/streaming and prompt cleanup - using a decorator
by Daniel Díaz 10 Jun '19

10 Jun '19

I tried to tackle this problem in my "streaming-bracketed" library http://hackage.haskell.org/package/streaming-bracketed, by using a "decorator" that wraps regular streams, as opposed to having a resource-aware base monad. When lifting take-like functions to the decorator, new deallocation actions are inserted. On Tue, Jun 4, 2019 at 2:53 PM <haskell-cafe-request(a)haskell.org> wrote: > I'm using the 'streaming' library and realized it doesn't close files in a > timely way for the way I'm using it, and in fact can't, due to how the > library > works. I know conduit has put a lot of thought into closing resources in a > timely way, so I did an experiment to see what it does, but as far as I can > tell, conduit has the same problem. Maybe I'm doing it wrong? > > The situation is that I'm opening multiple files and mixing their output. > I want to close the inputs as soon as I'm done with them. But I can get > done with them earlier than the end of the file. Since all of these > libraries > are based on pulling from downstream, if you don't pull all the way to the > end, > the close at the end doesn't happen, and has to wait until runResourceT > returns, which is too late. I remember long ago reading Oleg's original > iteratee paper, and it seems like he called out this problem with > pull-based > iterators, that the iterator doesn't know when its caller is done with it, > so > it can't close files on time. > > Here's a conduit version that I think illustrates the situation: > > import qualified Conduit as C > import Conduit ((.|)) > import qualified Control.Monad.Trans as Trans > import qualified System.IO as IO > > main :: IO () > main = C.runResourceT $ C.runConduit pipe > > pipe :: C.ConduitM a c (C.ResourceT IO) () > pipe = fileLines "TODO" .| (C.takeC 3 >> C.yield "***") > .| C.mapM_C (Trans.liftIO . putStrLn) > > fileLines :: C.MonadResource m => FilePath -> C.ConduitT i String m () > fileLines fname = C.bracketP (IO.openFile fname IO.ReadMode) close > handleLines > > handleLines :: Trans.MonadIO m => IO.Handle -> C.ConduitT i String m () > handleLines hdl = loop > where > loop = do > eof <- Trans.liftIO $ IO.hIsEOF hdl > if eof then return () else do > line <- Trans.liftIO $ IO.hGetLine hdl > C.yield line > loop > > close :: IO.Handle -> IO () > close hdl = IO.hClose hdl >> putStrLn "=== close" > > This prints the first three lines of TOOD, then ***, and then "=== close", > where the close should go before the ***s. > > As far as I can see, conduit can't do this any more than 'streaming' can, > because 'C.takeC' is just some awaits and yields, with no indication that > the final await is more special than any other await. > > I think what would be necessary to solve this is that combinators like > 'take' > have to be able to tell the stream to close, and that has to propagate > back up > to each producer that has registered a cleanup. Of course this renders the > stream invalid, so it's not safe to have any other references to the stream > around, but I guess streams are stateful in general so that's always true. > Maybe I could accumulate the finalizers in the stream data type and have > combinators like 'take' call it as soon as they've taken their last. What > I actually wound up doing was make a 'takeClose' that also takes a 'close' > action to run when its done with the stream. It's not exactly general but > I'm > not writing a library so I don't need general. > > Is there some kind of standard or built-in solution for this situation? > I know others have given a lot more thought to streaming than I have, > so surely this issue has come up. > > I know there is a lot of talk about "prompt finalisation" and streams vs. > pipes vs. conduit, and talk about brackets and whatnot, but despite reading > various documents (https://hackage.haskell.org/package/streaming-with, > > http://www.haskellforall.com/2013/01/pipes-safe-10-resource-management-and.… > , > etc.) I still don't really understand what they're talking about. > It seems like they're really about reliable cleanup when there are > exceptions, not really about prompt cleanup. Certainly pipes-safe doesn't > do > prompt cleanup, at least not the kind I'm talking about. > > >

2 1

Final call for regular papers for IFL 2019 (Implementation and Application of Functional Languages)
by Jurriaan Hage 07 Jun '19

07 Jun '19

Hello, Please, find below the call for papers for IFL 2019. With respect to the previous call, the deadline for submitting regular papers has been changed to June 15th. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- ================================================================================ IFL 2019 31st Symposium on Implementation and Application of Functional Languages National University of Singapore September 25th-27th, 2019 http://2019.iflconference.org ================================================================================ ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2019 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications ### Keynote Speaker * Olivier Danvy, Yale-NUS College ### Submissions and peer-review Differently from previous editions of IFL, IFL 2019 solicits two kinds of submissions: * Regular papers (12 pages including references) * Draft papers for presentations ('weak' limit between 8 and 15 pages) Regular papers will undergo a rigorous review by the program committee, and will be evaluated according to their correctness, novelty, originality, relevance, significance, and clarity. A set of regular papers will be conditionally accepted for publication. Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. Regular papers not accepted for publication will be considered as draft papers, at the request of the author. Draft papers will be screened to make sure that they are within the scope of IFL, and will be accepted for presentation or rejected accordingly. Prior to the symposium: Authors of conditionally accepted papers and accepted presentations will submit a pre-proceedings version of their work that will appear in the draft proceedings distributed at the symposium. The draft proceedings does not constitute a formal publication. We require that at least one of the authors present the work at IFL 2019. After the symposium: Authors of conditionally accepted papers will submit a revised versions of their paper for the formal post-proceedings. The program committee will assess whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. Our interest is to ultimately accept all conditionally accepted papers. If you are an author of a conditionally accepted paper, please make sure that you address all the concerns of the reviewers. Authors of accepted presentations will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal post-proceedings. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected. ### Publication The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication ### Important dates Submission of regular papers: June 15, 2019 Submission of draft papers: July 15, 2019 Regular and draft papers notification: August 1, 2019 Deadline for early registration: August 15, 2019 Submission of pre-proceedings version: September 15, 2019 IFL Symposium: September 25-27, 2019 Submission of papers for post-proceedings: November 30, 2019 Notification of acceptance: January 31, 2020 Camera-ready version: February 29, 2020 ### Submission details All contributions must be written in English. Papers must use the ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2019 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jurrien Stutterheim (Standard Chartered Bank Singapore), Wei Ngan Chin (National University of Singapore) Program Committee: - Olaf Chitil, University of Kent - Clemens Grelck, University of Amsterdam - Daisuke Kimura, Toho University - Pieter Koopman, Radboud University - Tamas Kozsik, Eotvos Lorand University - Roman Leschinskiy, Facebook - Ben Lippmeier, The University of New South Wales - Marco T. Morazan, Seton Hall University - Sven-Bodo Scholz, Heriot-Watt University - Tom Schrijvers, Katholieke Universiteit Leuven - Alejandro Serrano, Utrecht University - Tony Sloane, Macquarie University - Simon Thompson, University of Kent - Marcos Viera, Universidad de la Republica - Wei Ngan Chin, NUS - Jurrien Stutterheim, Standard Chartered Bank ### Venue The 31st IFL is organized by the National University of Singapore. Singapore is located in the heart of South-East Asia, and the city itself is extremely well connected by trains and taxis. See the website for more information on the venue. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organizers for their work, which is reused here. A part of IFL 2019 format and CFP language that describes conditionally accepted papers has been adapted from call-for-papers of OOPSLA conferences.

1 0

Looking for a paper
by Michael Orlitzky 05 Jun '19

05 Jun '19

Everyone knows that parentheses suck for function application. But I'm looking for a CS paper that argues that function application should have its own explicit syntax in a functional programming language. I believe, in the paper, that a dot "." was used, but this would be analogous to Haskell's "$" function, except that it would be made part of the language definition. I think it came up on this mailing list (where else would I have seen it?), and if anyone remembers the name or author I'd be grateful.

5 9

conduit/pipes/streaming and prompt cleanup
by Evan Laforge 05 Jun '19

05 Jun '19

I'm using the 'streaming' library and realized it doesn't close files in a timely way for the way I'm using it, and in fact can't, due to how the library works. I know conduit has put a lot of thought into closing resources in a timely way, so I did an experiment to see what it does, but as far as I can tell, conduit has the same problem. Maybe I'm doing it wrong? The situation is that I'm opening multiple files and mixing their output. I want to close the inputs as soon as I'm done with them. But I can get done with them earlier than the end of the file. Since all of these libraries are based on pulling from downstream, if you don't pull all the way to the end, the close at the end doesn't happen, and has to wait until runResourceT returns, which is too late. I remember long ago reading Oleg's original iteratee paper, and it seems like he called out this problem with pull-based iterators, that the iterator doesn't know when its caller is done with it, so it can't close files on time. Here's a conduit version that I think illustrates the situation: import qualified Conduit as C import Conduit ((.|)) import qualified Control.Monad.Trans as Trans import qualified System.IO as IO main :: IO () main = C.runResourceT $ C.runConduit pipe pipe :: C.ConduitM a c (C.ResourceT IO) () pipe = fileLines "TODO" .| (C.takeC 3 >> C.yield "***") .| C.mapM_C (Trans.liftIO . putStrLn) fileLines :: C.MonadResource m => FilePath -> C.ConduitT i String m () fileLines fname = C.bracketP (IO.openFile fname IO.ReadMode) close handleLines handleLines :: Trans.MonadIO m => IO.Handle -> C.ConduitT i String m () handleLines hdl = loop where loop = do eof <- Trans.liftIO $ IO.hIsEOF hdl if eof then return () else do line <- Trans.liftIO $ IO.hGetLine hdl C.yield line loop close :: IO.Handle -> IO () close hdl = IO.hClose hdl >> putStrLn "=== close" This prints the first three lines of TOOD, then ***, and then "=== close", where the close should go before the ***s. As far as I can see, conduit can't do this any more than 'streaming' can, because 'C.takeC' is just some awaits and yields, with no indication that the final await is more special than any other await. I think what would be necessary to solve this is that combinators like 'take' have to be able to tell the stream to close, and that has to propagate back up to each producer that has registered a cleanup. Of course this renders the stream invalid, so it's not safe to have any other references to the stream around, but I guess streams are stateful in general so that's always true. Maybe I could accumulate the finalizers in the stream data type and have combinators like 'take' call it as soon as they've taken their last. What I actually wound up doing was make a 'takeClose' that also takes a 'close' action to run when its done with the stream. It's not exactly general but I'm not writing a library so I don't need general. Is there some kind of standard or built-in solution for this situation? I know others have given a lot more thought to streaming than I have, so surely this issue has come up. I know there is a lot of talk about "prompt finalisation" and streams vs. pipes vs. conduit, and talk about brackets and whatnot, but despite reading various documents (https://hackage.haskell.org/package/streaming-with, http://www.haskellforall.com/2013/01/pipes-safe-10-resource-management-and.…, etc.) I still don't really understand what they're talking about. It seems like they're really about reliable cleanup when there are exceptions, not really about prompt cleanup. Certainly pipes-safe doesn't do prompt cleanup, at least not the kind I'm talking about.

2 2

Second Call for Submissions: ICFP Student Research Competition
by Sam Tobin-Hochstadt 03 Jun '19

03 Jun '19

ICFP 2019 Student Research Competition Call for Submissions ICFP invites students to participate in the Student Research Competition in order to present their research and get feedback from prominent members of the programming language research community. Please submit your extended abstracts through the submission website. ### Important dates Submissions due: 14 Jun 2019 (Friday) https://icfp19src.hotcrp.com Notification: 28 Jun 2019 (Friday) Conference: 18 August (Sunday) - 23 August (Friday) Each submission (referred to as "abstract" below) should include the student author’s name and e-mail address; institutional affiliation; research advisor’s name; ACM student member number; category (undergraduate or graduate); research title; and an extended abstract addressing the following: * Problem and Motivation: Clearly state the problem being addressed and explain the reasons for seeking a solution to this problem. * Background and Related Work: Describe the specialized (but pertinent) background necessary to appreciate the work in the context of ICFP areas of interest. Include references to the literature where appropriate, and briefly explain where your work departs from that done by others. * Approach and Uniqueness: Describe your approach in addressing the problem and clearly state how your approach is novel. * Results and Contributions: Clearly show how the results of your work contribute to programming language design and implementation in particular and to computer science in general; explain the significance of those results. * Submissions must be original research that is not already published at ICFP or another conference or journal. One of the goals of the SRC is to give students feedback on ongoing, unpublished work. Furthermore, the abstract must be authored solely by the student. If the work is collaborative with others and*or part of a larger group project, the abstract should make clear what the student’s role was and should focus on that portion of the work. * Formatting: Submissions must be in PDF format, printable in black and white on US Letter sized paper, and interpretable by common PDF tools. All submissions must adhere to the "ACM Small" template that is available (in both LaTeX and Word formats) from https://www.acm.org/publications/authors/submissions. For authors using LaTeX, a lighter-weight package, including only the essential files, is available from http://sigplan.org/Resources/Author/#acmart-format. The submission must not exceed 3 pages in PDF format. Reference lists do not count towards the 3-page limit. Further information is available at the ICFP SRC website: https://icfp19.sigplan.org/track/icfp-2019-Student-Research-Competition ICFP Student Research Competition Chair: William J. Bowman (University of British Columbia)

1 0

ANN: stack-2.1 second release candidate
by Emanuel Borsboom 03 Jun '19

03 Jun '19

Announcing the second release candidate for Stack 2.1! This is the version that will be released one week from now if there aren't any major issues discovered, so please give it a try. You can download bindists for Linux, macOS, and Windows from https://github.com/commercialhaskell/stack/releases/tag/v2.1.0.3 **Changes since v2.1.0.1** Other enhancements: * Add `--docker-mount-mode` option to set the Docker volume mount mode for performance tuning on macOS. Bug fixes: * Fix regression where `stack --docker` would quit after 20 seconds on macOS.

1 0

"-with-rtsopts=-T" solved the memory leak
by Vlatko Basic 29 May '19

29 May '19

Hello, I accidentally solved a memory leak just by enabling "with-rtsopts=-T". I knew where the issues was, in one servant client web call. It was showing even when the call result (a Bool) wasn't used. While the leak was "active", I had: ghc-options: -threaded -rtsopts -with-rtsopts=-N And now that it doesn't show anymore, I have: ghc-options: -threaded -rtsopts -with-rtsopts=-N -with-rtsopts=-T I can reproduce the leak just by commenting out "-with-rtsopts=-T" and force rebuilding. Can anyone explain what is happening? Best regards, vlatkoB

1 0

Fwd: Two weeks left for Haskell Exchange talk proposals
by Spiwack, Arnaud 29 May '19

29 May '19

Dear all, Only two weeks remain before the end of the Haskell eXchange call-for-paper (11th of june). Send your proposals! This year's keynote speaker will be Elise Huard, Gabriele Keller, Simon Peyton Jones, and Philip Wadler. Find the full CFP and submit your proposal here: https://docs.google.com/forms/d/e/1FAIpQLSeJgeTqAdYLBlRcO9PDzI3yrR22CqzhInH…

1 0

A "less" complex median
by Michel Haber 28 May '19

28 May '19

Hello Cafe, I wanted to try and write a median filter with good complexity and performance. This is just an exercise, so there is no use looking for better performance algorithms (median of medians). Below is the code I came up with: import Control.Monad.State import System.Random type MyState s = State (Int, Int, [(Int, s)]) -- Inserts a value in its sorted place, -- Removes all expired values encountered, -- Returns the median value of the list. insertSorted :: (Ord a) => a -> MyState a a insertSorted v = do (size, index, list) <- get let flt = valid size index -- Filter: If too old remove value cmp (_,x) = v < x -- Compare: If v spot reached, add v ret = min index size `div` 2 -- The return value's index let (newList, med) = goThrough flt cmp ret (index, v) list put (size, index + 1, newList) return . snd $ med -- Internal implementation goThrough :: (a -> Bool) -> (a -> Bool) -> Int -> a -> [a] -> ([a], a) goThrough _ _ _ v [] = ([v], v) goThrough flt cmp idx v ls@(x:xs) | flt x && cmp x = if idx == 0 then (v:ls, v) else (v:ls, getTo idx (v:ls)) | flt x = let (ys, y) = goThrough flt cmp (max 0 (idx-1)) v xs in if idx == 0 then (x:ys, x) else (x:ys, y) | otherwise = goThrough flt cmp idx v xs -- Continues going through the list until we get to the element we want, or we -- run out of elements, in which case we take the last one getTo :: Int -> [a] -> a getTo _ [] = error "No value to return!" getTo _ [x] = x getTo 0 (x:_) = x getTo i (_:xs) = getTo (i-1) xs -- A value is valid if it still has a place in the list (hasn't expired) valid :: Int -> Int -> (Int, a) -> Bool valid size index (i,_) = index - i < size -- Clean up all the old values in the list. This is costly, and should be -- performed sparingly clean :: MyState Double () clean = do (size, index, list) <- get put (size, index, filter (valid size index) list) -- Insert n values with insertSorted insertList :: [Double] -> MyState Double [Double] insertList ls = sequence $ insertSorted <$> ls -- Example main :: IO () main = do values <- sequence $ replicate 10000 $ randomRIO (1,100::Double) print $ runState (insertList values <* clean) (10, 0, []) return () The code works, at least in the simple cases I've tried. It seems, however, way too complex and not very composable. So I was wondering if anyone could tell me where I went wrong, and how I can make the code simpler and smaller. Of course, it is completely possible to divide my insertion function, but the goal is to do all of the steps in one iteration over the list. This allows me to later compare what I have with divided functions to discover if the compiler would optimize them into one traversal. But even with its current logic, I believe the code can be better written. I just don't know how :p So I really appreciate any advice on how to make it better (or fix a bug I missed, or maybe even the logic of the whole algorithm). Cheers, Michel :)

2 2

ANN: Elminator (Haskell to Elm code generator for Elm 0.19/0.18)
by sras 28 May '19

28 May '19

Happy to announce 'Elminator', a package for generating Elm source for type definitions and Json encoders/decoders from Haskell data type definitions. https://hackage.haskell.org/package/elminator, This package tries to address some issues with popular/existing packages in the same space. Some distinguishing features are.. 1. Supports generation of polymorphic types (as well as concrete ones) in Elm from possibly polymorphic Haskell types, including types with phantom type variables. 2. Supports generation of code for recursive types (direct/indirect) as long as the type is not polymorphic. 3. Generates code that does not depend on external Elm libraries. 4. Does not have limits on the number of fields that the constructors of your types can have. 5. Supports JSON encoding options exported by the Aeson library comprehensively. 6. Supports generation of code that depend on user defined types and encoders/decoders in Elm. Right now this package is tested by using a Haskell/Elm test app that round trips a bunch of data structures between an Elm front end and a Haskell back end, so as of now, there there aren't any automated tests included with this repo. Any feedback is welcome! Thanks.

1 0

Emacs org-mode code block problems
by Lawrence Bottorff 27 May '19

27 May '19

I've got this in an Emacs org-mode code block: #+begin_src haskell :results output doubleSmallNumber4 x = if x > 0 then x else x * 2 #+end_src but when I try to run it (with C-c C-c) I get ... Prelude> doubleSmallNumber4 x = if x > 0 then x else x * 2 "org-babel-haskell-eoe" <interactive>:19:23: error: parse error (possibly incorrect indentation or mismatched brackets) Prelude> <interactive>:20:11: error: parse error (possibly incorrect indentation or mismatched brackets) Prelude> <interactive>:21:5-8: error: parse error on input ‘then’ Prelude> <interactive>:22:5-8: error: parse error on input ‘else’ Prelude> "org-babel-haskell-eoe" ... I can run #+begin_src haskell tripleMe x = x + x + x #+end_src just fine though -- which means I've done something right with my Emacs init. The REPL started is 8.6.3 stack-ghci. I've formatted with the org-mode C-c '

1 0

How to make boolean logic with IO Monad more expressive?
by Magicloud Magiclouds 27 May '19

27 May '19

Hi, I think `a || b && c` is more clear than ``` if a then True else if b then if c then True else False else False ``` And some languages, `pureComputing || (ioOperation && pure2)` involves IO only when pureComputing is False. So in Haskell, is it possible to get both benefits? ``` status <- ioOperation -- IO-ed anyway return $ pureComputing || (status && pure2) ``` ``` if pureComputing then return True else do status <- ioOperation if status then return pure2 else return False -- Looks ugly ```

4 9

Call for papers for IFL 2019 (Implementation and Application of Functional Languages)
by Jurriaan Hage 27 May '19

27 May '19

Hello, Please, find below the call for papers for IFL 2019. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- ================================================================================ IFL 2019 31st Symposium on Implementation and Application of Functional Languages National University of Singapore September 25th-27th, 2019 http://2019.iflconference.org ================================================================================ ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2019 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications ### Keynote Speaker * Olivier Danvy, Yale-NUS College ### Submissions and peer-review Differently from previous editions of IFL, IFL 2019 solicits two kinds of submissions: * Regular papers (12 pages including references) * Draft papers for presentations ('weak' limit between 8 and 15 pages) Regular papers will undergo a rigorous review by the program committee, and will be evaluated according to their correctness, novelty, originality, relevance, significance, and clarity. A set of regular papers will be conditionally accepted for publication. Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. Regular papers not accepted for publication will be considered as draft papers, at the request of the author. Draft papers will be screened to make sure that they are within the scope of IFL, and will be accepted for presentation or rejected accordingly. Prior to the symposium: Authors of conditionally accepted papers and accepted presentations will submit a pre-proceedings version of their work that will appear in the draft proceedings distributed at the symposium. The draft proceedings does not constitute a formal publication. We require that at least one of the authors present the work at IFL 2019. After the symposium: Authors of conditionally accepted papers will submit a revised versions of their paper for the formal post-proceedings. The program committee will assess whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. Our interest is to ultimately accept all conditionally accepted papers. If you are an author of a conditionally accepted paper, please make sure that you address all the concerns of the reviewers. Authors of accepted presentations will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal post-proceedings. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected. ### Publication The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication ### Important dates Submission of regular papers: May 31, 2019 Submission of draft papers: July 15, 2019 Regular and draft papers notification: August 1, 2019 Deadline for early registration: August 15, 2019 Submission of pre-proceedings version: September 15, 2019 IFL Symposium: September 25-27, 2019 Submission of papers for post-proceedings: November 30, 2019 Notification of acceptance: January 31, 2020 Camera-ready version: February 29, 2020 ### Submission details All contributions must be written in English. Papers must use the ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2019 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jurrien Stutterheim (Standard Chartered Bank Singapore), Wei Ngan Chin (National University of Singapore) Program Committee: - Olaf Chitil, University of Kent - Clemens Grelck, University of Amsterdam - Daisuke Kimura, Toho University - Pieter Koopman, Radboud University - Tamas Kozsik, Eotvos Lorand University - Roman Leschinskiy, Facebook - Ben Lippmeier, The University of New South Wales - Marco T. Morazan, Seton Hall University - Sven-Bodo Scholz, Heriot-Watt University - Tom Schrijvers, Katholieke Universiteit Leuven - Alejandro Serrano, Utrecht University - Tony Sloane, Macquarie University - Simon Thompson, University of Kent - Marcos Viera, Universidad de la Republica - Wei Ngan Chin, NUS - Jurrien Stutterheim, Standard Chartered Bank ### Venue The 31st IFL is organized by the National University of Singapore. Singapore is located in the heart of South-East Asia, and the city itself is extremely well connected by trains and taxis. See the website for more information on the venue. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organizers for their work, which is reused here. A part of IFL 2019 format and CFP language that describes conditionally accepted papers has been adapted from call-for-papers of OOPSLA conferences.

1 0

Is there already a lib to work with filepath glob?
by Magicloud Magiclouds 26 May '19

26 May '19

Hi, Say for logic of Bash code `for f in /somePath/*/*; do ... done`, with filepath, directory packages, I have to do something like `listDirectoryContent "somePath" >>= mapM_ (\fp -> listDirectoryContent fp >>= action)`. It is not as expressive as the script. Especially when I'd like to use conduit to stream the folder. So is there already something I can use to make the logic expressive? PS: I know there are some libs to match a filepath against a glob string. But that is not what I want.

1 1

haskell-src-exts - no more releases
by Matthew Pickering 26 May '19

26 May '19

Hi all, I have decided that I am not going to do any more releases of `haskell-src-exts`. (https://github.com/haskell-suite/haskell-src-exts) If anyone wants to become the maintainer then I will gladly transfer rights to the repo. I advise anyone who wants to parse Haskell programs to use the GHC API, specifically you can use `ghc-lib-parser`. https://hackage.haskell.org/package/ghc-lib-parser Cheers, Matt

2 1

ANN: stack-2.1 release candidate
by Emanuel Borsboom 26 May '19

26 May '19

Announcing the first release candidate of Stack 2.1! You can download bindists for Linux, macOS, and Windows from https://github.com/commercialhaskell/stack/releases/tag/v2.1.0.1. ### Changes since v1.9.3 Major changes: * Switch over to pantry for managing packages. This is a major change to Stack's internals, and affects user-visible behavior in a few places. Some highlights: * Drop support for multiple package indices and legacy `00-index.tar` style indices. See [#4137](https://github.com/commercialhaskell/stack/issues/4137). * Support for archives and repos in the `packages` section has been removed. Instead, you must use `extra-deps` for such dependencies. `packages` now only supports local filepaths. * Add support for Git repositories containing (recursive) submodules. * Addition of new configuration options for specifying a "pantry tree" key, which provides more reproducibility around builds, and (in the future) will be used for more efficient package content downloads. You can also specify package name and version for more efficient config parsing. * __NOTE__ The new `stack freeze` command provides support for automatically generating this additional information. * Package contents and metadata are stored in an SQLite database in place of files on the filesystem. The `pantry` library can be used for interacting with these contents. * Internally, Stack has changed many datatypes, including moving to Cabal's definition of many data types. As a result of such changes, existing cache files will in general be invalidated, resulting in Stack needing to rebuild many previously cached builds in the new version. Sorry :(. * A new command, `stack freeze` has been added which outputs project and snapshot definitions with dependencies pinned to their exact versions. * The `ignore-revision-mismatch` setting is no longer needed, and has been removed. * Overriding GHC boot packages results in any other GHC boot packages depending on it being no longer available as a dependency, such packages need to be added explicitly when needed. See [#4510] (https://github.com/commercialhaskell/stack/issues/4510) * Cabal solver integration was not updated to support newer `cabal-install` versions so `stack solver` command was removed as well as a related option `--solver` from `stack new` and `stack init`. * Upgrade to Cabal 2.4 * Note that, in this process, the behavior of file globbing has been modified to match that of Cabal. In particular, this means that for Cabal spec versions less than 2.4, `*.txt` will match `foo.txt`, but not `foo.2.txt`. * Remove the `stack image` command. With the advent of Docker multistage builds, this functionality is no longer useful. For an example, please see [Building Haskell Apps with Docker]( https://www.fpcomplete.com/blog/2017/12/building-haskell-apps-with-docker) * Support building GHC from source (experimental) * Stack now supports building and installing GHC from source. The built GHC is uniquely identified by a commit id and an Hadrian "flavour" (Hadrian is the newer GHC build system), hence `compiler` can be set to use a GHC built from source with `ghc-git-COMMIT-FLAVOUR` * `stack.yaml` now supports a `configure-options`, which are passed directly to the `configure` step in the Cabal build process. See [#1438](https://github.com/commercialhaskell/stack/issues/1438) * Remove support for building GHCJS itself. Future releases of Stack may remove GHCJS support entirely. * Support for lock files for pinning exact project dependency versions Behavior changes: * `stack.yaml` now supports `snapshot`: a synonym for `resolver`. See [#4256](https://github.com/commercialhaskell/stack/issues/4256) * `stack script` now passes `-i -idir` in to the `ghc` invocation. This makes it so that the script can import local modules, and fixes an issue where `.hs` files in the current directory could affect interpretation of the script. See [#4538](https://github.com/commercialhaskell/stack/pull/4538) * When using `stack script`, custom snapshot files will be resolved relative to the directory containing the script. * Remove the deprecated `--upgrade-cabal` flag to `stack setup`. * Support the `drop-packages` field in `stack.yaml` * Remove the GPG signing code during uploads. The GPG signatures have never been used yet, and there are no plans to implement signature verification. * Remove the `--plain` option for the `exec` family of commands * Always use the `--exact-configuration` Cabal configuration option when building (should mostly be a non-user-visible enhancement). * No longer supports Cabal versions older than `1.19.2`. This means projects using snapshots earlier than `lts-3.0` or `nightly-2015-05-05` will no longer build. * Remove the `stack docker cleanup` command. Docker itself now has [`docker image prune`]( https://docs.docker.com/engine/reference/commandline/image_prune/) and [`docker container prune`]( https://docs.docker.com/engine/reference/commandline/container_prune/) which you can use instead. * Interleaved output is now turned on by default, see [#4702](https://github.com/commercialhaskell/stack/issues/4702). In addition, the `packagename> ` prefix is no longer included in interelaved mode when only building a single target. * The `-fhide-source-paths` GHC option is now enabled by default and can be disabled via the `hide-source-paths` configuration option in `stack.yaml`. See [#3784]( https://github.com/commercialhaskell/stack/issues/3784) * Stack will reconfigure a package if you modify your `PATH` environment variable. See [#3138](https://github.com/commercialhaskell/stack/issues/3138). * For GHC 8.4 and later, disable the "shadowed dependencies" workaround. This means that Stack will no longer have to force reconfigures as often. See [#3554](https://github.com/commercialhaskell/stack/issues/3554). * When building a package, Stack takes a lock on the dist directory in use to avoid multiple runs of Stack from trampling each others' files. See [#2730](https://github.com/commercialhaskell/stack/issues/2730). * Stack will check occassionally if there is a new version available and prompt the user to upgrade. This will not incur any additional network traffic, as it will piggy-back on the existing Hackage index updates. You can set `recommend-stack-upgrade: false` to bypass this. See [#1681](https://github.com/commercialhaskell/stack/issues/1681). * `stack list-dependencies` has been removed in favour of `stack ls dependencies`. * The new default for `--docker-auto-pull` is enabled. See [#3332](https://github.com/commercialhaskell/stack/issues/3332). Other enhancements: * Support MX Linux in get-stack.sh. Fixes [#4769](https://github.com/commercialhaskell/stack/issues/4769). * Defer loading up of files for local packages. This allows us to get plan construction errors much faster, and avoid some unnecessary work when only building a subset of packages. This is especially useful for the curator use case. * Existing global option `--color=WHEN` is now also available as a non-project-specific yaml configuration parameter `color:`. * Adopt the standard proposed at http://no-color.org/, that color should not be added by default if the `NO_COLOR` environment variable is present. * New command `stack ls stack-colors` lists the styles and the associated 'ANSI' control character sequences that stack uses to color some of its output. See `stack ls stack-colors --help` for more information. * New global option `--stack-colors=STYLES`, also available as a non-project-specific yaml configuration parameter, allows a stack user to redefine the default styles that stack uses to color some of its output. See `stack --help` for more information. * British English spelling of 'color' (colour) accepted as an alias for `--color`, `--stack-colors`, `stack ls stack-colors` at the command line and for `color:` and `stack-colors:` in yaml configuration files. * New build option `--ddump-dir`. (See [#4225]( https://github.com/commercialhaskell/stack/issues/4225)) * Stack parses and respects the `preferred-versions` information from Hackage for choosing latest version of a package in some cases, e.g. `stack unpack packagename`. * The components output in the `The main module to load is ambiguous` message now include package names so they can be more easily copy-pasted. * Git repos are shared across multiple projects. See [#3551](https://github.com/commercialhaskell/stack/issues/3551) * Use en_US.UTF-8 locale by default in pure Nix mode so programs won't crash because of Unicode in their output [#4095](https://github.com/commercialhaskell/stack/issues/4095) * Add `--tree` to `ls dependencies` to list dependencies as tree. [#4101](https://github.com/commercialhaskell/stack/issues/4101) * Add `--pedantic` to `ghci` to run with `-Wall` and `-Werror` [#4463](https://github.com/commercialhaskell/stack/issues/4463) * Add `--cabal-files` flag to `stack ide targets` command. * Add `--stdout` flag to all `stack ide` subcommands. * Use batches when unregistering packages with `ghc-pkg`. (See [#2662](https://github.com/commercialhaskell/stack/issues/2662)) * `get-stack` script now works on Windows CI machines of Appveyor, Travis and Azure Pipelines. See [#4535](https://github.com/commercialhaskell/stack/issues/4535)/ * Show snapshot being used when `stack ghci` is invoked outside of a project directory. See [#3651](https://github.com/commercialhaskell/stack/issues/3651) * The script interpreter now accepts a `--extra-dep` flag for adding packages not present in the snapshot. Currently, this only works with packages from Hackage, not Git repos or archives. * When using the script interpreter with `--optimize` or `--compile`, Stack will perform an optimization of checking whether a newer executable exists, making reruns significantly faster. There's a downside to this, however: if you have a multifile script, and change one of the dependency modules, Stack will not automatically detect and recompile. * `stack clean` will delete the entire `.stack-work/dist` directory, not just the relevant subdirectory for the current GHC version. See [#4480](https://github.com/commercialhaskell/stack/issues/4480). * Add `stack purge` as a shortcut for `stack clean --full`. See [#3863](https://github.com/commercialhaskell/stack/issues/3863). * Both `stack dot` and `stack ls dependencies` accept a `--global-hints` flag to bypass the need for an installed GHC. See [#4390](https://github.com/commercialhaskell/stack/issues/4390). * Add the `stack config env` command for getting shell script environment variables. See [#620]( https://github.com/commercialhaskell/stack/issues/620) * Less verbose output from `stack setup` on Windows. See [#1212](https://github.com/commercialhaskell/stack/issues/1212). * Add an optional `ignore-expiry` flag to the `hackage-security` section of the `~/.stack/config.yaml`. It allows to disable timestamp expiration verification just like `cabal --ignore-expiry` does. The flag is not enabled by default so that the default functionality is not changed. * Include default values for most command line flags in the `--help` output. See [#893](https://github.com/commercialhaskell/stack/issues/893). * Set the `GHC_ENVIRONMENT` environment variable to specify dependency packages explicitly when running test. This is done to prevent ambiguous module name errors in `doctest` tests. * Document the way stack interacts with the Cabal library. * `get-stack` script now works on Windows CI machines of Appveyor, Travis and Azure Pipelines. See [#4535](https://github.com/commercialhaskell/stack/issues/4535) * Warn when a Docker image does not include a `PATH` environment variable. See [#2472](https://github.com/commercialhaskell/stack/issues/2742) * When using `system-ghc: true`, Stack will now find the appropriate GHC installation based on the version suffix, allowing you to more easily switch between various system-installed GHCs. See [#2433](https://github.com/commercialhaskell/stack/issues/2433). * `stack init` will now support create a `stack.yaml` file without any local packages. See [#2465]( https://github.com/commercialhaskell/stack/issues/2465) * Store caches in SQLite database instead of files. * No longer use "global" Docker image database (`docker.db`). * User config files are respected for the script command. See [#3705](https://github.com/commercialhaskell/stack/issues/3705), [#3887](https://github.com/commercialhaskell/stack/issues/3887). * Set the `GHC_ENVIRONMENT` environment variable to `-` to tell GHC to ignore any such files when GHC is new enough (>= 8.4.4), otherwise simply unset the variable. This allows Stack to have control of package databases when running commands like `stack exec ghci`, even in the presence of implicit environment files created by `cabal new-build`. See [#4706](https://github.com/commercialhaskell/stack/issues/4706). * Use a database cache table to speed up discovery of installed GHCs * You can specify multiple `--test-arguments` options. See [#2226](https://github.com/commercialhaskell/stack/issues/2226) * Windows terminal width detection is now done. See [#3588](https://github.com/commercialhaskell/stack/issues/3588) * On Windows, informs users if the 'programs' path contains a space character and further warns users if that path does not have an alternative short ('8 dot 3') name, referencing the `local-programs-path` configuration option. See [#4726](https://github.com/commercialhaskell/stack/issues/4726) Bug fixes: * Ignore duplicate files for a single module when a Haskell module was generated from a preprocessor file. See [#4076](https://github.com/commercialhaskell/stack/issues/4076). * Only track down components in current directory if there are no hs-source-dirs found. This eliminates a number of false-positive warnings, similar to [#4076](https://github.com/commercialhaskell/stack/issues/4076). * Handle a change in GHC's hi-dump format around `addDependentFile`, which now includes a hash. See [yesodweb/yesod#1551](https://github.com/yesodweb/yesod/issues/1551) * Fix `subdirs` for git repos in `extra-deps` to match whole directory names. Also fixes for `subdirs: .`. See [#4292](https://github.com/commercialhaskell/stack/issues/4292) * Fix for git packages to update submodules to the correct state. See [#4314](https://github.com/commercialhaskell/stack/pull/4314) * Add `--cabal-files` flag to `stack ide targets` command. * Don't download ghc when using `stack clean`. * Support loading in GHCi definitions from symlinked C files. Without this patch, Stack will try to find object files in the directory pointed to by symlinks, while GCC will produce the object files in the original directory. See [#4402](https://github.com/commercialhaskell/stack/pull/4402) * Fix handling of GitHub and URL templates on Windows. See [commercialhaskell/stack#4394]( https://github.com/commercialhaskell/stack/issues/4394) * Fix `--file-watch` not responding to file modifications when running inside docker on Mac. See [#4506](https://github.com/commercialhaskell/stack/issues/4506) * Using `--ghc-options` with `stack script --compile` now works. * Ensure the detailed-0.9 type tests work. See [#4453](https://github.com/commercialhaskell/stack/issues/4453). * Extra include and lib dirs are now order-dependent. See [#4527](https://github.com/commercialhaskell/stack/issues/4527). * Apply GHC options when building a `Setup.hs` file. See [#4526](https://github.com/commercialhaskell/stack/issues/4526). * Stack handles ABI changes in FreeBSD 12 by differentiating that version from previous. * Help text for the `templates` subcommand now reflects behaviour in stack 1.9 — that it downloads and shows a help file, rather than listing available templates. * Fix detection of aarch64 platform (this broke when we upgraded to a newer Cabal version). * Docker: fix detecting and pulling missing images with `--docker-auto-pull`, see [#4598](https://github.com/commercialhaskell/stack/issues/4598) * Hackage credentials are not world-readable. See [#2159](https://github.com/commercialhaskell/stack/issues/2159). * Warnings are dumped from logs even when color is enabled. See [#2997](https://github.com/commercialhaskell/stack/issues/2997) * `stack init` will now work for cabal files with sublibraries. See [#4408](https://github.com/commercialhaskell/stack/issues/4408) * When the Cabal spec version is newer than the global Cabal version, build against the snapshot's Cabal library. See [#4488](https://github.com/commercialhaskell/stack/issues/4488) * Docker: fix detection of expected subprocess failures. This fixes downloading a compatible `stack` executable when the host `stack` is not compatible with the Docker image (on Linux), and doesn't show an unnecessary extra error when the in-container re-exec'ed `stack` exits with failure. * The `stack ghci` command's `--ghc-options` flag now parses multiple options. See [#3315](https://github.com/commercialhaskell/stack/issues/3315).

1 0

Call For Papers: Workshop in OCL and Textual Modeling (OCL 2019)
by Achim D. Brucker 25 May '19

25 May '19

CALL FOR PAPERS 19th International Workshop on OCL and Textual Modeling Co-located with MODELS 2019 ACM/IEEE 22nd International Conference on Model Driven Engineering Languages and System, September 15-20, 2019, Munich, Germany http://oclworkshop.github.io The goal of this workshop is to create a forum where researchers and practitioners interested in building models using OCL or other kinds of textual languages (e.g., OCL, textual MOF, Epsilon, or Alloy) can directly interact, report advances, share results, identify tools for language development, and discuss appropriate standards. In particular, the workshop will encourage discussions for achieving synergy from different modeling language concepts and modeling language use. The close interaction will enable researchers and practitioners to identify common interests and options for potential cooperation. ## Topics of interest Topics of interest include (but are not limited to): - Mappings between textual modeling languages and other languages/formalisms - Mathematical models and/or formal semantics for textual modeling languages - Algorithms, evaluation strategies and optimizations in the context of textual modeling languages for: - validation, verification, and testing, - model transformation and code generation, - meta-modeling and DSLs, and - query and constraint specifications - Alternative graphical/textual notations for textual modeling languages - Evolution, transformation and simplification of textual modeling expressions - Libraries, templates and patterns for textual modeling languages - Tools that support textual modeling languages (e.g., verification of OCL formulae, runtime monitoring of invariants) - Model-driven security using textual modeling languages - Complexity results for textual modeling languages - Quality models and benchmarks for comparing and evaluating textual modeling tools and algorithms - Successful applications of textual modeling languages - Case studies on industrial applications of textual modeling languages - Experience reports: - usage of textual modeling languages and tools in complex domains, - usability of textual modeling languages and tools for end-users - Empirical studies about the benefits and drawbacks of textual modeling languages - Innovative textual modeling tools - Comparison, evaluation and integration of modeling languages - Correlation between modeling languages and modeling tasks We particularly encourage submissions describing applications and case studies of textual modeling as well as test suites and benchmark collections for evaluating textual modeling tools. ## Submissions Four types of submissions will be considered: * Presentation only submission (not included in the workshop proceedings), e.g., for already published work. Authors should submit a short (1 page) abstract of their presentation. * Short papers (between 5 and 7 pages) describing new ideas or position papers. * Tool papers (between 5 and 7 pages) describing tools supporting textual modeling tools * Full papers (between 10 and 14 pages). All submissions should follow the LNCS format guidelines and should be uploaded to [EasyChair](https://easychair.org/conferences/?conf=ocl2019). Accepted papers will be published online in [CEUR](http://www.ceur-ws.org). ## Important Dates - Submission of papers: 14 Jul 2019 - Notification: 25 Aug 2019 - Pre-Workshop CRC: 9 Sep 2019 - Post-Workshop CRC: 5 Oct 2019 -- Dr. Achim D. Brucker | Chair of Cybersecurity | University of Exeter https://www.brucker.ch | https://logicalhacking.com/blog @adbrucker | @logicalhacking

1 0

Munich Haskell Meeting, 2019-05-27 @ 19:30
by Leah Neukirchen 24 May '19

24 May '19

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Monday, May 27 at Augustiner-Gaststätte Rumpler at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-may-2019/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> http://leahneukirchen.org/

1 0

job opportunity at Luna
by Sylwia Brodacka 23 May '19

23 May '19

Luna (http://luna-lang.org) is an award-winning data-science platform and a general-purpose functional programming language, selected by NASA and Singularity University as 1 of the 20 most impressive technologies worldwide. It spans the entire stack, from high-level visualisation and communication, to the nitty-gritty of running backend services in a single language. With inbuilt capabilities for visualisation and a dual-syntax architecture, the possibilities are limitless. We are looking for talented and extraordinary people with strong technical skills and a passion for functional programming. Since majority of Luna codebase is written in Haskell we have available positions for senior Haskell developers for a variety of roles, including Compiler Engineer, DevOps Engineer, GUI Architect, and Cloud Software Engineer. If you want to learn more about possibilities please check out detailed job description: https://stackoverflow.com/jobs/264670/senior-haskell-developer-luna Cheers, Sylwia

1 0

Re: [Haskell-cafe] Announce: Haskell Platform 8.6.5 (Gershom B) - clarification
by Pierre_van_der_Laar (Functional Account) 21 May '19

21 May '19

Dear All, The license issue can be summarized as follows: Whenever a program is compiled with GHC and is distributed on another platform than OS X, anybody can claim that the source code of that program must be provided due to the LGPL license, since integer-gmp, the ghc code, and that program's code are statically linked! Not convinced? Read e.g. https://gitlab.haskell.org/ghc/ghc/wikis/replacing-gmp-notes that discussed both the LGPL license and the usage of static libraries by GHC. For convenience, I have include the most relevant parts: ``` GMP is licensed under the GNU Lesser General Public License (LGPL), a kind of "copyleft" license. According to the terms of the LGPL, paragraph 5, you may distribute a program that is designed to be compiled and dynamically linked with the library under the terms of your choice (i.e., commercially) but if your program incorporates portions of the library, if it is linked statically, then your program is a "derivative"--a "work based on the library"--and according to paragraph 2, section c, you "must cause the whole of the work to be licensed" under the terms of the LGPL (including for free). The LGPL licensing for GMP is a problem for the overall licensing of binary programs compiled with GHC because most distributions (and builds) of GHC use static libraries. (Dynamic libraries are currently distributed only for OS X.) The LGPL licensing situation may be worse: even though The Glasgow Haskell Compiler License is essentially a "free software" license (BSD3), according to paragraph 2 of the LGPL, GHC must be distributed under the terms of the LGPL! ``` So the problem is real and seems to be underestimated by the Haskell user community based on the many (partly) incorrect responses on this mailing list. I still would like to know what GHC's strategy is to tackle this problem! Greetings, Pierre ________________________________ The information contained in this message may be confidential and legally protected under applicable law. The message is intended solely for the addressee(s). If you are not the intended recipient, you are hereby notified that any use, forwarding, dissemination, or reproduction of this message is strictly prohibited and may be unlawful. If you are not the intended recipient, please contact the sender by return e-mail and destroy all copies of the original message.

3 2

[TFP'19 and TFPIE'19] call for participation
by Peter Achten 21 May '19

21 May '19

--------------------------------- C A L L F O R P A R T I C I P A T I O N --------------------------------- ====== TFP 2019 ====== 20th Symposium on Trends in Functional Programming 12-14 June, 2019 Vancouver, BC, CA https://www.tfp2019.org/index.html ====== TFPIE 2019 ====== 8th International Workshop on Trends in Functional Programming in Education 11 June, 2019 Vancouver, BC, CA http://www.staff.science.uu.nl/~hage0101/tfpie2019/index.html 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 (see below at scope). Please be aware that TFP uses two distinct rounds of submissions (see below at submission details). TFP 2019 will be the main event of a pair of functional programming events. TFP 2019 will be accompanied by the International Workshop on Trends in Functional Programming in Education (TFPIE), which will take place on June 11. == Invited Speakers == TFP 2019 is pleased to announce keynote talks by the following two invited speakers: Nikhil Swamy, Microsoft Research: Structuring the Verification of Imperative Programs with Functional Programming Frank Wood, University of British Columbia: Probabilistic Programming TFPIE 2019 is pleased to have the following invited speaker: Gregor Kiczales: Functional Programming at the Core of a High Throughput Software Engineering Curriculum == Scope == The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles: Leading-edge, previously unpublished research work Position Articles: On what new trends should or should not be Project Articles: Descriptions of recently started new projects Evaluation Articles: What lessons can be drawn from a finished project Overview Articles: Summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: Functional programming and multicore/manycore computing Functional programming in the cloud High performance functional computing Extra-functional (behavioural) properties of functional programs Dependently typed functional programming Validation and verification of functional programs Debugging and profiling for functional languages Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. Interoperability with imperative programming languages Novel memory management techniques Program analysis and transformation techniques Empirical performance studies Abstract/virtual machines and compilers for functional languages (Embedded) domain specific languages New implementation strategies Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2019 program chairs, William J. Bowman and Ron Garcia. == Best Paper Awards == To reward excellent contributions, TFP awards a prize for the best paper accepted for the formal proceedings. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, that paper will then receive both prizes. == Instructions to Author == Papers must be submitted at: https://easychair.org/conferences/?conf=tfp2019 Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. == Pre-symposium formal review == Papers to be formally reviewed before the symposium should be submitted before an early deadline and receive their reviews and notification of acceptance for both presentation and publication before the symposium. A paper that has been rejected in this process may still be accepted for presentation at the symposium, but will not be considered for the post-symposium formal review. == Post-symposium formal review == Papers submitted for post-symposium review (draft papers) will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback received at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. == Paper categories == There are two types of submission, each of which can be submitted either for pre-symposium or post-symposium review: Extended abstracts. Extended abstracts are 4 to 10 pages in length. Full papers. Full papers are up to 20 pages in length. Each submission also belongs to a category: research position project evaluation overview paper Each submission should clearly indicate to which category it belongs. Additionally, a draft paper submission—of either type (extended abstract or full paper) and any category—can be considered a student paper. A student paper is one for which primary authors are research students and the majority of the work described was carried out by the students. The submission should indicate that it is a student paper. Student papers will receive additional feedback from the PC shortly after the symposium has taken place and before the post-symposium submission deadline. Feedback is only provided for accepted student papers, i.e., papers submitted for presentation and post-symposium formal review that are accepted for presentation. If a student paper is rejected for presentation, then it receives no further feedback and cannot be submitted for post-symposium review. == Format == Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site (http://www.springer.com/lncs) == Program Committee == Program Co-chairs William J. Bowman University of British Columbia Ronald Garcia University of British Columbia Matteo Cimini University of Massachusetts Lowell Ryan Culpepper Czech Technical Institute Joshua Dunfield Queen's University Sam Lindley University of Edinburgh Assia Mahboubi INRIA Nantes Christine Rizkallah University of New South Wales Satnam Singh Google AI Marco T. Morazán Seton Hall University John Hughes Chalmers University and Quviq Nicolas Wu University of Bristol Tom Schrijvers KU Leuven Scott Smith Johns Hopkins University Stephanie Balzer Carnegie Mellon University Viktória Zsók Eötvös Loránd University

1 0

Re: [Haskell-cafe] Announce: Haskell Platform 8.6.5 (Gershom B)
by Pierre_van_der_Laar (Functional Account) 21 May '19

21 May '19

Dear Gershom / GHC development team, The provided windows version of GHC contains lib-gmp. Hence, this version enforces a LGPL license on my code (see e.g. https://gitlab.haskell.org/ghc/ghc/wikis/replacing-gmp-notes for more info) . Unfortunately, this license is unacceptable for me. For me this raises the question: What is the strategy of GHC with respect to licensing? In particularly, * Why considers GHC a LGPL license for all the code developed by their users acceptable? * Is GHC considering to allow their user to standardly develop their code under a license of their own choice? * Are there plans to offer the GHC users an opportunity to choose the license in the near future? e.g. by distributing GHC binary distributions with integer-gmp and integer-simple. Thanks in advance for your answers, Pierre van de Laar --------------------------------------------------------------------- Date: Wed, 8 May 2019 16:28:21 -0400 From: Gershom B <gershomb(a)gmail.com> To: haskell-cafe <haskell-cafe(a)haskell.org>, haskell(a)haskell.org Subject: [Haskell-cafe] Announce: Haskell Platform 8.6.5 Message-ID: <CAM8RHpGB=mhYLJ_qDd__Td8vcJYBvZ66h0fErTU98H9DnWawmQ(a)mail.gmail.com> Content-Type: text/plain; charset="UTF-8" On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.6.5 Now available at https://eur01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.haske… This includes GHC 8.6.5, cabal-install 2.4.1.0, and stack 1.9.3. It is an incremental release over 8.6.3 intended mainly to make available bugfixes for windows in subsequent revisions in the 8.6 series and otherwise leave everything the same. These windows fixes are important, and it is recommended all windows users upgrade to 8.6.5 whether through the platform installer or some other mechanism. For detail on these changes and fixes see https://eur01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.haske… https://eur01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.haske… As with the 8.6.3 release, we are only providing core builds. Further, in 8.6.3 we moved from generic linux installers to recommending users install ghc through ghcup. As discussed in the last announcement, we have now moved to recommending os x users also use ghcup rather than a dedicated binary installer. For more details, please see the 8.6.3 announcement at https://eur01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fmail.hask… Happy Haskell Hacking all, Gershom ________________________________ The information contained in this message may be confidential and legally protected under applicable law. The message is intended solely for the addressee(s). If you are not the intended recipient, you are hereby notified that any use, forwarding, dissemination, or reproduction of this message is strictly prohibited and may be unlawful. If you are not the intended recipient, please contact the sender by return e-mail and destroy all copies of the original message.

7 8

Second Call for Tutorial Proposals: ICFP 2019
by Sam Tobin-Hochstadt 20 May '19

20 May '19

*EXTENDED DEADLINE* - CALL FOR TUTORIAL PROPOSALS ICFP 2019 24th ACM SIGPLAN International Conference on Functional Programming August 18 - 23, 2019 Berlin, Germany https://icfp19.sigplan.org/ The 24th ACM SIGPLAN International Conference on Functional Programming will be held in Berlin, Germany on August 18-23, 2019. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for tutorials, lasting approximately 3 hours each, to be presented during ICFP and its co-located workshops and other events. These tutorials are the successor to the CUFP tutorials from previous years, but we also welcome tutorials whose primary audience is researchers rather than practitioners. Tutorials may focus either on a concrete technology or on a theoretical or mathematical tool. Ideally, tutorials will have a concrete result, such as "Learn to do X with Y" rather than "Learn language Y". Tutorials may occur after ICFP co-located with the associated workshops, from August 22 till August 23. ---------------------------------------------------------------------- Submission details Deadline for submission: June 3rd, 2019 Notification of acceptance: June 10th, 2019 Prospective organizers of tutorials are invited to submit a completed tutorial proposal form in plain text format to the ICFP 2018 workshop co-chairs (Jennifer Hackett and Christophe Scholliers), via email to icfp-workshops-2019(a)googlegroups.com by June 3rd, 2019. Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by June 10th, 2019. The proposal form is available at: http://www.icfpconference.org/icfp2019-files/icfp19-tutorials-form.txt ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2019 organizing committee. Tutorials Co-Chair: Jennifer Hackett (University of Nottingham) Tutorials Co-Chair: Christophe Scholliers (University of Ghent) General Chair: Derek Dreyer (MPI-SWS) Program Chair: François Pottier ( Inria, France) ---------------------------------------------------------------------- Further information Any queries should be addressed to the tutorial co-chairs (Jennifer Hackett and Christophe Scholliers), via email to icfp-workshops-2019(a)googlegroups.com

1 0

How to dynamic plan in Haskell?
by Magicloud Magiclouds 20 May '19

20 May '19

Hi, I solved the question. But I could not figure out a FP style solution. Question: 1 - 9, nine numbers. Show all the possible combinations that sum up to 10. Different orders are counted as the same. For example, [1, 4, 5].

7 16

zstd package. Proposal to take over maintenance
by Luis Pedro Coelho 20 May '19

20 May '19

Hi everyone, The zstd package contains important bugs (it produces malformed output in some cases) and seems unmaintained. I would like to take over maintenance of it. I have actually forked the package and fixed the bugs, releasing it as hs-zstd: https://github.com/luispedro/hs-zstd http://hackage.haskell.org/package/hs-zstd I was advised to consider taking over maintenance of zstd as an earlier attempt to contact the maintainers of zstd was not answered. I would still prefer not to have this responsibility, but I would also like to use zstd in my work. * The zstd issues are not obvious because 99% of the time it works well, so we actually used it in a release of ngless, but after 3 days in the wild, we had to release a "bugfix". This is because most code paths work well, but there is one which produces a broken file. http://ngless.embl.de/whatsnew.html#version-0-11 Thanks, Luis Luis Pedro Coelho | Fudan University | http://luispedro.org https://orcid.org/0000-0002-9280-7885

1 0

First Call for Papers for IFL 2019 (Implementation and Application of Functional Languages)
by J. Stutterheim 19 May '19

19 May '19

Dear all, Please, find below the first call for papers for IFL 2019. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. Best regards, Jurriën Stutterheim --- ================================================================================ IFL 2019 31st Symposium on Implementation and Application of Functional Languages National University of Singapore September 25th-27th, 2019 http://2019.iflconference.org ================================================================================ ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2019 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications ### Keynote Speaker * Olivier Danvy, Yale-NUS College ### Submissions and peer-review Differently from previous editions of IFL, IFL 2019 solicits two kinds of submissions: * Regular papers (12 pages including references) * Draft papers for presentations ('weak' limit between 8 and 15 pages) Regular papers will undergo a rigorous review by the program committee, and will be evaluated according to their correctness, novelty, originality, relevance, significance, and clarity. A set of regular papers will be conditionally accepted for publication. Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. Regular papers not accepted for publication will be considered as draft papers, at the request of the author. Draft papers will be screened to make sure that they are within the scope of IFL, and will be accepted for presentation or rejected accordingly. Prior to the symposium: Authors of conditionally accepted papers and accepted presentations will submit a pre-proceedings version of their work that will appear in the draft proceedings distributed at the symposium. The draft proceedings does not constitute a formal publication. We require that at least one of the authors present the work at IFL 2019. After the symposium: Authors of conditionally accepted papers will submit a revised versions of their paper for the formal post-proceedings. The program committee will assess whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. Our interest is to ultimately accept all conditionally accepted papers. If you are an author of a conditionally accepted paper, please make sure that you address all the concerns of the reviewers. Authors of accepted presentations will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal post-proceedings. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected. ### Publication The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication ### Important dates Submission of regular papers: May 31, 2019 Submission of draft papers: July 15, 2019 Regular and draft papers notification: August 1, 2019 Deadline for early registration: August 15, 2019 Submission of pre-proceedings version: September 15, 2019 IFL Symposium: September 25-27, 2019 Submission of papers for post-proceedings: November 30, 2019 Notification of acceptance: January 31, 2020 Camera-ready version: February 29, 2020 ### Submission details All contributions must be written in English. Papers must use the ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2019 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jurrien Stutterheim (Standard Chartered Bank Singapore), Wei Ngan Chin (National University of Singapore) Program Committee: - Olaf Chitil, University of Kent - Clemens Grelck, University of Amsterdam - Daisuke Kimura, The University of Tokyo - Pieter Koopman, Radboud University - Tamás Kozsik, Eötvös Loránd University - Roman Leschinskiy, Facebook - Ben Lippmeier, The University of New South Wales - Marco T. Morazan, Seton Hall University - Sven-Bodo Scholz, Heriot-Watt University - Tom Schrijvers, Katholieke Universiteit Leuven - Alejandro Serrano, Utrecht University - Tony Sloane, Macquarie University - Simon Thompson, University of Kent - Marcos Viera, Universidad de la República - Wei Ngan Chin, NUS - Jurriën Stutterheim, Standard Chartered Bank ### Venue The 30th IFL is organized by the University of Massachusetts Lowell. The City of Lowell is located at the heart of the Merrimack Valley just 30 miles northwest of Boston. Lowell can be easily reached by train or taxi. See the website for more information on the venue. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organizers for their work, which is reused here. A part of IFL 2019 format and CFP language that describes conditionally accepted papers has been adapted from call-for-papers of OOPSLA conferences.

2 1

Mocking out external services
by Francesco Ariis 19 May '19

19 May '19

(literate Haskell follows) Hello -cafe, I recently read "Three Layer Haskell Cake" [1] and decided to give it a go. I am stuck on a simple problem and feel like I am missing something easy. One of the first examples is a mocking of an `IO UTCTime` function. > > {-# Language FlexibleInstances #-} > > data UTCTime = UTCTime Int > > class MonadTime m where > getCurrentTime :: m UTCTime > > instance MonadTime ((->) UTCTime) where > getCurrentTime = id > > -- instance IO omitted > Everything is clear. I decided to write another function, mocking a stream-of-Char input. > > class MonadKeys m where > getKeys :: m [Char] > > instance MonadKeys ((->) [Char]) where > getKeys = id > > -- instance IO omitted > Again, fine. But now, if I want to write a function which combines the two external services, like: > > someFun :: (MonadTime m, MonadKeys m) => m () > someFun = undefined > there is no non-IO instance satisfying the two constraints. I could of course write a type > > data Env = Env UTCTime [Char] > and make it instance of MonadTime and MonadKeys, but then I am passing non-relevant arguments to a mocked function like getCurrentTime, which would only need UTCTime. What am I doing incorrectly? -F [1] https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html

2 2

Identity operator for types
by Juan Miguel Vilar 17 May '19

17 May '19

Hi, Café: I am not sure how to make the question, but the idea is to have a type operator that returns the same type. Let me show what I need. I have some type like this: data Example f t = Example (f t) So if I want a type variable that contains a list of integers, I can use Example [] Int and then treat the content like a list: f :: Example [] Int -> Int f (Example l) = length l Now, the problem is what can I do to have a type that contains a single Int? Is there a sort of id for types so that I can write f :: Example ?? Int -> Int f (Example i) = 2 * i ? Thanks in advance Juan Miguel Vilar -- Juan Miguel Vilar Torres Profesor titular de universidad Departamento de Lenguajes y Sistemas Informáticos Escuela Superior de Tecnología y Ciencias Experimentales Universitat Jaume I Av. de Vicent Sos Baynat s/n 12071 Castelló de la Plana (Spain) Tel: +34 964 72 8365 Fax: +34 964 72 8435 jvilar(a)uji.es

4 6

How to express a logic matrix clearly?
by Magicloud Magiclouds 17 May '19

17 May '19

Hi, I have trouble describing this clearly. Let me show code directly. data Rule1 = A1 | A2 | A3 data Rule2 = B1 | B2 | B3 foo a b = if a == A1 then if b == B1 then fun1 else if b == B2 then fun2 else if b == B3 then fun3 else fun4 ... Basically, Rule1 and Rule2 compose a matrix, for each case of Rule1 and Rule2, I need to do different things. Above is already long and not quite clear, and it is far from complete. So my question is, is there a way/lib that I can make this clear to read/understand?

4 5

Re: [Haskell-cafe] Dispatching user code at runtime, injecting appropriate typeclass instances into user code scope
by Evgeny Permyakov 16 May '19

16 May '19

Hi. reflection is about selecting a type instance of a typeclass that is known to exist over type. Completely different thing. Monads ... I guess, using monadic context in some way is an option, but not exactly what I have in mind. Still, worth looking into. On Thu, 16 May 2019 at 10:20, Georgi Lyubenov <godzbanebane(a)gmail.com> wrote: > Hi, > > It seems like the "extensible" parts you want is something similar to most > extensible effects stuff. Perhaps check out the "Member stuff" from the > "Freer Monads, More Extensible Effects" paper and some EE libraries > (freer-simple, fused-effects, polysemy)? Also, if you want runtime > typeclasses reflection <http://hackage.haskell.org/package/reflection> can > help. > > ======= > Georgi >

1 0

Dispatching user code at runtime, injecting appropriate typeclass instances into user code scope
by Evgeny Permyakov 16 May '19

16 May '19

Let's suppose that at runtime I create a hardware context and test it for a set of supported operation and want to adapt the way I work with it based on the set of operations available. (RL example: OpenGL extension discovery and use) Naturally, I can create a function that checks hardware and then, based on the result, returns different dictionaries of functions over the context, maybe as closures. This is verbose and crude, even if it shall work. However, I want to work with the context using a typeclass interface. It isn't hard when number of options is low. I suppose, we can use something like typeclass Context a where > { dispatch :: MonadIO m => forall k . Context a -> (forall a . Testable1 > a -> a -> m k) -> (forall a. Testable2 a -> a -> m k ) -> a -> m k } > Here, Context typeclass defines a function that selects appropriate handler from the set of user-provided functions and each instance takes the function it likes. Fine. The problems are twofold: - This is not extensible, the set of possible cases is defined on the definition of Context typeclass - This approach is hardly appropriate if we have a lot of cases, For example, if context may support ten optional operation sets in addtion to basic one, the number of possible cases *dispatch* needs to support A more modular approach is needed, something like (pseudocode) dispatch :: typeclassSet Defined, -- collection of defined typeclasses typeClass Tested, -- what we test for Dispatchable a, Defined a -- what we test =>forall b. (forall a . Defined a => a -> b) -- 'fallback' function -> (forall a . Defined a, Tested a => a -> b) -- this is called if A supports Tested interface. -> b This way one can gradually inject typeclass instances into scope. But how I can do it? PS. Naturally, I don't want to expose internals of the type I dispatch over, it is an abstract type.

1 0

Speeding up compilation of a happy generated parser
by Nathan Bloomfield 15 May '19

15 May '19

Hello all! I'm using Alex/Happy to generate a parser for PHP. This is my first go at using a parser generator instead of parser combinators and it's been going pretty smoothly so far, but I've hit a snag. Compiling the happy-generated parser is excruciatingly slow -- 20+ minutes with -O0 -- which messes up the typically very fast feedback loop haskell+ghci allows. Running the code is great; my quickcheck test suite is very fast. But compiling and loading into ghci are so slow that iterating on the project further is not practical until I can figure out how to speed it up. Are there any folklore techniques for dealing with this problem, or any resources about how to profile/debug slow compilation? I'm on macos using Stack with lts-13.21, which includes happy-1.19.10. I tried the ideas in this known issue: https://github.com/simonmar/happy/issues/109. I also tried downgrading to lts-6.35 (the most recent with GHC 7.*), all with similar results. I imagine some of this slowdown is inevitable because of the grammar's size; it has ~275 nonterminals and the generated `Parser.hs` module is 3.8MB. Usually for a problem like this I'd break the module up into smaller pieces that won't change as often, but in this case it's an opaque monolith generated by happy. I also see that the generated code doesn't have type signatures on all top level functions. Here's the relevant output from GHC with -v2 enabled: ``` *** Parser [PHP.Parse.Parser]: !!! Parser [PHP.Parse.Parser]: finished in 1980.24 milliseconds, allocated 3155.733 megabytes *** Renamer/typechecker [PHP.Parse.Parser]: !!! Renamer/typechecker [PHP.Parse.Parser]: finished in 243923.86 milliseconds, allocated 178189.005 megabytes *** Desugar [PHP.Parse.Parser]: Result size of Desugar (before optimization) = {terms: 1,346,664, types: 672,082,252, coercions: 789, joins: 0/9,651} Result size of Desugar (after optimization) = {terms: 834,353, types: 285,053,589, coercions: 246,053, joins: 235/735} !!! Desugar [PHP.Parse.Parser]: finished in 103983.68 milliseconds, allocated 17597.213 megabytes *** Simplifier [PHP.Parse.Parser]: Result size of Simplifier iteration=1 = {terms: 1,059,012, types: 69,942,882, coercions: 1,934,739, joins: 235/1,935} Result size of Simplifier iteration=2 = {terms: 815,760, types: 64,805,160, coercions: 1,368,873, joins: 233/1,929} Result size of Simplifier = {terms: 776,400, types: 64,474,214, coercions: 1,297,320, joins: 233/1,929} !!! Simplifier [PHP.Parse.Parser]: finished in 197842.50 milliseconds, allocated 116983.797 megabytes *** CoreTidy [PHP.Parse.Parser]: Result size of Tidy Core = {terms: 776,400, types: 64,474,214, coercions: 1,297,320, joins: 233/1,929} !!! CoreTidy [PHP.Parse.Parser]: finished in 97776.92 milliseconds, allocated 11254.968 megabytes *** CorePrep [PHP.Parse.Parser]: Result size of CorePrep = {terms: 795,714, types: 66,237,082, coercions: 1,297,320, joins: 233/4,234} !!! CorePrep [PHP.Parse.Parser]: finished in 7911.78 milliseconds, allocated 2564.067 megabytes *** Stg2Stg: *** CodeGen [PHP.Parse.Parser]: !!! CodeGen [PHP.Parse.Parser]: finished in 7048.73 milliseconds, allocated 6407.563 megabytes *** Assembler: *** CorePrep [PHP.Parse.Parser]: Result size of CorePrep = {terms: 795,714, types: 66,237,082, coercions: 1,297,320, joins: 233/4,234} !!! CorePrep [PHP.Parse.Parser]: finished in 3069.67 milliseconds, allocated 2564.018 megabytes *** Stg2Stg: *** CodeGen [PHP.Parse.Parser]: !!! CodeGen [PHP.Parse.Parser]: finished in 5970.62 milliseconds, allocated 6634.422 megabytes *** Assembler: *** Deleting temp files: Warning: deleting non-existent /var/folders/td/sxyy9wl919740vddr49g8nth0000gn/T/ghc1272_0/ghc_70.s Warning: deleting non-existent /var/folders/td/sxyy9wl919740vddr49g8nth0000gn/T/ghc1272_0/ghc_72.c Warning: deleting non-existent /var/folders/td/sxyy9wl919740vddr49g8nth0000gn/T/ghc1272_0/ghc_74.c ``` -- Nathan Bloomfield Systems Analyst, Team Neutron Automattic, Inc.

1 0

Metaprogramming Summer School (August 2019): call for applications
by Jeremy Yallop 15 May '19

15 May '19

==================================================================== Second International Summer School on Metaprogramming Schloss Dagstuhl, Leibniz Center for Informatics, Germany 11th-16th August 2019 (the week before ICFP'19) https://www.cl.cam.ac.uk/events/metaprog/2019/ ==================================================================== Metaprogramming is an approach to constructing programs by treating program fragments (such as expressions or types) as values that the program can manipulate. Metaprogramming comes in various forms --- for example, * in dependently-typed programming terms appear within types, supporting the construction of precise specifications of functions and data. * in multi-stage programming expressions are program values, making it possible to write safe program generation programs that can significantly improve performance. * in languages with macros programs execute partly during compilation and partly at run-time, eliminating the sharp distinction between built-in and user-defined constructs. * embedded domain-specific languages reuse host language features such as syntax and type-checking for convenient definition of little languages suited to a particular endeavour. Metaprogramming has many applications, including genericity, proof automation, language extensibility and user-defined optimization. The goal of the summer school is to explore the state-of-the art in metaprogramming and its applications, covering both theory and practice. -------------------------------------------------------------------- Lecturers and courses Oleg Kiselyov (Tohoku University) From the tagless-final cookbook: simple hardware description language and optimization-by-evaluation Matthew Flatt (University of Utah) Building Languages with Racket Conor McBride (University of Strathclyde) TBD Jonathan Protzenko (Microsoft Research Redmond) Meta-F*: efficient meta-programming of the F* compiler at every stage -------------------------------------------------------------------- Prerequisites The school is aimed at graduate students in programming languages and related areas, but is open to researchers, practitioners and strong masters students with the support of a supervisor. Some experience of typed functional programming in Haskell, OCaml, Scala, or a similar language will be assumed. -------------------------------------------------------------------- Costs Thanks to the Schloss Dagstuhl subsidies, accommodation costs are as follows, and the dates are immediately before ICFP'19 (also in Germany): Single-occupancy accommodation: €420 Double-occupancy accommodation: €330 Accommodation costs include full board (in a single- or double-occupancy room, including meals during stay) from Sunday 11 August (evening) to Friday 16 August (afternoon). -------------------------------------------------------------------- Application procedure You will need to complete the online registration form at: https://www.cl.cam.ac.uk/events/metaprog/2019/application.html and ensure your referees send your references to: metaprog-2019(a)cl.cam.ac.uk by the application deadline. TIMETABLE * 30 June: Application and reference letters deadline. * 10 July: Notification of acceptance. * 11 August: Summer school. -------------------------------------------------------------------- Further information For any questions relating to the school, please contact the organisers (Jeremy Yallop, Ohad Kammar, Yukiyoshi Kameyama) at metaprog-2019(a)cl.cam.ac.uk

1 0

[ANN] stdio-0.2.0.0
by Dong Han 15 May '19

15 May '19

Dear Haskellers, Today I'm very happy to announce a new beta version of stdio is released on hackage <http://hackage.haskell.org/package/stdio>, there're some large additions in this version: - Add UDP module. - Add JSON module. - Add ToText class to Std.Data.TextBuilder module. The largest addition is a new JSON module, features full RFC 8259 compliance <https://github.com/haskell-stdio/JSONTestSuite> and 2~3x faster performance <https://github.com/haskell-stdio/stdio/tree/master/bench/json>. Try to bring big improvements over a very mature library like aeson is not an easy task, parts of the improvements come from faster Parser and Builder infrastructures in stdio. But we also made a few other improvements: - To improve building lookup table during JSON parsing(and many other formats as well), An ordered map module based on sorted vectors and binary-search is also added, there're actually four modules providing similar functions to containers: - Std.Data.Vector.FlatMap - Std.Data.Vector.FlatIntMap - Std.Data.Vector.FlatSet - Std.Data.Vector.FlatIntSet These data structures have different time and memory characteristics from tree-based ones, and suits some situations better, e.g. intermediate lookup table. - To improve JSON string parsing, we made an UTF-8 validation state machine with JSON unescaping logic built-in written in C, combine with the ability to scan a whole chunk of input(provided by our new Parser, namely scanChunks), we now have faster JSON string parsing performance than some native code(JSON.parse from nodejs). - Numeric parsing is also improved, e.g. we changed Integer decoding loop to use machine words if range permits, then covert the result to Integer rather than use Integer all the time. There're also lots of improvements and simplifications contribute to faster performance. Overall this is good proof that our new Parser and Builder infrastructures work well. Besides the JSON module, another important addition is the ToText class in Std.Data.TextBuilder, which is also derivable via generics. The format is chosen to follow Show class as much as possible, this is a very handy class when you need to quickly turn something into a builder or text. A UDP module is added quite easily since the IO manager part is in place. Due to the message based nature, the API is quite different from TCP, design suggestions are welcomed! Happy hacking! ~Cheers Han Dong

1 0

Scrap your boilerplate
by The FLOSS Information 15 May '19

15 May '19

4 4

You're invited to the New York Haskell CoHack
by Chris Smith 14 May '19

14 May '19

Fellow Haskellers, In cooperation with the New York Haskell User Group, I'm now organizing a monthly co-hacking event for Haskell programmers in New York. We are meeting on June 1st, and the first Saturday of each month after that. (However, to avoid the U.S. holiday weekend, we're meeting on June 29 instead of July 6.) More details and RSVP form at https://www.meetup.com/NY-Haskell/events/261245898/ This is an informal event where you can meet and collaborate with the rest of the Haskell community in New York. I am taking the format from the Atlanta Haskathon <https://www.meetup.com/Atlambda-Haskathon/>, where it's worked really well. We'll have time for lightning talks, and then open hacking time. To stay focused on project work, we will ask everyone to state a goal for the day, and check in on progress when we're wrapping up. Your choice of goal, though, is entirely up to you. You can use the time to collaborate on a project, get help learning Haskell or advice on using libraries or tools, help others, or just work by yourself. There will be refreshments provided courtesy of the Microsoft Reactor space.

1 0

Cabal revision online form silently converts file to Windows line endings, breaking patches
by Niklas Hambüchen 14 May '19

14 May '19

I noticed that if you use Hackage's online Cabal file editor, it changes all your \n line endings to \r\n. This breaks all patches written against upstream .cabal files. For example, if I write a patch against `cachix-0.2.0` git repo's .cabal file, I can no longer apply it to whatever revisions of it Hackage has, even if there's no real conflict. Here's a reproduction (I changed only 1 line in the editor, and it shows the whole file as changed): diff -u <(curl https://hackage.haskell.org/package/AesonBson-0.2.0/revision/0.cabal) <(curl https://hackage.haskell.org/package/AesonBson-0.2.0/revision/1.cabal) I found this especially problematic for nixpkgs, where patching packages is a common practice.

6 6

How to optimize a directory scanning?
by Magicloud Magiclouds 12 May '19

12 May '19

Hi, I have asked this in Stackoverflow without getting an answer. Wondering if people here could have some thoughts. I have a function reading the content of /proc every second. Surprisingly, its CPU usage in top is around 5%, peak at 8%. But same logic in C or Rust just takes like 1% or 2%. Wondering if this can be improved. /proc is virtual filesystem, so this is not related to HDD performance. And I noticed this difference because my CPU is too old (Core Gen2). On modern CPU, as tested by others, the difference is barely noticeable. import Control.Exception import Control.Concurrent import Control.Monad import Data.Char import Data.Maybe import System.Directory import System.FilePath import System.Posix.Files import System.Posix.Signals import System.Posix.Types import System.Posix.User import System.IO.Strict as Strict watch u limit0s limit0h = do listDirectory "/proc/" >>= mapM_ (\fp -> do isMyPid' <- maybe False id <$> wrap2Maybe (isMyPid fp u) wrap2Maybe (Strict.readFile ("/proc/" </> fp </> "stat"))) threadDelay 1000000 watch u limit0s limit0h where wrap2Maybe :: IO a -> IO (Maybe a) wrap2Maybe f = catch ((<$>) Just $! f) (\(_ :: IOException) -> return Nothing) isMyPid :: FilePath -> UserID -> IO Bool isMyPid fp me = do let areDigit = fp >= "0" && fp <= "9" isDir <- doesDirectoryExist $ "/proc/" </> fp owner <- fileOwner <$> getFileStatus ("/proc" </> fp) return $ areDigit && isDir && (owner == me) -- 竹密岂妨流水过山高哪阻野云飞

10 18

LFVM-STG Compilation
by james faure 10 May '19

10 May '19

Hello, I want to introduce the STG backend I am currently working on: https://github.com/jfaure/lfvm-stg I'd love to see how much interest there is for this, to receive any comments, and find out if I've missed anything ! The goal is to massively speed up compilation times and generate faster and clearer code, and in that respect I am already quite successful. Llvm is very well suited for encoding a (lazy) functional language, however the evaluation mechanism is very different to ghc's stg, there is notably no continuation passing nor result registers. In LFVM, all non constant let bindings are given an llvm function. I believe this approach is more natural, the llvm more accurately reflects the source code and we get proper stack traces in a debugger. Status: The project is barely a month old, and I'm working to support everything ghc's code generation supports. The STG is heavily based on the one found in ghc and, at this time and as far as I can tell, supports everything except multithreading, a gc and lazy evaluation. The current idea I think is very promising is to use an inferred pi calculus to elegantly implement all 3 missing parts at once. Pi calculus [1] (process calculus) In the STG * Multithreading occurs for arguments of functions with >1 arity * Perfect garbage collection is quite probably possible [2], where allocation creates a new pi name, and its uses are modeled by pi calculus communication * Perfect Lazy evaluation (in the sense that the wrapper and associated wrapped type overhead is coerced away after the first evaluation) is possible in the pi calculus and closely linked the gc model. I intend to make strict evaluation the default, If you want lazy (for MonadFix or infinite lists or whatever), you must request it. [1]: https://en.wikipedia.org/wiki/%CE%A0-calculus [2]: https://www.researchgate.net/publication/228514964_Resources_garbage-collec… James Faure (Discord: J4#0303)

6 7

Need help understanding Ralf Hinze's Lifting Lemma, and its connection to the Transfer Principle
by Brian Merchant 10 May '19

10 May '19

Hi all, I am a student in mathematics exploring alternative ways in which the transfer principle ( https://en.wikipedia.org/wiki/Transfer_principle ) can be proved. I've found a paper by Ralf Hinze which I think is relevant: https://www.cs.ox.ac.uk/ralf.hinze/Lifting.pdf. However, I'd benefit from being able to talk to someone who understands the notation starting section 3 and onwards, as I am very much a Haskell newbie (everything I have learned, has been in the last 4 days, as I try to decipher this paper). Would anyone be willing to have a conversation with me regarding this? Kind regards, Brian

2 1

FHPNC'19 Deadline Extension and 2nd Call for Papers
by Marco Zocca 09 May '19

09 May '19

We are happy to extend the submission deadline to the 2019 ACM SIGPLAN Functional High Performance and Numerical Computing Workshop until Saturday, May 25, 2019, 12 PM AoE ("anywhere on Earth", i.e. UTC-6). Marco Zocca and Dominic Steinitz FHPNC'19 Organizing Committee ================================= 2nd Call for Papers (Extended Abstracts and Full Papers) ACM SIGPLAN Workshop on Functional High-Performance and Numerical Computing (FHPNC), Berlin, August 18, 2019 Satellite event of the 24th ACM SIGPLAN International Conference on Functional Programming (ICFP 2019) 18 - 23 August, 2019 Homepage : https://icfp19.sigplan.org/home/FHPNC-2019#Call-for-Papers The ACM SIGPLAN International Workshop on Functional High-Performance and Numerical Computing aims to bring together researchers and practitioners exploring or employing the use of functional or declarative programming languages or techniques in scientific computing, and specifically in the domains of high-performance computing and numerical programming. The purpose of the meeting is to enable sharing of results, experiences, and novel ideas about how high-level, declarative techniques can help make high-performance, distributed/parallel, or numerically-intensive code dealing with computationally challenging problems easier to write, read, maintain, or portable to new hardware architectures. Areas of interest include, but are not limited to: * relevant compiler technologies * runtime systems (including fault tolerance mechanisms and those supporting distributed or parallel computation) * domain-specific languages (embedded or standalone) * type systems * formal methods * software libraries (e.g. for exact or interval arithmetic). ## Submission details Submissions should fall into one of two categories: * Regular research papers (up to 12 pages) * Extended abstracts (1 - 2 pages) The bibliography will not be counted against the page limits for either category. Regular research papers are expected to present novel and interesting research results, and will be included in the formal proceedings. Extended abstracts should report work in progress that the authors would like to present at the workshop; they will be evaluated primarily for relevance and interest. Extended abstracts will be distributed to workshop attendees but will not be published in the formal proceedings. We welcome submissions from PC members (with the exception of the PC Chair), but these submissions will be held to a higher standard. Submission is handled through the HotCRP site. All submissions should be in portable document format (PDF) and formatted using the ACM SIGPLAN style guidelines. Submissions written with LaTeX are required to use the ‘acmart’ format and the two-column ‘sigplan’ subformat (not to be confused with the one-column ‘acmlarge’ subformat!). Extended Abstracts must be submitted with the label ‘Extended abstract’ clearly in the title. ## Publication The proceedings of FHPNC 2019 will be published in the ACM Digital Library. ## Related links * Author Information and LaTeX templates : http://www.sigplan.org/Resources/Author/ * Attendee Code of Conduct: http://www.sigplan.org/Resources/Policies/CodeOfConduct/

1 0

Invititation to provide feedback on RISC-V ISA Formal Specs
by Rishiyur Nikhil 09 May '19

09 May '19

The RISC-V Foundation (riscv.org) has a task group to develop a Formal Spec for the RISC-V Instruction Set Architecture. The group has been pursuing several approaches: - 3 are written in Haskell - 1 is in SAIL, a DSL with dependent types, intended for ISA specs - 1 is in Kami, a DSL in Coq Most of them are complete enough to boot Linux, i.e., they are not for toy subsets of the ISA. They are expected and intended to become the "official" ISA spec for RISC-V, and to be used in anger, for compliance testing, formal verification of compilers, hardware designs, etc. We would love to get community feedback on these approaches. The following link provides an overview, and links to individual web sites (all on GitHub) for the 5 approaches, and information on how to provide feedback: https://github.com/riscv/ISA_Formal_Spec_Public_Review Thanks very much in advance! Rishiyur Nikhil, Chair, ISA Formal Spec Technical Group

1 0

Announce: Haskell Platform 8.6.5
by Gershom B 08 May '19

08 May '19

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.6.5 Now available at https://www.haskell.org/platform/ This includes GHC 8.6.5, cabal-install 2.4.1.0, and stack 1.9.3. It is an incremental release over 8.6.3 intended mainly to make available bugfixes for windows in subsequent revisions in the 8.6 series and otherwise leave everything the same. These windows fixes are important, and it is recommended all windows users upgrade to 8.6.5 whether through the platform installer or some other mechanism. For detail on these changes and fixes see https://www.haskell.org/ghc/blog/20190305-ghc-8.6.4-released.html https://www.haskell.org/ghc/blog/20190423-ghc-8.6.5-released.html As with the 8.6.3 release, we are only providing core builds. Further, in 8.6.3 we moved from generic linux installers to recommending users install ghc through ghcup. As discussed in the last announcement, we have now moved to recommending os x users also use ghcup rather than a dedicated binary installer. For more details, please see the 8.6.3 announcement at https://mail.haskell.org/pipermail/haskell-cafe/2018-December/130371.html Happy Haskell Hacking all, Gershom

1 0

how to debug segfaults in ghc-compiled executable?
by Johannes Waldmann 08 May '19

08 May '19

Dear Cafe, I keep getting spurious segfaults from a dynamically linked executable compiled by ghc. In dmesg: [402186.145258] pure-matchbox:w[25362]: segfault at 7f98644a5c00 ip 00000000017ab65e sp 00007f98377f9988 error 4 [402186.145262] Code: b8 0a 7e 77 01 48 83 ec 08 48 89 df 48 89 c3 31 c0 ff d3 48 83 c4 08 48 8b 1c 25 50 90 a7 01 48 89 c1 48 6b c9 18 48 83 c1 10 <48> 83 3c 0b 00 74 30 48 8b 1c 25 50 90 a7 01 48 6b c0 18 48 83 c0 How can I find out what part of the program this refers to? The error might be related to external libraries (used by hmatrix-glpk) but I don't know how to verify this. When I look at the output of `nm´ for this executable, I am not seeing any address like 00017ab65e. I do not have a concrete reproducible test case, but the bug happens statistically (say, in one out of 1000 runs). - J.

2 1

Journal of Functional Programming - Call for PhD Abstracts
by Graham Hutton 08 May '19

08 May '19

Dear all, If you or one of your students recently completed a PhD in the area of functional programming, please submit the dissertation abstract for publication in JFP: simple process, no refereeing, open access, deadline 31st May 2019. Please share! Best wishes, Graham Hutton ============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 31st May 2019 http://tinyurl.com/jfp-phd-abstracts ============================================================ PREAMBLE: Many students complete PhDs in functional programming each year. As a service to the community, twice per year the Journal of Functional Programming publishes the abstracts from PhD dissertations completed during the previous year. The abstracts are made freely available on the JFP website, i.e. not behind any paywall. They do not require any transfer of copyright, merely a license from the author. A dissertation is eligible for inclusion if parts of it have or could have appeared in JFP, that is, if it is in the general area of functional programming. The abstracts are not reviewed. Please submit dissertation abstracts according to the instructions below. We welcome submissions from both the PhD student and PhD advisor/supervisor although we encourage them to coordinate. ============================================================ SUBMISSION: Please submit the following information to Graham Hutton <graham.hutton(a)nottingham.ac.uk> by 31st May 2019: o Dissertation title: (including any subtitle) o Student: (full name) o Awarding institution: (full name and country) o Date of PhD award: (month and year; depending on the institution, this may be the date of the viva, corrections being approved, graduation ceremony, or otherwise) o Advisor/supervisor: (full names) o Dissertation URL: (please provide a permanently accessible link to the dissertation if you have one, such as to an institutional repository or other public archive; links to personal web pages should be considered a last resort) o Dissertation abstract: (plain text, maximum 350 words; you may use \emph{...} for emphasis, but we prefer no other markup or formatting; if your original abstract exceeds the word limit, please submit an abridged version within the limit) Please do not submit a copy of the dissertation itself, as this is not required. JFP reserves the right to decline to publish abstracts that are not deemed appropriate. ============================================================ PHD ABSTRACT EDITOR: Graham Hutton School of Computer Science University of Nottingham Nottingham NG8 1BB United Kingdom ============================================================ 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

[TFPIE'19] Final call for papers: Trends in Functional Programming in Education 2019, 11 June 2019, Vancouver, BC, CA
by Peter Achten 08 May '19

08 May '19

TFPIE 2019 Call for papers http://www.staff.science.uu.nl/~hage0101/tfpie2019/index.html (June 11th, University of British Columbia, Vancouver Canada, co-located with TFP 2019) TFPIE 2019 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. On top of the lecture itself, the presentation can also provide commentary on the lecture. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 16 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2019 After the workshop, presenters will be invited to submit (a revised version of) their article for review. The PC will select the best articles that will be published in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Dates Submission deadline: May 14th 2019, Anywhere on Earth. Notification: May 20th Workshop: June 11th Submission for formal review: August 18th 2019, Anywhere on Earth Notification of full article: October 6th Camera ready: November 1st Program Committee Alex Gerdes - University of Gothenburg / Chalmers Jurriaan Hage (Chair) - Utrecht University Pieter Koopman - Radboud University, the Netherlands Elena Machkasova - University of Minnesota, Morris, USA Heather Miller - Carnegie Mellon University and EPFL Lausanne Prabhakar Ragde - University of Waterloo, Waterloo, Ontario, Canada Simon Thompson - University of Kent, UK Sharon Tuttle - Humboldt State University, Arcata, USA Note: information on TFP is available at https://www.tfp2019.org/index.html

1 0

[TFP'19] final call for papers (deadline extension): Trends in Functional Programming 2019, 12-14 June 2019, Vancouver, BC, CA
by Peter Achten 08 May '19

08 May '19

-------------------------------- F I N A L C A L L F O R P A P E R S -------------------------------- ====== TFP 2019 ====== 20th Symposium on Trends in Functional Programming 12-14 June, 2019 Vancouver, BC, CA https://www.tfp2019.org/index.html == Important Dates == Sumbission Deadline for Draft Papers Thursday, May 16, 2019 ** extended deadline ** Notification for Draft Papers Tuesday, May 21, 2019 ** extended deadline ** TFPIE Tuesday, June 11, 2019 Symposium Wednesday, June 12, 2019 – Friday, June 14, 2019 Notification of Student Paper Feedback Friday June 21, 2019 Submission Deadline for revised Draft Papers (post-symposium formal review) Thursday, August 1, 2019 Notification for post-symposium submissions Thursday, October 24, 2019 Camera Ready Deadline (both pre- and post-symposium) Friday, November 29, 2019 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 (see below at scope). Please be aware that TFP uses two distinct rounds of submissions (see below at submission details). TFP 2019 will be the main event of a pair of functional programming events. TFP 2019 will be accompanied by the International Workshop on Trends in Functional Programming in Education (TFPIE), which will take place on June 11. == Scope == The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles: Leading-edge, previously unpublished research work Position Articles: On what new trends should or should not be Project Articles: Descriptions of recently started new projects Evaluation Articles: What lessons can be drawn from a finished project Overview Articles: Summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: Functional programming and multicore/manycore computing Functional programming in the cloud High performance functional computing Extra-functional (behavioural) properties of functional programs Dependently typed functional programming Validation and verification of functional programs Debugging and profiling for functional languages Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. Interoperability with imperative programming languages Novel memory management techniques Program analysis and transformation techniques Empirical performance studies Abstract/virtual machines and compilers for functional languages (Embedded) domain specific languages New implementation strategies Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2019 program chairs, William J. Bowman and Ron Garcia. == Best Paper Awards == To reward excellent contributions, TFP awards a prize for the best paper accepted for the formal proceedings. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, that paper will then receive both prizes. == Instructions to Author == Papers must be submitted at: https://easychair.org/conferences/?conf=tfp2019 Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. == Pre-symposium formal review == Papers to be formally reviewed before the symposium should be submitted before an early deadline and receive their reviews and notification of acceptance for both presentation and publication before the symposium. A paper that has been rejected in this process may still be accepted for presentation at the symposium, but will not be considered for the post-symposium formal review. == Post-symposium formal review == Papers submitted for post-symposium review (draft papers) will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback received at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. == Paper categories == There are two types of submission, each of which can be submitted either for pre-symposium or post-symposium review: Extended abstracts. Extended abstracts are 4 to 10 pages in length. Full papers. Full papers are up to 20 pages in length. Each submission also belongs to a category: research position project evaluation overview paper Each submission should clearly indicate to which category it belongs. Additionally, a draft paper submission—of either type (extended abstract or full paper) and any category—can be considered a student paper. A student paper is one for which primary authors are research students and the majority of the work described was carried out by the students. The submission should indicate that it is a student paper. Student papers will receive additional feedback from the PC shortly after the symposium has taken place and before the post-symposium submission deadline. Feedback is only provided for accepted student papers, i.e., papers submitted for presentation and post-symposium formal review that are accepted for presentation. If a student paper is rejected for presentation, then it receives no further feedback and cannot be submitted for post-symposium review. == Format == Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site (http://www.springer.com/lncs) == Program Committee == Program Co-chairs William J. Bowman University of British Columbia Ronald Garcia University of British Columbia Matteo Cimini University of Massachusetts Lowell Ryan Culpepper Czech Technical Institute Joshua Dunfield Queen's University Sam Lindley University of Edinburgh Assia Mahboubi INRIA Nantes Christine Rizkallah University of New South Wales Satnam Singh Google AI Marco T. Morazán Seton Hall University John Hughes Chalmers University and Quviq Nicolas Wu University of Bristol Tom Schrijvers KU Leuven Scott Smith Johns Hopkins University Stephanie Balzer Carnegie Mellon University Viktória Zsók Eötvös Loránd University

1 0

ANN: tensor-safe-0.1.0.1
by Leonardo Piñeyro 08 May '19

08 May '19

Hello everyone, I’m happy to announce a preliminary release of what I called TensorSafe, a library to build structurally correct deep neural networks using dependent types in Haskell. Currently, it also provides the option to compile the models to external frameworks like Keras for Python or Keras JavaScript. I’ve built this as a part of what it is my capstone project to get my degree in computer engineering this year. I’ve learned a ton in a few months, especially thanks to projects like Grenade and the MM Haskell blogs 🙌 I’m still working on details but I think it’s ready for anyone to take a look at it. Any feedback is welcome! • http://hackage.haskell.org/package/tensor-safe • https://github.com/leopiney/tensor-safe Thanks!

1 0