September 2020 - Haskell-Cafe

Re: [Haskell-cafe] I think I discovered my first Monoid instance
by David Banas 30 Sep '20

30 Sep '20

> > But we're talking about xor for the Word64 type, so it is slightly more > complicated to prove that it has a unit. Here's a proof in Agda: -- Agda proof that zero is the unit (i.e. - left and right identity) -- for the XOR operation. import Relation.Binary.PropositionalEquality as Eq open Eq using (_≡_; refl; cong; sym) open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_; _^_) -- Binary data. data Bin : Set where ⟨⟩ : Bin _O : Bin → Bin _I : Bin → Bin _xor_ : Bin → Bin → Bin ⟨⟩ xor y = y (x O) xor ⟨⟩ = x O (x O) xor (y O) = (x xor y) O (x O) xor (y I) = (x xor y) I (x I) xor ⟨⟩ = x I (x I) xor (y O) = (x xor y) I (x I) xor (y I) = (x xor y) O lemma : ∀ (b : Bin) ------------ → b xor ⟨⟩ ≡ b lemma ⟨⟩ = refl lemma (b O) = refl lemma (b I) = refl _ : ( ⟨⟩ I O O I O I I O ) xor ( ⟨⟩ O I I I O O O O ) ---------------------- ≡ ( ⟨⟩ I I I O O I I O ) _ = refl -- Left & right identity proofs. postulate binO : (⟨⟩ O) ≡ ⟨⟩ -- Just accomodating a syntactical nuisance. xor-idₗ : ∀ (b : Bin) ---------------- → (⟨⟩ O) xor b ≡ b xor-idₗ ⟨⟩ rewrite binO = refl xor-idₗ (b O) = refl xor-idₗ (b I) = refl xor-idᵣ : ∀ (b : Bin) ---------------- → b xor (⟨⟩ O) ≡ b xor-idᵣ ⟨⟩ rewrite binO = refl xor-idᵣ (b O) rewrite lemma b = refl xor-idᵣ (b I) rewrite lemma b = refl -db

1 0

Re: [Haskell-cafe] [Haskell] [ANNOUNCE] Glasgow Haskell Compiler 9.0.1-alpha1 released
by Dan Burton 29 Sep '20

29 Sep '20

That's great news! Thank you for your hard work. Does this address the Windows issue with GHC 8.10.2? Will there still be a GHC 8.10.3 release? See: https://gitlab.haskell.org/ghc/ghc/-/issues/18550 (Pardon the dupe; I had the wrong address on haskell-cafe) -- Dan Burton On Tue, Sep 29, 2020 at 5:23 PM Dan Burton <danburton.email(a)gmail.com> wrote: > That's great news! Thank you for your hard work. > > Does this address the Windows issue with GHC 8.10.2? Will there still be a > GHC 8.10.3 release? > See: https://gitlab.haskell.org/ghc/ghc/-/issues/18550 > > -- Dan Burton > > > On Mon, Sep 28, 2020 at 3:16 PM Ben Gamari <ben(a)well-typed.com> wrote: > >> Hello all, >> >> The GHC team is very pleased to announce the availability of the first >> alpha release in the GHC 9.0 series. Source and binary distributions are >> available at the usual place: >> >> https://downloads.haskell.org/ghc/9.0.1-alpha1/ >> >> This first alpha comes quite a bit later than expected. However, we have >> done a significant amount of testing on this pre-release and therefore >> hope to be able to move forward quickly with a release candidate next >> week and with a final release in mid-October. >> >> GHC 9.0.1 will bring a number of new features: >> >> * A first cut of the new LinearTypes language extension [1], allowing >> use of linear function syntax and linear record fields. >> >> * A new bignum library (ghc-bignum), allowing GHC to be more easily >> used with integer libraries other than GMP. >> >> * Improvements in code generation, resulting in considerable >> performance improvements in some programs. >> >> * Improvements in pattern-match checking, allowing more precise >> detection of redundant cases and reduced compilation time. >> >> * Implementation of the "simplified subsumption" proposal [2] >> simplifying the type system and paving the way for QuickLook >> impredicativity in GHC 9.2. >> >> * Implementation of the QualifiedDo extension [3], allowing more >> convenient overloading of `do` syntax. >> >> * Improvements in compilation time. >> >> And many more. See the release notes [4] for a full accounting of the >> changes in this release. >> >> Do note that there are a few things that we expect will change before >> the final release: >> >> * We expect to sort out a notarization workflow for Apple Darwin, >> allowing our binary distributions to be used on macOS Catalina >> without hassle. >> >> Until this has been sorted out Catalina users can exempt the >> current macOS binary distribution from the notarization requirement >> themselves by running `xattr -cr .` on the unpacked tree before >> running `make install`. >> >> * We will likely transition the Alpine binary distribution to be fully >> statically-linked, providing a convenient, distribution-independent >> packaging option for Linux users. >> >> * We will be merging a robust solution for #17760 which will introduce >> a new primitive, `keepAlive#`, to the `base` library, subsuming >> most uses of `touch#`. >> >> As always, do test this release and open tickets for whatever issues you >> encounter. To help with this, we will be publishing a blog post >> describing use of our new `head.hackage` infrastructure to ease testing >> of larger projects with Hackage dependencies later this week. >> >> Cheers, >> >> - Ben >> >> >> [1] >> https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0111-l… >> [2] >> https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0287-s… >> [3] >> https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0216-q… >> [4] >> https://downloads.haskell.org/ghc/9.0.1-alpha1/docs/html/users_guide/9.0.1-… >> _______________________________________________ >> Haskell mailing list >> Haskell(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell >> >

