Hacker News Reader

Comment by awinter-py | Hacker News Reader

as a new haskell learner who started this month, I've really learned empathy from banging my head against the language

the docs have a specific tone or pattern that's everywhere (and by docs I mean everything -- library readmes, examples, language intros, and stackoverflow posts)

they all read like 'well, you probably haven't been introduced to monads yet. I can't answer your question directly in a short post (these posts are all like 6 paragraphs, nothing short about them), but I'll tell you why you can't do what you're trying to do and I'll also explain why I can't tell you what a monad is'

also my laptop battery keeps dying because the builds are so expensive

View on HN

I highly, highly recommend skipping Haskell for now and learning statically-typed FP using this excellent free online course: https://www.coursera.org/learn/programming-languages

The lecture videos are short, about 10mins each, and Professor Grossman explains the concepts carefully and succinctly, within a fixed teaching framework so you have a predictable learning experience with each concept. It's by far the best way to get into the mindset of typed FP.

I like the advice, but unfortunately not an option in my case -- very short consulting gig

Feel free to email me if you’re stuck. I’d be happy to help you out.

I highly recommend spending a little time trying to understand the basics. You might find “Functors, Applicatives, and Monads in Pictures” helpful: http://adit.io/posts/2013-04-17-functors,_applicatives,_and_...

Type classes, functors, and monads are assumed knowledge in most documentation, as they are foundational concepts in Haskell. Just like math, you must know addition, subtraction, multiplication when learning algebra.

A bunch of languages have some special syntax to solve hairy problems. Async await, yield for generators, ? for dealing with errors in rust, etc.

If those deal with composition and variable scoping in an intuitive way it's a monad. This "intuitive way" is equivalent to changing block scoping in imperative languages.

    {
        let x = foo()
        let y = bar(x)
        let z = baz(x,y)
        ...
    }

should stay equivalent to

    {
        let x = foo()
        let z
        {
            let y = bar(x)
            z = baz(x,y)
        }
        ...
    }

and you should be able to add empty scopes without changing anything so

    {
        foo()
    }

should still equal

    {
         {}
         foo()
         {}
    }

And that's the entire definition of monads. The abstract monad interface is useful to let users define new interpretations for the syntax sugar but not necessary when getting started with haskell - you will pick up intuitions while using it.

I’d just recommend skimming over something like Haskell book to gain some vague familiarity with what concepts exist, then just write code and learn applicative/monad/monoid etc as you run into walls.

Generalizations are notoriously hard to describe as they become more general. Better to understand where and when to use those patterns over being able to write a blog post about what a monad is.

at this point I'm desperate for good docs / resources -- link to anything you particularly like

spent hours figuring out how to debug-print a value from a pure function and still haven't gotten there

    import Debug.Trace
    
    myPureThing :: Bool -> Int
    myPureThing b = if b 
                    then traceShow "yay True" 42 
                    else traceShow "oh noes False" 13

…

    λ> myPureThing True
    "yay True"
    42
    λ> myPureThing False
    "oh noes False"
    13

I don't know if they're good for others, but I read Real World Haskell[1] and Learn You a Haskell[2]. There's also Graham Hutton's book which people like and which is free to read this month or something[3].

[1] http://book.realworldhaskell.org/ – see also the in-progress updated version at https://github.com/tssm/up-to-date-real-world-haskell

[2] http://learnyouahaskell.com/

[3] https://www.cambridge.org/core/books/programming-in-haskell/...

ack sorry, I meant how to add a debug statement to an existing pure function

while still having it return the original value

EDIT per comment below, I totally misread this! yes exactly, traceShow ftw

You saved me another N hours

Isn't that exactly what unhammer is demonstrating?

oops yes

You could also use unsafePerformIO

Really don't.

In principle, you wouldn't do any logging, even debug logging, in a pure function. It always returns the same output for the same input anyway. You'd just check its output.

> spent hours figuring out how to debug-print a value from a pure function

What method did you try to figure it out?

If I google "haskell debug print pure function", the first three results I get are:

* https://hackage.haskell.org/package/base-4.12.0.0/docs/Debug...

* https://stackoverflow.com/questions/13265783/trace-output-in...

* https://en.wikibooks.org/wiki/Haskell/Debugging

and they all have easy, one-line, correct examples of how to do it, within the first 20 seconds of reading.

(This is not to criticise -- sometimes one misses the forest for the trees -- as a professional Haskell consultant who runs trainings I am genuinely interested into what problems people face and why.)

saw a lot of these links and passed over them -- I had it in my head that I could use the `print` command and that I didn't need the debug lib

shrug

there's always an adjustment process when learning something new

Have you seen What I wish I knew when learning Haskell?

[0] http://dev.stephendiehl.com/hask/

If you're serious about picking up the language, I urge you to simply start building something. Build something you can relate with, something similar that you've already built with a different toolset. Like a web server.

A lot of the fancy abstractions don't make sense until you have a problem where you'll actually need them. Artificial problems, like some algorithmic assignments in books just don't click nearly as well to many of us.

Monads are very simple. If you know how futures / promises work (the chain of .then), you already have enough intuition about them.

Also, (Glasgow) Haskell has ghci, a rather nice REPL. You only need to learn to use :{ ... :} for multiline stuff. It's very good for quick experimentation with zero build time.

I worked as a Haskell developer for a year and a half. The best productivity boost I had was switching to compiling on an EC2 instance. I saved battery, sped up compiles with greater parallelism than my XPS had cores for, and didn’t have to worry about cleaning up ~/.stack

wait do I need to worry about cleaning up ~/.stack

Not for correctness, but I was running low on disk

Could you give a short explanation or link to a write up? Which size of EC2 instance works well for compiling Haskell? Does the EC2 live only for the duration of the compile, or permanently? If only for the duration, how do you deal with persisting the installed libraries to disk? Thanks!

I can’t recall exactly, I want to say 16 vCPUs and 64GB. How well a project can make use of the cores depends on how wide your dependency graph is vs how tall, as the unit of parallelism is a package.

The EC2 instance was on continuously, and I would ssh+tmux in. You could probably replace this with a server plugged in under your desk, depending on how much you trade off operational costs and capital costs.

More often than not I wanted passing tests to send something for review. If I needed an artifact, I would publish a docket image on an internal registry.

Reply on news.ycombinator.com