Learn Haskell by building a blog generator – a project-oriented Haskell book

by gilmi • 4 years ago

230 40 4 years ago

danuker• 4 years ago

How you would write tests in a real project?

I suppose it's not writing out the entire program and then writing the tests, as seems to be implied. That would mean a lot of manual testing.

Or is there a Haskell REPL where you can try out small pieces before saving them?

jose_zap• 4 years ago

Yes, there is GHCi, the Haskell interpreter and repl comes bundled with the compiler.

You can load your entire project in the repl and try your functions there.

rowanG0772• 4 years ago

You have testing libraries in Haskell just like in every other languages. For example: https://hackage.haskell.org/package/tasty

gilmi8• 4 years ago

When you create a project description for your project (for the package manager) you can define a library, executables and test suites.

In the test suite you write your tests against the library. You can do that at any stage, even before writing a line of library code.

But yes, Haskell also has a REPL that can be used to experiment with code.

jokethrowaway• 4 years ago

HUnit is a popular choice: https://mmhaskell.com/testing/test-driven-development

lgas• 4 years ago

In addition to the other good answers you've gotten, I would like to point out that Haskell has QuickCheck (https://hackage.haskell.org/package/QuickCheck) which, if I'm not mistaken, more or less pioneered property testing. Property testing libraries are available in many languages now but they never seem to be as capture the magic of QuickCheck. (There's also https://hackage.haskell.org/package/hedgehog which is sort of a "modern alternative" to QuickCheck but I still prefer the OG).

_query3• 4 years ago

If you want to do web development with Haskell beyond building a blog generator, a good starting point is IHP (https://ihp.digitallyinduced.com/ https://github.com/digitallyinduced/ihp). IHP is Haskell's version of Laravel/Rails/Django. It's really a superpower to have Haskell's type system combined with the rapid development approach of Rails :) (Disclaimer: I'm founder of the company that makes IHP)

froza• 4 years ago

I was tempted to try it, but then I saw that some core features (like mysql) are for paid versions only so its a big red flag already

_query3• 4 years ago

Mysql support is not implemented at the moment. If there's someone paying for the development we could have it. You're of course also free to contribute it yourself to the open source version, then it wouldn't need to be part of the commercial version.

Some more background on why IHP has a paid variant can be found here: https://ihp.digitallyinduced.com/blog/6392ad84-e96a-46ce-9ab...

cultofmetatron• 4 years ago

software needs work and devs have bills. its unfortunate but we don't have a government currently giving grants to open source devs yet.

bitmapper• 4 years ago

I'm really not a fan of IHP for that purpose due to how it redefines so much of the Haskell Prelude without making it clear it does that.

My71staccount• 4 years ago

Ah, I was wondering why you post about IHP on most Haskell threads here and I just noticed it is a commercial product. You should probably disclose that this is an advertisement if it is permitted at all.

_query3• 4 years ago

IHP is mostly an open source project.

I comment on most Haskell threads about IHP because I would love to see more Haskell adoption. Most people think Haskell is about Monads and Math, with IHP we want to show that Haskell can be used in a very productive way to build things. The comments are typically well received, so I don't see any problem with this.

embwbam• 4 years ago

I think IHP for learning Haskell has the same flaw that Rails always did. You have no idea what is part of the language and what is part of the framework. You'll get stuck once you stray from the golden path.

I'd recommend starting with Scotty instead. It's much easier to understand what it is doing. Use Lucid for HTML rendering, and your choice of DB libraries (I like Selda). These all avoid template haskell and don't rename any prelude functions. If you add them one at a time you'll see what each one is offering and understand where to go when you need to do something more complicated

alephnan• 4 years ago

Is the website/book/blog self-hosting?

https://en.wikipedia.org/wiki/Self-hosting_(compilers)

gilmi8• 4 years ago

No. It is built with mdbook[0].

[0] https://rust-lang.github.io/mdBook

matijash• 4 years ago

This is really cool! I've been looking for something like for a while - my learning path was through LYAH and Real-World Haskell (also tried Haskell from the first principles but a bit too extensive IMO). I think this would fit in perfectly between LYAH and RWH.

I am using Haskell mostly for writing compilers (https://github.com/wasp-lang/wasp currently), but I believe if the tutorial isn't using a lot of specialized libraries/frameworks (which seems to be the case from the first glance), a majority of the material taught should be transferable to any domain.

gilmi8• 4 years ago

Thanks!

hans1729• 4 years ago

At first sight I’ve read “an object-oriented Haskell book”.

[brief pause for contemplating the thought]

Naturally, someone went there: https://www.parsonsmatt.org/tutorials/

greymalik• 4 years ago

The linked articles are actually about how to translate problems from an OOP perspective into idiomatic Haskell.

cosmic_quanta• 4 years ago

That's the perfect learning project because there's something tangible at the end.

Whenever the question of "How do I learn Haskell" comes up, I always suggest to come up with a project that would be useful on its own, regardless of the technology used to create it, and use Haskell to do it. In my case it was a pandoc filter to embed plots in documents (https://github.com/LaurentRDC/pandoc-plot), which was ultimately useful to create my PhD dissertation.

There's only so much you can learn about Haskell by working through toy examples.

cholantesh• 4 years ago

Great project; I'd have loved to have had it when I was writing my dissertation - hell, I'd have liked anything that would have let me write it in vim and just generate the final submission per the university's format, because I hate Word.

zeckalpha• 4 years ago

I have found Hakyll to be useful in this space, if you want to move from building your own to configuring/extending your own.

Iceland_jack4• 4 years ago

Oh this looks fun getStructureString and render can be defined as record selectors

  newtype Structure = Structure { getStructureString :: String }
  newtype Html      = Html      { render             :: String }

BlockArguments let you write expressions like myhtml

  myhtml :: Html
  myhtml =
    html_
      "My title"
      ( append_
        (h1_ "Heading")
        ( append_
          (p_ "Paragraph #1")
          (p_ "Paragraph #2")
        )
      )

in a more domain-specific style. De gustibus, but some may prefer it to the parentheses.

  {-# Language BlockArguments #-}

  myhtml :: Html
  myhtml =
    html_ "My title" do
      append_
        do h1_ "Heading"
        do append_
             do p_ "Paragraph #1"
             do p_ "Paragraph #2"

or using the associativity of append_ = (<>)

  myhtml =
    html_ "My title" do
      h1_ "Heading" <> p_ "Paragraph #1" <> p_ "Paragraph #2"

  myhtml =
    html_ "My title" do mconcat
      [ h1_ "Heading"
      , p_ "Paragraph #1"
      , p_ "Paragraph #2"
      ]

All examples of 'concat . map' can be replaced with.. concatMap :Ð

Iceland_jack4• 4 years ago

Instead of defining append_ for structure

  newtype Structure = Structure String

  append_ :: Structure -> Structure -> Structure
  append_ (Structure c1) (Structure c2) = Structure (c1 <> c2)

  empty_ :: Structure
  empty_ = Structure ""

the <> operator (from Semigroup) can be reused by deriving it via the underlying String type (edit: I see this is suggested later in the tutorial).

  {-# Language DerivingStrategies         #-}
  {-# Language GeneralizedNewtypeDeriving #-}

  newtype Structure = Structure String
    deriving
    newtype (Semigroup, Monoid)

  append_ :: Structure -> Structure -> Structure
  append_ = (<>)

  empty_ :: Structure
  empty_ = mempty

Semigroup and Monoid let us use a lot of standard vocabulary

  concatStructure :: [Structure] -> Structure
  concatStructure list =
    case list of
      [] -> empty_
      x : xs -> x <> concatStructure xs

becomes

  concatStructure :: [Structure] -> Structure
  concatStructure = mconcat

  concatStructure = fold

Also in the detour about kinds they are written as * while the ecosystem is moving towards a more uniform Type name.

  {-# Language StandaloneKindSignatures #-}

  import Data.Kind (Type)

  type Tuple :: Type -> Type -> Type
  data Tuple a b = Tuple a b

  type Either :: Type -> Type -> Type
  data Either a b = Left a | Right b

gilmi8• 4 years ago

Right but the point of the book is to ease learners into the language (and teach core concepts), and not throw them into the deep end of it.

Also, I'll update the text about kinds when GHC will use Type instead of * everywhere:

$ ghci

GHCi, version 9.2.2: https://www.haskell.org/ghc/ :? for help

λ> :k (,)

(,) :: * -> * -> *

ypeterholmes• 4 years ago

For anyone that does decide to learn Haskell, you can easily get a job afterwards working on the Cardano blockchain. Smart contract devs are in high demand, and Cardano uses a variant of Haskell that is relatively unique to the space.

punkbit• 4 years ago

I've been following for at least a year and find that the jobs pay is very low in comparison to Rust; or Solidity.

I also don't see much jobs available.

Where do you see those job listings?

bwanab• 4 years ago

If you’re more inclined to visual and/or musical arts, I’d recommend “Th Haskell School Of Expression” by Paul Hudak. He guides you through the language and the techniques with an eye for concise, expressive code that has good runtime characteristics.

mbrodersen• 4 years ago

Kudos to the author. The best way to teach something is to start with a foundation of nothing and then step by step building layers of understanding on top of it. Most other Haskell tutorials fail to do this.

gilmi8• 4 years ago

Thank you!

Learn Haskell by building a blog generator – a project-oriented Haskell book

Related Stories