- Haskell-Cafe - Haskell.org

Haskell internship at Tsuru Capital
by Mikhail Baykov 30 Aug '19

30 Aug '19

Hi Cafe It's that time of year again and we are looking for more interns. Haskell knowledge is required, experience with pricing futures/options would be nice but not necessary. Located in Tokyo, company language is English. Casual environment, nice monitors and a big coffee machine. Duration 3-6 months, starting at your convenience. We will help you with visa and looking for a place to stay. There's some salary. Details how to apply are on our website: http://www.tsurucapital.com/en/ Feel free to ask questions here, on Reddit or #tsurucapital on freenode. https://www.reddit.com/r/haskell/comments/cx8yei/tsuru_capital_is_looking_f…

1 0

First call for draft papers for TFPIE 2020 (Trends in Functional Programming in Education)
by Jurriaan Hage 28 Aug '19

28 Aug '19

Hello, Please, find below the final call for draft papers for TFPIE 2020. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Chair of TFPIE 2020 ======================================================================== TFPIE 2020 Call for papers http://www.staff.science.uu.nl/~hage0101/tfpie2020/index.html February 12th 2020, Krakow, Poland (co-located with TFP 2020 and Lambda Days) TFPIE 2020 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 20 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=tfpie2020 . 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: January 14th 2020, Anywhere on Earth. Notification: January 17th 2020 TFPIE Registration Deadline: January 20th 2020 Workshop: February 12th 2020 Submission for formal review: April 19th 2020, Anywhere on Earth. Notification of full article: June 6th 2020 Camera ready: July 1st 2020 Program Committee Olaf Chitil - University of Kent Youyou Cong - Tokyo Institute of Technology Marko van Eekelen - Open University of the Netherlands and Radboud University Nijmegen Jurriaan Hage (Chair) - Utrecht University Marco T. Morazan - Seton Hall University, USA Sharon Tuttle - Humboldt State University, USA Janis Voigtlaender - University of Duisburg-Essen Viktoria Zsok - Eotvos Lorand University Note: information on TFP is available at http://www.cse.chalmers.se/~rjmh/tfp/

1 0

GHC: Policy on -O flags?
by Andreas Klebinger 27 Aug '19

27 Aug '19

Hello ghc-devs and haskell users. I'm looking for opinions on when an optimization should be enabled by default. -O is currently the base line for an optimized build. -O2 adds around 10-20% compile time for a few % (around 2% if I remember correctly) in performance for most things. The question is now if I implement a new optimization, making code R% faster but slowing down the compiler down by C% at which point should an optimization be: * Enabled by default (-O) * Enabled only at -O2 * Disabled by default Cheap always beneficial things make sense for -O Expensive optimizations which add little make sense for -O2 But where exactly is the line here? How much compile time is runtime worth? If something slows down the compiler by 1%/2%/5% and speeds up code by 0.5%/1%/2% which combinations make sense for -O, -O2? Can there even be a good policy with the -O/-O2 split? Personally I generally want code to either: * Typecheck/Run at all (-O0, -fno-code, repl) * Not blow through all my RAM when adding a few Ints while developing: -O ? * Make a reasonable tradeoff between runtime/compiletime: -O ? * Give me all you got: -O2 (-O99999) The use case for -O0 is rather clear, so is -O2. But what do people consider the use case for -O What trade offs seem acceptable to you as a user of GHC? Is it ok for -O to become slower for faster runtimes? How much slower? Should all new improvements which might slow down compilation be pushed to -O2? Or does an ideal solution add new flags? Tell me what do you think. Cheers, Andreas Klebinger

4 3

Munich Haskell Meeting, 2019-08-29 @ 19:30
by Leah Neukirchen 27 Aug '19

27 Aug '19

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Thursday, August 29 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-aug-2019/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

ANN: bcp47
by Evan Borden 26 Aug '19

26 Aug '19

Announcing bcp47, http://hackage.haskell.org/package/bcp47-0.1.0.0 This library provides language tags as specified by https://tools.ietf.org/html/bcp47 As well it provides a trie like data structure for collecting and querying data that varies by language.

1 0

First call for participation for IFL 2019 (Implementation and Application of Functional Languages)
by Jurriaan Hage 26 Aug '19

26 Aug '19

Hello, Please, find below the first call for participation 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: June 15, 2019 Submission of draft papers: August 1, 2019 Regular papers notification: August 1, 2019 Regular draft papers notification: August 7, 2019 Deadline for early registration: August 31, 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 - 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 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

ANN bitvec-1.0.0.1
by Andrew Lelechenko 23 Aug '19

23 Aug '19

Hello, I am happy to announce the stable release of bitvec-1.0.0.1. This package provides a "better" Vector instance for Bool. An unboxed Vector Bool spends 8 bits per boolean, while bitvec provides a newtype Bit and a custom instance of Vector, packing booleans densely and achieving 8x less memory footprint. Performance stays roughly the same, and certain bulk operations become up to 64x faster. http://hackage.haskell.org/package/bitvec-1.0.0.1 https://github.com/Bodigrim/bitvec#readme Best regards, Andrew

2 1

Getting both the value and name of a variable in one expression
by Christopher Done 22 Aug '19

