- Haskell-Cafe - Haskell.org

Haskell's "historical futurism" needs better writing, not better tools
by Michael Turner 04 Oct '21

04 Oct '21

I haven't been able to view Andrew Boardman's video so far, but I gather from the summary that he feels the solution to the most pressing problem -- growth through fostering newbies -- is simply . . . better tools. I beg to differ, as a newbie who is now struggling with the revival of some Haskell code only with a feeling of claustrophobia. Where is this incredible feeling of freedom I was promised? At the top of the learning curve. And it feels like a Sisyphean slope -- the boulder stops, when I lay off learning, and then slowly starts to roll down under the gravitational force of memory decay. The real problem is that the writing sucks. Not all of it -- and some contributors to the community are stellar writers, even if, in the snarkish commentary they write about Haskell and the community, I don't quite get all the jokes. But speaking as a contributor to the Haskell.org wiki -- to which I contribute at times out of hope that clarifying points I understand will also lead to more clarity for myself -- I have to say it: the writing sucks. Why does it suck? Well, there are several syndromes. One is to think that Haskell is so incredibly good and pure and elementally profound that one must start conceptually from scratch. (I've actually been curtly informed on the beginners' list -- yes, the beginner' list! -- that my problems of comprehension can be solved simply: "Learn lambda calculus.") I've had a book recommended to me whose author had such pretensions to writing in a way that was easily foundational that he actually claimed his book could teach you Haskell even if you have no programming experience at all. Now, in practical marketing terms, that's just silly: such an approach addresses a minuscule fraction of the book's potential audience. If you've heard of Haskell as a programming language, you're probably software-multilingual already. But in practical pedagogical terms, it's also a little ridiculous. Your average reader (already a programmer) would be better served by a comparative approach: Here's how to say something in a couple of other programming languages, here's how to say something roughly equivalent in Haskell -- BUT, here's how it's subtly different in Haskell. Here's how Haskell makes something easier (at least perhaps in being more concise, if the Haskell is more concise) but also conferring useful leverage where Haskell might otherwise seem unnecessarily verbose. The problem of better writing is ultimately social, I believe. I have a friend who's a tenured professor at Columbia University, who has used Haskell in courses, who praises Haskell for how it makes students think a little more clearly about how to structure software. However, his final verdict is this: Functional programming is a cult. Now, he's a unabashedly abrasive type. (Just ask him, he'll tell you.) And that verdict IS a little over the top. But I have to say, my impression of the community is that there are Founder demi-gods praised even though they leave something to be desired in how articulate and clear they are for newbies, even when claiming to be addressing newbies, while the language itself seems to be somewhat an object of worship. How can the writing be better? Well, here's a clue: Simon Peyton-Jones, somewhere in a talk where he was his usual vibrant self (but where the audience was clearly stunned and intimidated into silence even though he'd invited people to interrupt with questions) said that F# had settled on the term "workflow" instead of "monad", and he felt this was wise. Workflow? Workflow!? My still-feeble understanding of monads took a leap forward, because suddenly I had a motivation for them: abstraction of the idea of a workflow. Could it be that something as simple as Maybe was a kind of "degenerate case" of a "workflow abstraction"? I felt massively encouraged that I might finally figure out how great monads were. Which is not to say that I have. Writers: you need to stop speaking your own obscure little dialect of "programmer English". If you're not aware that you are, become more self-aware. If you ARE aware of it, become aware of how snobbish or pointlessly mysterious you sound. And if you do become aware of how you sound, but don't care, ask yourself: if the goal now is to spread Haskell and help it flourish, isn't your attitude more of a hindrance than a help? Tools? That's not the front I'd pick. Because I hit a glitch in getting VScode to work under Windows 10 (yes, cue the snobbery), I backed off to github bash and vim. And you know what? It's fine. Sorry if my knuckles seem to be dragging on the floor, but I'm from the Stone Age of Unix v7 command line and Bill Joy's original vi. I'd like nicer tools. But they aren't likely to help me with Haskell. What's not fine: half the time, I can't figure out the error messages from GHC, and a dismaying portion of the time, I can't figure out the language documentation. And since the concepts are seldom described in concrete enough and time-honored programming language terms (by comparison to other programming languages) they often don't really stick. It's like my Sysiphean boulder has been pre-greased -- if I stop pushing (hard enough with all the abstraction grease on it), it starts to slide even before it rolls, whenever I leave off coding in Haskell for any length of time. Sorry for not writing better email here -- my sentences get rather long and tortuous when I rant. But not sorry for ranting. You say the solution to a tool adoption problem (getting more people to use Haskell) is yet more tools written in Haskell, for your favorite language, Haskell? No. The failure here is a failure to communicate. Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry

