- Haskell-Cafe - Haskell.org

[ANN] hindley-milner-type-check-0.1.1.0 - type-checker for extended lambda-calculus
by Anton Kholomiov 08 Jun '21

08 Jun '21

I am happy to announce the first release of hindley-milner-type-check. It is generic type checker for lambda-calculus augmented with let-expressions, case-expressions pattern-matching and polymorphism. Library can report source code locations and returns the list of all errors if any. The library is generic in terms of source code locations, names for variables, literals of the language. You can find tutorials and examples in the github repo. Links: Hackage: https://hackage.haskell.org/package/hindley-milner-type-check Github: https://github.com/anton-k/hindley-milner-type-check Happy type-checking! Cheers, Anton

1 0

Re: [Haskell-cafe] [Haskell] [ANNOUNCE] GHC 8.10.5 released
by Zubin Duggal 06 Jun '21

06 Jun '21

The correct link to the release notes is: https://downloads.haskell.org/ghc/8.10.5/docs/html/users_guide/8.10.5-notes… (Note the missing tilde) Apolgies, Zubin

1 0

[Haskell] [ANNOUNCE] GHC 8.10.5 released
by Zubin Duggal 06 Jun '21

06 Jun '21

The GHC team is very pleased to announce the availability of GHC 8.10.5. Source and binary distributions are available at the [usual place](https://downloads.haskell.org/ghc/8.10.5/). This release adds native ARM/Darwin support, as well as bringing performance improvements and fixing numerous bugs of varying severity present in the 8.10 series: - First-class support for Apple M1 hardware using GHC's LLVM ARM backend - Fix a bug resulting in segmentation faults where code may be unloaded prematurely when using the parallel garbage collector (#19417) along with other bugs in the GC and linker (#19147, #19287) - Improve code layout fixing certain performance regressions (#18053) and other code generation bug fixes (#19645) - Bug fixes for signal handling when using the pthread itimer implementation. - Improvements to the specializer and simplifier reducing code size and and memory usage (#17151, #18923,#18140, #10421, #18282, #13253). - Fix a bug where typechecker plugins could be run with an inconsistent typechecker environment (#19191). - Fix a simplifier bug which lead to an exponential blow up and excessive memory usage in certain cases A complete list of bug fixes and improvements can be found in the release notes: [release notes](https://downloads.haskell.org/~ghc/8.10.5/docs/html/users_guide/8.10… As always, feel free to report any issues you encounter via [gitlab.haskell.org](https://gitlab.haskell.org/ghc/ghc/-/issues/new).

1 0

printf using values more than once
by Olaf Klinke 04 Jun '21

04 Jun '21

Dear Café, since the topic recently was rendering text, I'd like to ask a related design question. I want a version of printf that - is more type-safe because unused or surplus arguments cause compile-time errors, - the formatting instructions can use arguments out of order and more than once, - is polymorphic in the text type being built: Suppose I want to build a Pandoc Block but the holes are of type Inline. The format string must therefore be able to promote the Block type's constructors to constructors with holes. The closest match I know of is HoleyMonoid [1] but it only provides printf-like holes, whereas I need named positional arguments like arg1, arg2 etc. that can be repeated. Document templating libraries provide these, but all templating libraries I looked at are type-unsafe. In order to fulfill the second requirement, one could use the free monad over a Reader functor, e.g. Free ((->) (forall a. Show a => a)) String with some custom instances. Here one can use the nesting levels of the free monad to encode the argument position. But it is just as type-unsafe as printf. Funneling return type constructors through this works sort of, but it's awkward. One can achieve type saftey with type classes like printf does: class Eventually r a where eventually :: r -> a instance Eventually r r where eventually = id instance (Eventually r a) => Eventually r (b -> a) where eventually r = const (eventually r) This class can be used to inject constant Text into any nesting of (Text -> ... -> Text -> Text) and argument position is indeed function argument position. But using this system often leads to type ambiguity errors. Also, it is so type-safe that it is impossible to write a function taking a natural number and returning the hole of the corresponding position: Such a function would be dependently-typed. My current best implementation uses a combination of Eventually and HoleyMonoid, but I'm not entirely satisfied. Olaf [1] https://hackage.haskell.org/package/HoleyMonoid

3 3

[ANN] ttc-1.0.0.0 - Textual Type Classes
by Travis Cardwell 04 Jun '21

04 Jun '21

I am happy to announce the 1.0 release of TTC (Textual Type Classes). The library provides the following functionality: * The Textual type class is used to convert between common textual data types. It can be used to write functions that accept or return values of any of these textual data types. * The Render type class is used to render a value as text. Avoid bugs by only using Show for debugging/development purposes. * The Parse type class is used to parse a value from text. Unlike Read, it has support for error messages. * Validate constants at compile-time using Parse instances. Links: * GitHub: https://github.com/ExtremaIS/ttc-haskell * Hackage: https://hackage.haskell.org/package/ttc * Guided Tour: https://www.extrema.is/articles/ttc-textual-type-classes Best regards, Travis

4 10

Call for Tutorial, Panel, and Discussion Proposals: ICFP 2021
by Sam Tobin-Hochstadt 02 Jun '21

02 Jun '21

CALL FOR TUTORIAL, PANEL, AND DISCUSSION PROPOSALS ICFP 2020 25th ACM SIGPLAN International Conference on Functional Programming August 22 - 27, 2021 Virtual https://icfp21.sigplan.org/ The 25th ACM SIGPLAN International Conference on Functional Programming will be held virtually on August 22-27, 2021. 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". Just like last year, following the success of the #ShutDownPL event @ ICFP, we are also inviting proposals for panels and discussions on topics of broader interest to the PL community. Tutorials, panels, and discussions may occur before or after ICFP, co-located with the associated workshops, on August 22 or August 26-27. ---------------------------------------------------------------------- Submission details Deadline for submission: June 28th, 2020 Notification of acceptance: July 5th, 2020 Prospective organizers of tutorials are invited to submit a completed tutorial proposal form in plain text format to the ICFP 2021 workshop co-chairs (Leonidas Lampropoulos and Zoe Paraskevopoulou), via email to icfp-workshops-2021(a)googlegroups.com by June 28th, 2021. Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by July 5th, 2021. The proposal form is available at: http://www.icfpconference.org/icfp2021-files/icfp21-panel-form.txt http://www.icfpconference.org/icfp2021-files/icfp21-tutorials-form.txt ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2021 organizing committee. Tutorials Co-Chair: Zoe Paraskevopoulou (Northeastern) Tutorials Co-Chair: Leonidas Lampropoulos (University of Maryland) General Chair: Sukyoung Ryu (KAIST) Program Chair: Ron Garcia (University of British Columbia) ---------------------------------------------------------------------- Further information Any queries should be addressed to the tutorial co-chairs ( Leonidas Lampropoulos and Zoe Paraskevopoulou), via email to icfp-workshops-2021(a)googlegroups.com

1 0

Generic Traversal of ASTs
by Richard Yu 02 Jun '21

02 Jun '21

I have a question about generic traversal/transformation of nested data structures. From what I understand the main options available are SYB, Uniplate, GHC.Generics and Data.Lens (although I am under the impression this requires record types). The data structure I am attempting to traverse is similar to this simplified version: data SExpr = Expr | Const data Const = B bool | I int data Expr = Lambda String SExpr | If Expr ... I have attempted to use Uniplate and GHC.Generics to traverse the built AST and modify for example, the string of a Lambda type, but have not been able to figure out how to get any of the libraries to typecheck. The examples or docs I found were not quite enough. Does anyone know of examples that might help or explain how I should be using the generic libraries? In addition if I moved to writing the AST with GADTs, do some generic traversal strategies/libraries stop working? Many thanks, Richard

4 4

Wrapping external process communication in a nice API?
by Mario Lang 31 May '21

31 May '21

Hi. For my chessIO package, I wrote a module to communicate with UCI (Universal Chess Interface) speaking chess engines. This sort of thing is pretty new to me. I settled to use attoparsec for parsing and TChan to feed incoming data to the library users. This is the first thing that I found which looked like it could work... I would be thrilled if someone with more experience in this area would give my approach a review. Let me know if something is glaringly unidiomatic, I am sure you will find things. https://github.com/mlang/chessIO/blob/master/src/Game/Chess/UCI.hs This is for me to learn, and to avoid putting weird stuff on hackage... I actually prefer private mail, but a GitHub issue or even a PR are also highly welcome. Thanks. -- CYa, ⡍⠁⠗⠊⠕

4 9

bottom/unconditionally false in Haskell
by Galaxy Being 31 May '21

31 May '21

I just ran into this formula head = foldr (<<) ⊥ where x << y = x in Bird and Gibbons' *Algorithm Design with Haskell* and I understand it's a sort of pseudo-code. Intuitively, I understand that foldr will take "bottom" as its "starter seed", but I don't know how to convert the << into Haskell code. This works myHead = foldr choose1st undefined where choose1st x y = x but I can't get myHead2 = foldr (<<) undefined where << x y = x to work. How do you create a non-alphanumeric operator like <<? -- ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2

Is there some tool for inferring wide dependency ranges?
by Askar Safin 31 May '21

31 May '21

Hi. Is there some tool for inferring dependency ranges for my cabal packages? I know about "cabal gen-bounds", but this command gives too short ranges. I want to get as wide range as possible. I. e. I want tool, which tries to build and test my package on various versions of dependencies, and reports resulting range. Successful testing should mean that the version of dependency is compatible. That tool should work also on "base" package, this means that it should test various ghc versions, too. If there is no such tool, then at least I want some tool, which will check already specified dependency range. Such tool should do this: - Extract dependencies from cabal file - Install smallest versions of specified dependencies (this will include "base" and thus ghc) - Test on this versions - Install largest versions - Test on this versions I will put invocation of such tool to continuous integration. I hope there are a lot of package maintainers here. How do you manage dependencies? == Askar Safin http://safinaskar.com https://sr.ht/~safinaskar https://github.com/safinaskar

3 6