22 Aug '19

Hi all, Do we have already a syntax for ‘foo that also contains the typed value like TExp? I have e.g. an AST that I want to do more static checks on it that aren’t as convenient to do in the type system. Here’s an example: -- | Check the grammar spec to produce a grammar.checkGrammar :: (SchemaName, [(SchemaName, Schema)]) -> Q ExpcheckGrammar (toplevel, rules) = if M.size rulesMap /= length rules then error "Duplicate rule names in grammar." else lift (Grammar {grammarToplevel = toplevel, grammarRules = rulesMap}) where rulesMap = M.fromList rules -- | Grammar for Haskell.grammar :: Grammargrammar = $(checkGrammar $ runDefine $ mdo -- General expression expression <- rule "Expression" (ChoiceSchema [variable, constructor, parentheses ,tuple, let', application, string]) application <- rule "Application" (CompositeSchema [expression, expression]) parentheses <- rule "Parentheses" (CompositeSchema [openParenSchema, expression, closeParenSchema]) ... pure expression) Here I do a trivial check for duplicates. After I’ve checked the expression at compile-time, I Lift it so that it can be used at runtime. That’s pretty good. But some types like (a -> b) don’t Lift. So an alternative would be: grammar = $(checkGrammar_take2 thename 'thename) In which checkGrammar_take2 would: 1. Use thename at compile-time for a check. 2. If the check passes, then return (VarE thename) E.g. checkGrammar_take2 value name = if valueFine value then varE name elseerror "value isn't fine" That’s actually quite a good solution because it avoids a lift, and I didn’t transform the AST. It’s also more efficient than lifting. But there’s no checked relationship between thename and ‘thename. checkGrammar_take2 has no way of knowing that they refer to the same thing. See? Hence, if I could get e.g. `thename to produce both the value and a name for the value, that would be cool. My gist doesn’t go this far. It might look like this: checkGrammar_take2 namedValue = if valueFine (getValue namedValue) then getExp namedValue else error "value isn't fine" and call it like: mygrammar = checkGrammar_take2 `thename So the semantics would be roughly similar to [|| thename ||] :: TExp a but you’d get `thename :: Named a where data Named a = { namedThing :: a, nameOfThing :: Name } I feel like the more DSLs I design, the more I’d like something like this to perform my static checks. Cheers, Chris

2 6

Question on inductive type-families
by Sylvain Henry 22 Aug '19

22 Aug '19

Hi, Suppose I have the following type family: type family Index (n :: Nat) (l :: [k]) = (r :: k) where Index 0 (x ': _ ) = x Index n (_ ': xs) = Index (n-1) xs I'm using it to define a Variant type: data V2 (vs :: [k]) where V2 :: forall vs (n :: Nat). KnownNat n => Proxy n -> Index n vs -> V2 vs Now I want to match on the Variant retrieving either the head or the tail (another Variant): splitV2 :: forall v vs. V2 (v:vs) -> Either v (V2 vs) splitV2 = \case V2 (n1 :: Proxy n) v -> case sameNat n1 (Proxy @0) of Just Refl -> Left v Nothing -> Right (V2 (Proxy @(n-1)) v) It fails to typecheck with: Couldn't match type ‘Index n (v : vs)’ with ‘Index (n - 1) vs’ Expected type: Index (n - 1) vs Actual type: Index n vs1 NB: ‘Index’ is a non-injective type family Is there a way to make this work? This is highly speculative as I'm not very familiar with type-checking: would it be sound to make the inductive Index family "weakly" injective? I.e. somehow produce a typing rule for the type family: forall n n' x xs xs'. Solving: Index n (x ': xs) ~ Index (n'-1) xs' Is equivalent to solving: if n /= 0 then (n ~ n', xs ~ xs') else (x ~ Index (n'-1) xs') Here we could know that "n /= 0" thanks to the match on "sameNat n1 (Proxy @0)". ("weakly" because we have some form of injectivity on the shape of the list but not on its contents) Any pointer on this kind of stuff in research papers, Coq, Agda, etc. ? Thanks, Sylvain

3 3

Optimizations for list comprehension
by Emilio Francesquini 21 Aug '19

21 Aug '19

Hello Cafe, While investigating a performance problem I stumbled upon what I eventually reduced to the example below: module Main where import Data.Time.Clock outside :: Int -> Int outside n = sum [i + j | i <- range, j <- range] where range = [0..n-1] inside :: Int -> Int inside n = sum [i + j | i <- [0..n-1], j <- [0..n-1]] main :: IO () main = do t0 <- getCurrentTime print $ inside 10000 t1 <- getCurrentTime print $ outside 10000 t2 <-getCurrentTime print (diffUTCTime t1 t0) print (diffUTCTime t2 t1) Compiling with -O2, up to GHC 8.2.2, both `inside` and `outside` functions would take the same amount of time to execute. Somewhere between GHC 8.2.2 and 8.6.4 something changed (possibly some new optimization) making `inside` run ~4x faster on my machine. With LLVM the difference is even bigger. It is not that `outside` got slower, but that `inside` got much faster. I'm curious to what optimizations might be happening to the `inside` function that would not fire on the outside function. Any hints? Best regards, Emilio

5 5