7 26

Seeking community input on change to Haskell.org Downloads page
by Tom Ellis 03 Oct '21

03 Oct '21

The Haskell.org committee is considering a change to the [Haskell.org Downloads page]. The change is being reviewed in a [GitHub PR]. The specifics of the change are to replace Chocolatey with ghcup as the preferred installation method of GHC, cabal-install and haskell-language-server on Windows. The overall effect is that the install instructions become common over Windows, Linux and MacOS. The Chocolatey install method is mentioned further down the page. (The PR does not impinge on Stack. The Stack instructions remain unchanged.) The committee would welcome input from any interested parties, particularly those who have familiarity with Chocolatey, or ghcup on Windows, or both. You are welcome to comment on the [PR itself][GitHub PR] (or this thread if absolutely necessary). Thanks to @bodigrim for the PR. [Haskell.org Downloads page]: https://www.haskell.org/downloads/ [GitHub PR]: https://github.com/haskell-infra/www.haskell.org/pull/125

3 3

Re: [Haskell-cafe] Improving the docs (specifically Data.Foldable)
by Anthony Clayden 02 Oct '21

02 Oct '21

At *Fri Oct 1 01:42:39 UTC 2021* Ben Franksen wrote >> Am 17.09.21 um 07:15 schrieb Michael Turner:>> >>* "The contribution of each element to the final result is combined with an *>>* accumulator via an /operator/ function. The operator may be explicitly *>>* provided by the caller as in `foldr` or may be implicit as in `length`. In *>>* the case of `foldMap`, the caller provides a function mapping each element *>>* into a suitable 'Monoid', which makes it possible to merge the per-element *>>* contributions via that monoid's `mappend` function." *> >>* This is a little better, but I'd write it this way, I think. *>> >>* "Folds take operators as arguments. In some cases, it's implicit, as *>>* in the function "length". These operators are applied to elements when *>>* lazy evaluation requires it, with a fold 'accumulator' as one of the *>>* operands. 'foldMap' uses a function (implicit? explicit?) that maps *>>* elements into . . . ." * > The problem you two are both facing is this: you want to describe, > abstractly, generally, the common principle behind an ad-hoc > lumped-together set of functions. This is very likely to result in > contortions and provides you with no insight. I think neither "ad-hoc" nor "lumped-together" is accurate. For both `Functor t` and `Foldable t` the metaphor is `t` as container. * For `Functor` we wish to preserve the shape/spine and mangle each element irrespective of other content. * For `Foldable` we wish to throw away the shape/spine and return some characteristic of the contents-as-a-whole. (The fold is possibly returning another container/contents, but it won't necessarily be the same `t`; even if it is, the result won't be the same shape/spine.) There are some frequent use-cases for "characteristic of the contents-as-a-whole": count, sum, min/max, is-element. So it makes sense to provide (possibly optimised) methods. Yes the insight is that there's a common principle. But the optimising devil is in the detail. The devilish detail is that although we're going to throw away the shape/spine, knowing its organising principle will help navigating it effectively. Otherwise we could stick with List as container -- but as Ref [1] points out, that's hardly ever wise. For somebody coming to the docos to generate their own `instance Foldable`, thinking in terms of `toList` might help in getting the right result; it won't explain why they'd want to use something other than a List.

2 1

Stack lock issue
by Dominick Samperi 01 Oct '21

01 Oct '21

Hi, Stack install does its thing in some hashed directory under .stack-work by default, but I want to write to <package-root>/bin as part of the configure process. I'm trying to do this as follows: -- configure file contains: cd $(stack path --project-root) echo "..." > .bin/foo.sh cd - > cd <project-root> > stack install I'm doing this under Windows with the born shell in my path. Problem: the use of stack to find the project-root directory is blocked waiting for the outer stack to terminate! This may have something to do with Windows "Device or resource busy" lock. Is there a better way? Thanks, Dominick <http://www.avg.com/email-signature?utm_medium=email&utm_source=link&utm_cam…> Virus-free. www.avg.com <http://www.avg.com/email-signature?utm_medium=email&utm_source=link&utm_cam…> <#DAB4FAD8-2DD7-40BB-A1B8-4E2AA1F9FDF2>