1 0

Re: [Haskell-cafe] Proposed "Restructuring" of State Monad page in Haskell Wikibooks
by Olaf Klinke 29 Sep '20

29 Sep '20

> Hello – I’m proposing to restructure this< > https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State>;, > and I have a draft here< > https://en.wikibooks.org/wiki/Davjam2:Example/StateMonad>;. I’ve > given my main reasons for the restructuring at the top of the draft > page. > > I’d very much like feedback before updating the real page, especially > if people don’t like the new one much. +1 for the new version by David. In addition to the content already present, I'd like to see examples (and exercises! these are great!) of State used with other common monadic combinators. You covered sequence, but what about mapM a.k.a. traverse, what about foldM? Can filterM be put to good use with state monads? You could introduce another type TurnstileInput = Push | Coin and combine pushS, coinS into a single function of type TurnstileInput -> State TurnstileState TurnstileOutput which can be used in mapM. Your exercises of different people can then be implemented as mapM of a single function (namely the FSM) over finite sequences of TurnstileInputs. As a side-note, Data.Traversable.mapAccumR is implemented using a StateR that passes the state backwards. Only an Applicative instance is given in Data.Functor.Utils. I wonder whether this is a lawful monad or not. The comment says so, but I don't see how. Here is a departure from the otherwise very concrete and down-to-earth explanation of State, but a fun exercise nevertheless: Implement return and (>>=) for type State s a = s -> (s,a) using the following two functions and the Functor instance of ((->) s). iso :: ((s,a) -> b) -> a -> s -> b iso uncurried = curry (uncurried . Data.Tuple.swap) iso' :: (a -> s -> b) -> (s,a) -> b -- inverse of iso iso' curried = uncurry (flip curried) Olaf

1 0

ANN: first release candidate for stack-2.5.x
by Emanuel Borsboom 29 Sep '20

29 Sep '20

