January 2021 - Haskell-Cafe

F-IDE 2021 - 2nd Call for Papers
by Andrei Paskevich 08 Jan '21

08 Jan '21

****************************************************************** F-IDE 2021: 6th Workshop on Formal Integrated Development Environment Affiliated with NASA Formal Methods 2021 May 24-25, 2021 -- held online https://cister-labs.pt/f-ide2021 ****************************************************************** Keynotes * Prof. Jan Friso Groote, Eindhoven Univ. of Technology, the Netherlands * Benoît Rognier, Edukera, France Important Dates * Abstract submission: Mon, Feb 22, 2021 * Full paper submission: Mon, Mar 1, 2021 * Notification: Mon, Apr 19, 2021 * Camera-ready: Mon, May 3, 2021 * Workshop: May 24-25, 2021 Overview High levels of safety, security, and privacy standards require the use of formal methods to specify and develop compliant software (sub)systems. Any standard comes with an assessment process, which requires a complete documentation of the application to ease the justification of design choices and the review of code and proofs. Ideally, an F-IDE dedicated to such developments should comply with several requirements. The first one is to associate a logical theory with a programming language, in a way that facilitates the tightly coupled handling of specification properties and program constructs. The second is to offer a language and/or an environment simple enough to be usable by most developers, even if they are not fully acquainted with higher-order logics or set theory, in particular by making development of proofs as easy as possible. The third is to offer automated management of application documentation. It may also be expected that developments done with such an F-IDE are reusable and modular. Tools for testing and static analysis may be embedded within F-IDEs to support the assessment process. Topics The workshop is open to contributions on all aspects of a system development process, including specification, design, implementation, analysis, and documentation. It welcomes the presentation of tools, methods, techniques, and experiments. Topics of interest include, but are not limited to, the following: * F-IDE building: design and integration of languages, development of user-friendly front-ends * How to make high-level logical and programming concepts palatable to industrial developers * Integration of object-oriented and modularity features * Integration of static analyzers * Integration of automated proof tools, theorem provers, and testing tools * Documentation tools * Impact of tools on certification * Experience reports on developing F-IDEs * Experience reports on using F-IDEs * Experience reports on formal methods-based assessments in industrial applications Submission Guidelines We accept both long (15 pages) and short (6 pages) paper submissions. The page limit does not include the bibliography. Submitted papers must present original contributions whose main results and conclusions have not been published or submitted elsewhere. Each submission will be reviewed by at least three members of the Program Committee. We expect that one author of every accepted paper will present their work at the workshop. Submitted papers must be written in English and follow the EPTCS LaTeX format (http://style.eptcs.org) Authors are invited to submit the following types of contributions: * Research papers providing new concepts and results * Experience reports * Position papers and research perspectives * Tool presentations Papers should be submitted via EasyChair at F-IDE 2021's workshop page: https://easychair.org/conferences/?conf=f-ide2021. Preliminary proceedings will be made available in electronic form at the workshop. Post-proceedings will be published in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Program Committee * Andrew Reynolds, University of Iowa, USA * Damien Doligez, Inria, France * Bernhard Rumpe, RWTH Aachen University, Germany * Carlo A. Furia, Chalmers University of Technology, Sweden * César Muñoz, NASA Langley, USA * Cinzia Bernardeschi, University of Pisa, Italy * Claudio Sacerdoti Coen, University of Bologna, Italy * Enrico Tassi, Inria, France * François Pessaux, ENSTA ParisTech, France * José Creissac Campos, University of Minho, Portugal * Kenneth Lausdahl, Aarhus University, Denmark * Laurent Voisin, Systerel, France * Lucas Wagner, Collins Aerospace, USA * Makarius Wenzel, sketis.net * Markus A. Kuppe, Microsoft Research, USA * Mattias Ulbrich, Karlsruhe Institute of Technology, Germany * Pierre-Yves Strub, LIX, École Polytechnique, France * Rosemary Monahan, Maynooth University, Ireland * Silvia Lizeth Tapia Tarifa, University of Oslo, Norway * Simão Melo de Sousa, Universidade Beira Interior, Portugal * Stefan Mitsch, Carnegie Mellon University, USA * Stephan Merz, Inria, France * Virgile Prevosto, Institut List, CEA Tech, Université Paris-Saclay, France * Yannick Moy, AdaCore, France * Yi Zhang, Massachusetts General Hospital, USA PC Chairs * Andrei Paskevich, Université Paris-Saclay, France * José Proença, CISTER/ISEP, Portugal Steering Committee * Catherine Dubois, Samovar, ENSIIE, France * Paolo Masci, US National Institute of Aerospace (NIA), USA * Dominique Méry, LORIA, Université de Lorraine, France