1 0

Cabal or stack in 2021 ?
by Alexis Praga 01 Oct '21

01 Oct '21

Hi, As an intermediate beginner, I've been back into Haskell for the last months for a small project, using stack as the building tool. Why stack ? A few years back, I learned that it was the "best" way to build projects to avoid "cabal hell", which I understood at the time as "managing dependencies with cabal is hard". As such, I've use stack since and have been quite happy with it. The only drawback is that building a project can be quite long. This is usually not a problem, except for writing Haskell scripts using shelly (for example), where the stack layout is a bit impractical for fast-paced development. A solution is to use `runghc` or a script interpreter [1]. However, I've seen some projects where cabal is used to build directly instead of cabal, so it looks like the situation improved. My question is this: in 2021, is there a reason to switch back to cabal ? Thanks, [1] https://www.fpcomplete.com/haskell/tutorial/stack-script/ -- Alexis Praga

8 11

Re: [Haskell-cafe] Pattern guards seen in the wild?
by Anthony Clayden 01 Oct '21

01 Oct '21

Thank you all for the examples. Hehe real-world data structures are messy. Especially if dictated by systems utilities that don't care for functional programming. In the back of my mind is: do these idioms date from before there were pattern synonyms? Would matching to a pattern synonym give clearer code in the case branching? (Would it be worth declaring a synonym for just one usage?) There's only one of those examples where I feel expressing without the Pattern guard would be awkward. Tom's example 1., whose characteristics are: * There's a long straggly sequence of matchers; * With a particularly awkward branch in the middle, needing sub-analysis of a _component_ of the scrutinee, and only if such a component is present; * If the sub-analysis fails to match, the logic must unnest itself and resume matching at the next branch of the straggle. The awkward branch (slightly reformatted) is > (GET, [x]) | Just (path', mime) <- List.lookup x staticFiles > -> Just (StaticFile mime path') `staticFiles` is a module-wide variable, so matching is looking outside the scrutinee, therefore couldn't be expressed as a pattern synonym. The `lookup` might return a `Nothing`, so the inner pattern match could fail/this is doing more than a 'local binding' with `let`, which "always succeed" says the Language Report.

1 0

Re: [Haskell-cafe] Haskell's "historical futurism" needs better writing, not better tools
by Anthony Clayden 01 Oct '21

01 Oct '21