Download binaries from here: https://github.com/commercialhaskell/stack/releases/tag/v2.5.0.1 **Changes since v2.3.3** Major changes: * Add the `snapshot-location-base` yaml configuration option, which allows to override the default location of snapshot configuration files. This option affects how snapshot synonyms (LTS/Nightly) are expanded to URLs by the `pantry` library. * `docker-network` configuration key added to overwrite docker `--net` arg Behavior changes: * File watching now takes into account specified targets, old behavior could be restored using the new flag `--watch-all` [#5310](https://github.com/commercialhaskell/stack/issues/5310) Other enhancements: * `stack ls dependencies json` now includes fields `sha256` and `size` for dependencies of `type` `archive` in `location`. [#5280](https://github.com/commercialhaskell/stack/issues/5280) * Build failures now show a hint to scroll up to the corresponding section [#5279](https://github.com/commercialhaskell/stack/issues/5279) * Customisable output styles (see `stack --help` and the `--stack-colors` option, and `stack ls stack-colors --help`) now include `info`, `debug`, `other-level`, `secondary` and `highlight`, used with verbose output. Bug fixes: * Fix `stack test --coverage` when using Cabal 3 * `stack new` now generates PascalCase'd module name correctly. [#5376](https://github.com/commercialhaskell/stack/issues/5376) * Connection issues to Casa server no longer cause builds to failure. Casa acts only as an optimizing cache layer, not a critical piece of infrastructure. * Fix modified time busting caches by always calculating sha256 digest during the build process. [#5125](https://github.com/commercialhaskell/stack/issues/5125)

1 0

Re: [Haskell-cafe] Proposed "Restructuring" of State Monad page in Haskell Wikibooks
by Tom Smeding 29 Sep '20

29 Sep '20

Hi all, Branimir wrote: > Two years is not enough to do anything serious in Haskell. That is beyond demo programs. This statement carries a lot of assumptions, some of which may be true in this case, some of which may not -- I don't know David James -- but I think it isn't good to let this statement stand on its own like that. If a student who has never programmed before starts learning Haskell, they will not be able to succeed professionally after just two years unless they have other useful background knowledge and/or talent (let's not discuss whether talent is a thing or not). However, the email by David James did not sound like he is a beginner in the act of programming; indeed, with experience in imperative (C++, VB), declarative (SQL), functional (Lisp) and logic (Prolog) programming languages, that certainly does not count as "has never programmed before". And I think we can agree that someone with sufficient experience in programming at large can learn to use Haskell effectively in two years (which is quite a long time, even if it's irregular practice). At least, I strongly believe this until proven otherwise. If that is indeed not the case, then something is seriously wrong on Haskell's side, as Gregory has noted below. David: I haven't read your rewritten State monad tutorial, for which my apologies; also apologies for kind of derailing this thread. Cheers, and have a great day, Tom Smeding P.S. This message wasn't accepted by the mailing list earlier, so was just sent to some people personally. Sorry for duplicate emails. On Tue, 29 Sep 2020 at 15:14, Gregory Guthrie <guthrie(a)miu.edu> wrote: > If this is true, Haskell will probably never move up into even the top 40 > of used languages, which would be too bad! And it would be interesting to > see why – certainly people find good productivity in the mainstream IP > languages in even 6-9 months. > > (Look at salaries from bootcamp placements.) > > > > Currently Haskell is significantly below Cobol, Fortran, Lisp, and Pascal > in the language usage/ratings. :-( > > > > > > Dr. Gregory Guthrie > > Maharishi International University > > ---------------------------------------------------------------- > > > > *From:* Haskell-Cafe <haskell-cafe-bounces(a)haskell.org> *On Behalf Of *Branimir > Maksimovic > *Sent:* Tuesday, September 29, 2020 7:17 AM > *To:* haskell-cafe(a)haskell.org > *Subject:* Re: [Haskell-cafe] Proposed "Restructuring" of State Monad > page in Haskell Wikibooks > > > > Two years is not enough to do anything seroius in Haskell. That is beyond > demo programs. > > > > Greets, Branimir. > > > > On 9/28/20 6:37 PM, David James wrote: > > Hello – I’m proposing to restructure this > <https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State>, and I > have a draft here > <https://en.wikibooks.org/wiki/Davjam2:Example/StateMonad>. I’ve given my > main reasons for the restructuring at the top of the draft page. > > > > I’d very much like feedback before updating the real page, especially if > people don’t like the new one much. > > > > I’m new here, so should probably say a bit about myself. I’ve been > learning-by-doing Haskell for about two years. Sometimes I feel I’m > starting to get it, but these feelings don’t usually last long. I’m > certainly not an expert, and don’t have a PhD in Very Clever Things. I do > have quite an extensive IT background, originally programming in Lisp and > Prolog, then (sadly) C++, VB and SQL but have had quite a long break from > programming (doing dumb things like architecting systems and project > managing) before looking at Haskell. I built this website > <https://decimos.net/> and this library > <https://hackage.haskell.org/package/MapWith>, just for my own amusement. > > > > Apologies if this isn’t the right place to send this. (But then where is?) > I’ve already put a note on the page itself about the new draft, but I’ve no > idea whether anyone will notice it. > > > > Thanks very much, > > David. > > > > > > > > > > > > > > > > > > _______________________________________________ > > 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. > > _______________________________________________ > 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.