1 0

[TFP'21] final call for papers: Trends in Functional Programming 2021, 17-19 February (online event with Lambda Days 2021 & TFPIE 2021)
by Peter Achten 08 Jan '21

08 Jan '21

------------------------------------------------------------------------- Final call for papers 22nd Symposium on Trends in Functional Programming tfp2021.org *deadline: January 15 2021* ------------------------------------------------------------------------- Did you miss the deadline to submit a paper to Trends in Functional Programming http://tfp2021.org/? No worries -- it's not too late! Submission is open until January 15th 2021, for a presentation slot at the event and post-symposium reviewing. The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. * TFP offers a supportive reviewing process designed to help less experienced authors succeed, with two rounds of review, both before and after the symposium itself. Authors have an opportunity to address reviewers' concerns before final decisions on publication in the proceedings. * TFP offers two "best paper" awards, the John McCarthy award for best paper, and the David Turner award for best student paper. * TFP is co-located with Lambda Days in beautiful Krakow. Lambda Days is a vibrant developer conference with hundreds of attendees and a lively programme of talks on functional programming in practice. Due to the covid pandemic, the event is online with a lot of attention to interaction and getting to socialize with the community. Important Dates --------------- Submission deadline for pre-symposium review: 20th November, 2020 -- passed -- Submission deadline for draft papers: 15th January, 2021 Symposium dates: 17-19th February, 2021 Visit http://tfp2021.org/ for more information.

1 0

How to do reversible parsing?
by Askar Safin 06 Jan '21

06 Jan '21

Hi. How to do deterministic reversible parsing in Haskell? Please, point me to some libs or tools. Or give some advice on how to write such lib or tool. (Also, I am interested in solutions for C or C++.) Now let me explain my task in detail. I am interested in formal math. I am going to develop various proof checkers. In particular, I want to develop my PTS checker ( https://en.wikipedia.org/wiki/Pure_type_system ). Here is example of existing PTS checker: http://web.archive.org/web/20180924133846/http://www.cs.kun.nl/~janz/yarrow/ . Here is example of input this checker accepts (taken from manual): Var (+) : Nat -> Nat -> Nat Def double := \x:Nat. x+x Def S := (+) one Also, I want to develop something similar to Isabelle ( https://isabelle.in.tum.de/ ). Example of Isabelle input: https://isabelle.in.tum.de/dist/library/HOL/HOL/HOL.html . Also, I am going to write converters between various languages. For example, between input for some existing PTS checker and my PTS checker. In short, I want to write lot of parsers and pretty-printers for various languages. And thus I need some parsing solution. The solution should have the following features: 1. The parsing should be divided into lexing and parsing. I. e. usual lex + yacc model. Parsing should be done using usual context-free grammars (CFGs). Left-recursive grammars should be supported (this leaves out parser combinator libraries). All languages I am going to deal with fit this model. I. e. I will deal with simple to parse languages, such as Pascal. Not complex ones, like C or C++. 2. Parsing should be deterministic. I. e. parser should check that CFG is unambiguous. Yes, I know that this task is impossible to do on Turing machine. But at very least some partial solution will go. For example, some algorithm, which will check that some reasonable set of CFGs is deterministic. Or even brute force up to some limit will go. (Yes, this will not give absolutely correct results, but this will go.) This is example of grammar for PTS in one of my checkers (start symbol is t0): t1000 = id t1000 = "(" t0")" t999 = t999 t1000 t3 = t4 "::" t3 t3 = "%" id "::" t0 "." t3 t0 = "!!" id "::" t0 "." t0 t1 = t2 "==>" t1 t0 = t1 t1 = t2 t2 = t3 t3 = t4 t4 = t999 t999 = t1000 If I remember correctly, this grammar is deterministic (checked using brute force up to a limit). I want solution which will verify that this grammar is deterministic. All stages of parsing should be proved as deterministic (i. e. scanner too). 3. Parsing should be reversible. I. e. pretty-printing should be supported, too. And the tool should guarantee that parsing and pretty-printing match. Now let me give more precise definition. Let's assume we have these functions: parse :: String -> Maybe X print :: X -> Maybe String As you can see, not every internal representation is printable. This is OK. For example, if internal representation contains variable names that happen to equal reserved words, then, of course, this is unprintable representation. The tool should guarantee that: a. Result of parsing should be printable, but printing not necessary should give same string. I. e. if "parse s == Just x", then "print x /= Nothing". (But not necessary "print x == Just s".) b. Parsing of result of printing should give same representation. I. e. if "print x == Just s", then "parse s == Just x" 4. Not only parsing should generate parse tree (i. e. exact representation of derivation), but also AST. AST differs from parse tree. For example, AST should not contain braces. I. e. "2 + (3 * 4)" and "2 + 3 * 4" should give same AST. And the tool should be able parse string to AST and pretty print AST back to string. 5. It should be possible to use CFG not known in compile time. Consider Isabelle language. Here is again example of Isabelle text: https://isabelle.in.tum.de/dist/library/HOL/HOL/HOL.html . As you can see the language is divided into inner language and outer language. Strings in inner language are quoted. Outer language can add productions to inner language. Inner language cannot change itself. "notation" and "translations" commands add productions to inner language. So inner language is not known beforehand, it is created dynamically. There is no need to dynamically create scanner, i. e. it should be possible to dynamically create parser (for inner language), but there is no such requirement for scanner. Also, parser will not change in the middle of parsing given string. Again: let's assume I write parser for my Isabelle analog. Scanner and parser for outer language is fixed. Scanner for inner language is fixed, too. But parser for inner language is not. I read input document and add productions to CFG of inner language on the fly. Every time I add production, resulting CFG should be checked for ambiguity. And when I find inner language string in input, I process it using just constructed parser for inner language. -- Points 2 and 3 are the most important in this list. If there is solution which contains them alone, this already will be very good. Now let me list considered solutions. * Usual combinator libraries (such as parsec) will not go. They don't work with left-recursive CFGs. They don't check grammars for ambiguities. They don't do reversible parsing. But they allow creating language on the fly, and this is good thing. * Happy and alex will not go. As well as I know Happy can prove unambiguity of some very simple grammars (i. e. for some set of simple grammars it will not report any conflicts and thus will prove they unambiguity). It seems this is LR(1) set. But, as well as I know, Happy will report conflicts on PTS grammar given above, i. e. Happy cannot prove its unambiguity. Also, Happy and Alex cannot pretty-print. And Happy and Alex don't allow supplying CFG on the fly. * Package "earley". Handle arbitrary CFGs, including left-recursive. This is good thing. It seems CFG can be supplied in runtime. This is good thing, too. Gives all parse trees, thus we can verify that count of parse trees equals to 1. This is good thing, too. Unfortunately, earley cannot verify CFS's unambiguity before supplying input. Also, earley doesn't support pretty-printing. * PEG libraries. Will not go, I want CFGs. * I searched on Hackage reversible parsing libraries. Unfortunately, none of them guarantee reversibility. I. e. it is very easy to fool these libraries and create parsers and printers not satisfying equations I gave above. Also, this libraries doesn't have other features I mentioned * http://augeas.net/ is very cool project. Unlike nearly everything I found in internet, Augeas provides guaranteed reversible parsing and pretty-printing (!!!!!). Unfortunately, set of supported target languages is very limited. Regular languages are supported. And some very limited set of CFGs is supported. For example, it is possible to construct parser for JSON. But parser for Pascal seems impossible. Augeas not designed for parsing programming languages. Only simple configuration languages like JSON, XML, etc. Mutually recursive nonterminals are not supported. Also, Augeas provides C API, not Haskell one. * https://www.brics.dk/xsugar.html is very good. It provides guaranteed reversible translation between arbitrary language and XML. And XSugar even verifies unambiguity of the CFG using some sophisticated algorithm. Unfortunately, this algorithm still cannot prove unambiguity of PTS grammar given above. Also, XSugar is not Haskell library. It is standalone Java app. So, I need to convert some language to XML, then load this XML to my Haskell program and parse. Also, there is similar lib https://www.brics.dk/Xact.html from same author, but it is for Java, not for Haskell. I was able to find only 2 projects, which do guaranteed reversible parsing: mentioned Augeas and XSugar/Xact. Unfortunately, both are not for Haskell. And both cannot prove unambiguity for my PTS grammar. So, please tell me about solution. Or give advice how to write one. Also, let me describe my experience with various algorithms for checking ambiguity of grammar. 1. Try to construct LR(1) table. If there is no conflicts, then the grammar is unambiguous. It seems this is algorithm used by bison and happy. Unfortunately it is too weak and cannot prove unambiguity of my PTS grammar. 2. Try to construct LR(k) table. This algorithm is stronger than LR(1). I was unable to find implementation of this algorithm in any language. I don't want to write such algorithm. 3. Schmitz's algorithm. http://www.lsv.fr/~schmitz/pub/expamb.pdf . Even stronger than LR(k). I downloaded his bison fork. Unfortunately this bison fork can prove unambiguity for same set of grammars original bison can (i. e. LR(1)). I. e. it seems Schmitz did not implemented his algorithm. I don't want to implement his algorithm either. 4. Horizontal and vertical ambiguity checking. https://www.brics.dk/grammar/kruse.pdf . This is algorithm used in XSugar. Unfortunately, it doesn't handle my PTS grammar. 5. Brute force up to some limit. Doesn't give unambiguity guarantee. But I like it, and I will use it if I don't find anything else. It is the only algorithm which can handle my PTS grammar (and give enough amount of guarantee), not counting LR(k) and Schmitz's algorithm (I was not able to find implementations of both). I will try to write tool I want, I will write about my progress to this list. == Askar Safin https://github.com/safinaskar

4 4

Re: [Haskell-cafe] upload file with ftp
by Kees Bleijenberg 06 Jan '21

06 Jan '21

Hi Brandon, The ftp-client I use (total commander) does not use passive mode. I changed the host to another server. And now I do not get an exception, no error messages, but nothing is uploaded. Unfortunately is ‘working in passive mode’ not so easy (at least not to me). After login I send the ‘pasv’ command and I get back a IP address and a port (I assume). Do I have to create a new connection with a handle to this new port for the stor command? I don’t know how to do that in network.ftp.client. A hint or better a working example would be nice. Kees Van: Brandon Allbery [mailto:allbery.b@gmail.com] Verzonden: dinsdag 5 januari 2021 13:49 Aan: Kees Bleijenberg <K.Bleijenberg(a)lijbrandt.nl> CC: haskell-cafe <haskell-cafe(a)haskell.org> Onderwerp: Re: [Haskell-cafe] FW: upload file with ftp At a guess, you're using a modern FTP client that defaults to passive mode for compatibility with firewalls, and you'll need to check the docs to see how to do passive mode with Network.Client.FTP. On Tue, Jan 5, 2021 at 7:24 AM Kees Bleijenberg <K.Bleijenberg(a)lijbrandt.nl <mailto:K.Bleijenberg@lijbrandt.nl> > wrote: I want to upload a file with ftp using library Network.FTP.Client. The OS is Windows 64 and ghc version is 8.6.4. This is the code: import System.FilePath.Windows import Network.FTP.Client import qualified Data.ByteString as B .... testFtp :: IO (Either String ()) testFtp = do let host = "copecco" -- this is from my hosts file username = **** pwd = **** ftpDir = "registratie" fileToSend = "globals.pas" -- a test text file putStrLn $ "Connect to " ++ host withFTP host 21 $ \h ftpResponse -> do print ftpResponse if frStatus ftpResponse == Success then do putStrLn "Connected" loginResp <- login h username pwd print loginResp if frStatus loginResp == Success then do putStrLn $ "Change directory to " ++ ftpDir cwdResp <- cwd h ftpDir print cwdResp if frStatus cwdResp == Success then do putStrLn "Read file from disk" let ftpFn = takeFileName fileToSend fileContents <- B.readFile fileToSend putStrLn $ "File size: " ++ show (B.length fileContents) ++ " bytes" stor h ftpFn fileContents TI return $ Right () else return $ Left $ "Ftp error cwd. Code: " ++ show (frCode ftpResponse) else return $ Left $ "Ftp error login. Code: " ++ show (frCode ftpResponse) else return $ Left $ "Connect to host " ++ host ++ " failed. Code: " ++ show (frCode ftpResponse) This is the response: Connect to copecco 220 (vsFTPd 3.0.2) Connected 230 Login successful. Change directory to registratie 250 Directory successfully changed. Read file File size: 27015 bytes *** Exception: Network.Socket.connect: <socket: 444>: failed (Connection timed out (WSAETIMEDOUT)) Everything works fine until the stor commmand. When I upload the same file with another ftp client program everything works (no permission problems). What is wrong and how do I get the result codes for the stor command? Kees _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe Only members subscribed via the mailman list are allowed to post. -- brandon s allbery kf8nh allbery.b(a)gmail.com <mailto:allbery.b@gmail.com>

3 4

command substitution in ghci?
by Johannes Waldmann 06 Jan '21

06 Jan '21

In a ghci session, I have an IO action that returns a file name, and then I want to :script that file. (The action could also be made to return the contents.) Cf. Bash has $(foo) to allow the output of a command to replace the command itself. See Bash manual 3.5.4 "Command Substitution" - $(command) and $(< file). We do have a work-around, since this is being called from an elisp program. This is just about a micro-optimisation of not calling ghci twice. https://github.com/tidalcycles/Tidal/issues/743 And the whole thing is a work-around for ghc and ghc-pkg not agreeing on the use of environment files (I think) - J.

1 0

FW: upload file with ftp
by Kees Bleijenberg 05 Jan '21

05 Jan '21

I want to upload a file with ftp using library Network.FTP.Client. The OS is Windows 64 and ghc version is 8.6.4. This is the code: import System.FilePath.Windows import Network.FTP.Client import qualified Data.ByteString as B .... testFtp :: IO (Either String ()) testFtp = do let host = "copecco" -- this is from my hosts file username = **** pwd = **** ftpDir = "registratie" fileToSend = "globals.pas" -- a test text file putStrLn $ "Connect to " ++ host withFTP host 21 $ \h ftpResponse -> do print ftpResponse if frStatus ftpResponse == Success then do putStrLn "Connected" loginResp <- login h username pwd print loginResp if frStatus loginResp == Success then do putStrLn $ "Change directory to " ++ ftpDir cwdResp <- cwd h ftpDir print cwdResp if frStatus cwdResp == Success then do putStrLn "Read file from disk" let ftpFn = takeFileName fileToSend fileContents <- B.readFile fileToSend putStrLn $ "File size: " ++ show (B.length fileContents) ++ " bytes" stor h ftpFn fileContents TI return $ Right () else return $ Left $ "Ftp error cwd. Code: " ++ show (frCode ftpResponse) else return $ Left $ "Ftp error login. Code: " ++ show (frCode ftpResponse) else return $ Left $ "Connect to host " ++ host ++ " failed. Code: " ++ show (frCode ftpResponse) This is the response: Connect to copecco 220 (vsFTPd 3.0.2) Connected 230 Login successful. Change directory to registratie 250 Directory successfully changed. Read file File size: 27015 bytes *** Exception: Network.Socket.connect: <socket: 444>: failed (Connection timed out (WSAETIMEDOUT)) Everything works fine until the stor commmand. When I upload the same file with another ftp client program everything works (no permission problems). What is wrong and how do I get the result codes for the stor command? Kees

2 1

Nominations close Jan 11th for the Haskell Foundation Board
by Simon Peyton Jones 04 Jan '21

04 Jan '21

Friends Happy new year! The closing date for self-nominations for membership of the Board of the Haskell Foundation<https://haskell.foundation/> is in just under a week: Monday January 11th 2021 The Haskell Foundation is a new non-profit organisation that seeks to articulate the benefits of functional programming to a broader audience, to erase barriers to entry, and to support Haskell as a solidly reliable basis for mission-critical applications. The Board provides the strategic leadership for the Foundation, including its goals, governance, finances, and staff. Membership of the Board is a key leadership role, not an honorary appointment. The Call for Nominations<https://haskell.foundation/board-nominations/> gives more details. Please do consider nominating yourself, or encouraging a suitable (but perhaps modest) colleague to do so. The HF needs a strong Board, and that means strong nominations. Thanks! Please do forward this message on social media or elsewhere. Simon Peyton Jones

1 0

[TFPIE'21] Third and Final Call For Papers: Trends in Functional Programming *in Education* 2021, 16 February 2021 (with Lambda Days 2021 & TFP 2021)
by Peter Achten 04 Jan '21

04 Jan '21

---------------------------------------------- TFPIE 2021 3rd and Final Call for papers ---------------------------------------------- *************************************************************** - Submission deadline: January 11 2021, Anywhere on Earth. *************************************************************** https://wiki.tfpie.science.ru.nl/TFPIE2021#TFPIE_2021 (February 16 2021, co-organized with TFP 2021 and Lambda Days 2021) Because of the covid pandemic, the events are online this year. The goal of the International Workshops on Trends in Functional Programming in Education is to gather researchers, professors, teachers, and all professionals that use or are interested in the use of functional programming in education. TFPIE aims to be a venue where novel ideas, classroom-tested ideas, and work in progress on the use of functional programming in education are discussed. The one-day workshop will foster a spirit of open discussion by having a review process for publication after the workshop. TFPIE 2021 welcomes submissions in the above mentioned areas. This year many teaching programmes have had to make a rapid transition to online teaching, and we explicitly solicit papers that explore this area of teaching functional programming. 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=tfpie2021 After the workshop, presenters are invited to submit (a revised version of) their article for review. The PC will select the best articles for publication 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 11 2021, Anywhere on Earth. - Notification: January 15 2021 - Workshop: February 16 2021 - Submission for formal review: April 20 2021, Anywhere on Earth. - Notification of full article: June 7 2021 - Camera ready: July 1st 2021 Program Committee - Peter Achten, Radboud University, Netherlands (chair) - Edwin Brady, University of St Andrews, UK - Laura Castro, Universidade da Coruña, Spain - Stephen Chang, University of Massachusetts Boston, USA - Youyou Cong, Tokyo Institute of Technology, Japan - Matthew Flatt, University of Utah, USA - Seth Fogarty, Trinity University, USA - Alex Gerdes, University of Gothenburg, Sweden - Gabriele Keller, Utrecht University, Netherlands - Prabhakar Ragde, University of Waterloo, Canada - Melinda Tóth, Eötvös Loránd University, Budapest, Hungary Registration TFPIE is part of Lambda Days. Please visit the Lambda Days 2021 pages when registration information becomes available. Only papers that have been presented at TFPIE may be submitted to the post-reviewing process. Information on Lambda Days is available at https://www.lambdadays.org/lambdadays2021 Information on TFP is available at http://tfp2021.org

1 0

Re: [Haskell-cafe] How to do reversible parsing?
by Michal J Gajda 03 Jan '21

03 Jan '21

Hi Askar, > Hi. How to do deterministic reversible parsing in Haskell? Please, point me to some libs or tools. > Or give some advice on how to write such lib or tool. (Also, I am interested in solutions for C or C++.) > > Now let me explain my task in detail. I liked the bidirectional applicatives and monads described in here: 1. Composing bidirectional programs monadically (with appendices) - Li-yao Xia, Dominic Orchard, Meng Wang https://arxiv.org/abs/1902.06950 You can use it for both bidirectional parsing/pretty pretting and type inference/type checking. 2. BiGuL is a bit more complicated: https://bitbucket.org/prl_tokyo/bigul/src/master/ -- Cheers Michał

1 0

[ANN] fp-ieee v0.1
by ARATA Mizuki 02 Jan '21

02 Jan '21

Hi all, I'd like to announce the first release of fp-ieee. https://hackage.haskell.org/package/fp-ieee This library aims to provide IEEE 754-2019 compliant operations, including * fusedMultiplyAdd * correctly-rounding versions of fromInteger (GHC's fromInteger for Float and Double do not round correctly; see https://gitlab.haskell.org/ghc/ghc/-/issues/17231) * realFloatToFrac: an alternative of realToFrac with well-defined semantics. Other notes: * Most of the functions are generic, and any RealFloat instance can be used. However, manipulation of NaN's sign and payload requires an additional constraint (RealFloatNaN, provided by this library). * Access to floating-point environment is not provided. If you want to control rounding direction, look at my another library: https://hackage.haskell.org/package/rounded-hw * Decimal-specific operations (like quantize, quantum) are not provided, and the preferred exponent is not honored. * Use of FFI can be disabled via a package flag (maybe useful when using non-native targets). Mizuki

2 3