Hi Michael, oh dear, oh dear, oh dear. The seeds of your confusion are very evident from your message. How to back you out of whatever deep rabbit-hole you've managed to get your head into? > ... Your average reader (already a programmer) would be better served by a comparative approach: Here's how to say something in a couple of other programming languages, here's how to say something roughly equivalent in Haskell -- BUT, here's how it's subtly different in Haskell. No. Just no. Haskell is not "subtly different" to (say) Java in the way that C++ or C# are different. (I'll leave others to judge how subtly different they are.) Haskell is dramatically and fundamentally different. You can't just 'translate' an algorithm from OOP to Haskell. Many newbies try, and there's many tales of woe on StackOverflow. Just No. I really don't know how you could have got any experience with Haskell and say "subtly". I suggest you unlearn everything you think you know about Haskell, and strike out in an entirely different direction. The best approach would be to spend a few days playing with lambda calculus. (That's what I did before tackling Haskell.) > (I've actually been curtly informed on the beginners' list -- yes, the beginner' list! -- that my problems of comprehension can be solved simply: "Learn lambda calculus.") Lambda calculus is an excellent place for beginners to start. What could be easier to learn? It's certainly easier than grokking a Turing machine; and much easier than Haskell: less than a handful of primitives yet can compute anything computable. > And since the concepts are seldom described in concrete enough and time-honored programming language terms (by comparison to other programming languages) I'm guessing that the concepts you're talking of simply don't correspond to anything in time-honoured (procedural) programming. Anybody writing about Haskell (including anybody writing the User Guide) assumes a base level of understanding of Haskell. You've clearly veered off the track and haven't yet reached base. Remember the User Guide builds on top of the Language Report. (On the point of 'time-honoured': lambda calculus is almost exactly the same age as Turing machines. The first well-known programming language using lambda-calculus ideas (LISP 1966) is almost exactly the same age as the first OOP language (Simula 1967). Which is the more time-honoured?) You do have a point that the terminology in Haskell is often mysterious > [SPJ said] F# had settled on the term "workflow" instead of "monad", and he felt this was wise. Yes many have yearned for a more warm-and-cuddly term than "monad". But the terminology barrier starts before that. Haskell typeclasses are not 'classes' in any sense recognisable from OOP. There are no objects, no hidden state, no destructive assignment. We might go back to February 1988 when a strawman for what became typeclasses used OVERLOAD/INSTANCE. AntC

5 5

Re: [Haskell-cafe] Haskell's "historical futurism" needs better writing, not better tools
by Anthony Clayden 01 Oct '21

01 Oct '21

> Switching subtopics to the "Chirality" section, ... I take Ben's point (with which I agree) to be that "Chirality" is an even more obscure word than "Endomorphism". (Except perhaps in the realm of subatomic particle physics.) Grokking this material is hard enough without having to reach for a dictionary. If you mean 'left-biased' vs 'right-biased', or 'from-front' vs 'from-rear' or 'Cons-oriented' vs 'Snoc-oriented', say that. (And I'll be interested to see how anyone explains this without `fromList` jigging their elbow.) Now I can see Foldable structures are abstract, not spatial. But Cons is recursive on its (textually) right operand, whereas `Bin` or `Node` are symmetric between their (textually) left/right recursive operands. I guessed that's what the Chirality section was talking about, so I skimmed the first sentence and skipped on.

3 2

Re: [Haskell-cafe] Pattern guards seen in the wild?
by Anthony Clayden 01 Oct '21

01 Oct '21

Thanks Viktor, you've answered (in the negative) one of my follow-on q's which was: isn't the comma just standing for Boolean `&&` ? > which would otherwise be something like: ... I would go: > smtpGreeting :: Int -> SmtpReply -> SmtpM B.ByteString > smtpGreeting _ r = > | replyCont r = pure B.empty > | code `div` 100 /= 2 = B.empty <$ modify' bail code > | otherwise = smtpSendHello > where > code = replyCode r > bail code s = > s { smtpErr = ProtoErr code $ replyText r } > but I find the pattern guard form to read "declarative", Hmm? Your `code <- ...` left-arrow doesn't look at all declarative to me. It's reminiscent of a binding in a do-block, or a 'source' in a comprehension. Strong imperative/sequential overtones. > with less "if then else" baggage and nesting getting in the way of seeing the essential conditions. My suggestion above also avoids "if then else". I guess a case of de gustibus ... To my taste, GHC Haskell is just too bloated/there's too many (equivalent) ways of writing code/there's too many idioms I have to keep up with to read code. It's not that there's anything particularly 'wrong' with any one of them; it's the sheer number of them. I'd have to say patterns/matching suffer a low power to weight ratio, where 'weight' means syntactic clutter and gotcha's: View pattern arrow-from-nowhere, I'm looking at you; pattern signatures double-forall's, empty forall's, double-constraints, I'm looking at you.

1 0

canonicalization of interval libraries
by Olaf Klinke 29 Sep '21

29 Sep '21

Emily Pillmore wrote: > Hello Haskell! > > I'm pleased to announce that the Core Libraries Committee Elections for September 2021 have concluded, and we have selected 2 new CLC members: > > - [Andrew Lelechenko]( https://github.com/Bodigrim ) > > - [Melanie Brown]( https://github.com/bi-functor ) > I could not help but notice that both new members have either written or contributed to an interval library. There are a handful out there (disclaimer: I have written one of them) but as far as I know there is no de-facto standard. Why is that? Is it because the applications of intervals are too diverse and hence no single type fits all? Or is it because it is such a niche application that no single library could gather enough traction? I'm curious whether others see the need to have a de-facto standard interval library that is both general and performant, as we are used to from our "core libraries". Judging from the number of downloads on hackage, people are mostly interested in intervals of floating point numbers and intervals of time. Olaf P.S. Yes, I am aware of the relevant xkcd comic on standards.

1 0