2 1

[TFPIE'21] First Call For Papers: Trends in Functional Programming *in Education* 2021, 16 February (with Lambda Days 2021 & TFP 2021)
by Peter Achten 29 Sep '20

29 Sep '20

-------------------------------- TFPIE 2021 Call for papers -------------------------------- https://wiki.tfpie.science.ru.nl/TFPIE2021#TFPIE_2021 (February 16 2021, co-organized with TFP 2021 and Lambda Days 2021) 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. We plan to publish them 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 (under construction) - 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 - Alex Gerdes, University of Gothenburg, Sweden - Prabhakar Ragde, University of Waterloo, Canada - Melinda Tóth, Eötvös Loránd University, Hungary Registration TFPIE is part of Lambda Days. Please visit the Lambda Days 2021 pages when registration information becomes available. Registration is mandatory for at least one author of every paper that is presented at the workshop. 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

[TFP'21] first call for papers: Trends in Functional Programming 2021, 17-19 February (with Lambda Days 2021 & TFPIE 2021)
by Peter Achten 29 Sep '20

29 Sep '20

------------------------------------------------------------------------- First call for papers 22nd Symposium on Trends in Functional Programming tfp2021.org ------------------------------------------------------------------------- The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. * TFP 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 Submission deadline for draft papers: 15th January, 2021 Symposium dates: 17-19th February, 2021 * We strongly encourage authors to submit their work for the first deadline. Authors whose papers are accepted for presentation, but not immediately for the proceedings in this first round, will have almost two months to address the reviewers' concerns. Papers submitted for the first deadline will also have priority for the presentation slots at the symposium. Visit tfp2021.org for more information.

1 0

Proposed "Restructuring" of State Monad page in Haskell Wikibooks
by David James 29 Sep '20

29 Sep '20

Hello – I’m proposing to restructure this<https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State>, and I have a draft here<https://en.wikibooks.org/wiki/Davjam2:Example/StateMonad>. I’ve given my main reasons for the restructuring at the top of the draft page. I’d very much like feedback before updating the real page, especially if people don’t like the new one much. I’m new here, so should probably say a bit about myself. I’ve been learning-by-doing Haskell for about two years. Sometimes I feel I’m starting to get it, but these feelings don’t usually last long. I’m certainly not an expert, and don’t have a PhD in Very Clever Things. I do have quite an extensive IT background, originally programming in Lisp and Prolog, then (sadly) C++, VB and SQL but have had quite a long break from programming (doing dumb things like architecting systems and project managing) before looking at Haskell. I built this website<https://decimos.net/> and this library<https://hackage.haskell.org/package/MapWith>, just for my own amusement. Apologies if this isn’t the right place to send this. (But then where is?) I’ve already put a note on the page itself about the new draft, but I’ve no idea whether anyone will notice it. Thanks very much, David.

6 5

I think I discovered my first Monoid instance
by Mario Lang 29 Sep '20

29 Sep '20

Hi. A common theme of some Haskell talks seems to be to motivate people to go and hunt for instances of standard typeclasses. As the hobbyist Haskell programmer that I am, I kept on wondering if I would ever find some. It feels sort of unrealistic, or at least unlikely, that I should suddenly start to see meaningful structure in code just because I think I know some typeclasses. I think I finally discovered a Monoid instance that helps to express a concept in code pretty well. However, unsure about the soundness of my blundering about, I'd like to confirm (or disprove!) my findings before I fall in love with the approach too much. In my chess library (chessIO) I use bitboards to represent chess positions. data QuadBitboard = QBB { black :: {-# UNPACK #-} !Word64 , pbq :: {-# UNPACK #-} !Word64 , nbk :: {-# UNPACK #-} !Word64 , rqk :: {-# UNPACK #-} !Word64 } deriving (Eq) A quad bitboard is a space optimisation based on the observation that a square can only be occupied by one piece. occupied QBB{pbq, nbk, rqk} = pbq .|. nbk .|. rqk pnr QBB{pbq, nbk, rqk} = pbq `xor` nbk `xor` rqk white = liftA2 xor occupied black pawns = liftA2 (.&.) pnr pbq knights = liftA2 (.&.) pnr nbk bishops = liftA2 (.&.) pbq nbk rooks = liftA2 (.&.) pnr rqk queens = liftA2 (.&.) pbq rqk kings = liftA2 (.&.) nbk rqk We can create a bitboard with a single occupied square: square :: Int -> Word4 -> QuadBitboard square !sq !nb = QBB (f 0) (f 1) (f 2) (f 3) where !b = bit sq f !n = fromIntegral ((nb `unsafeShiftR` n) .&. 1) * b And, as an aside, we can even use pattern synonyms to give these nibbles meaningful names. pattern NoPiece = 0 pattern WhitePawn = 2 pattern WhiteKnight = 4 pattern WhiteBishop = 6 pattern WhiteRook = 8 pattern WhiteQueen = 10 pattern WhiteKing = 12 pattern BlackPawn = 3 pattern BlackKnight = 5 pattern BlackBishop = 7 pattern BlackRook = 9 pattern BlackQueen = 11 pattern BlackKing = 13 But what felt really like a cool discovery, is combination: instance Monoid QuadBitboard where mempty = QBB 0 0 0 0 -- | bitwise XOR instance Semigroup QuadBitboard where QBB b0 b1 b2 b3 <> QBB b0' b1' b2' b3' = QBB (b0 `xor` b0') (b1 `xor` b1') (b2 `xor` b2') (b3 `xor` b3') With this, we can pretty easily define a function to create a quad bitboard from a string: instance IsString QuadBitboard where fromString = go (7, 0) mempty where go _ !qbb "" = qbb go (!r,_) qbb ('/':xs) = go (r - 1, 0) qbb xs go (!r,!f) !qbb (x:xs) | inRange ('1','8') x = go (r, f + (ord x - ord '0')) qbb xs | otherwise = go (r, f + 1) (qbb <> square (r*8+f) nb) xs where nb = case x of 'P' -> WhitePawn 'N' -> WhiteKnight 'B' -> WhiteBishop 'R' -> WhiteRook 'Q' -> WhiteQueen 'K' -> WhiteKing 'p' -> BlackPawn 'n' -> BlackKnight 'b' -> BlackBishop 'r' -> BlackRook 'q' -> BlackQueen 'k' -> BlackKing _ -> error $ "QuadBitBoard.fromString: Illegal FEN character " <> show x standard :: QuadBitboard standard = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR" The rest of the module builds on the Monoid instance of QuadBitboard. Again, this is the first time a instance like this turns up in my Haskell experiments. It feels extremely satisfying having discovered this. But maybe I am violating some laws (I hear instances do that sometimes!) or some other thing is totally wrong. One might say I am not fully trusting the peace. https://hackage.haskell.org/package/chessIO/docs/Game-Chess-QuadBitboard.ht… -- CYa, ⡍⠁⠗⠊⠕

6 9

Status of Haskell on the browser?
by Bryan Richter 28 Sep '20

28 Sep '20

A perennial question, I'm sure. I've been trying out some browser-side programming lately, and I'm curious if anyone in the community has any vision for where things are going. GHCJS looks like it hasn't had any updates in a while. Is it approaching its twilight years, or do people still have plans for it? Asterius looks interesting, but I'm not too clear on where WASM sits in the web space. Would a suitably-advanced Asterius cover all of our Haskell-on-the-browser needs, or would there still be a need for a separate javascript backend? Basically, I'm curious to know what people are working on in this realm! -Bryan

1 0