Haskell quick start

Haskell resource is a little bit outdated and if you take a look at https://www.haskell.org/documentation/ you would found there are several tutorials, make choose one be a hard thing. So I decide to make a simple quick start to record how I start with Haskell.

Before we typing any code, we have to install Haskell, please take a look at https://www.haskell.org/downloads/.

Binding

Let's start from a hello world example:

main :: IO ()
main = do
  putStrLn "Hello, World!"

We call it helloworld.hs, now run runhaskell helloworld.hs, should get: Hello, World! as an output on the screen.

We can find main appears twice. We call the first one as type binding, the second one as binding. Type binding shows the type of main, binding shows what would main do. At here IO is a kind of special type, its called Monad, and we are not going to explain it but can see that the body of main has a notation do, under do notation would be a special syntax that helps us create a DSL for certain domain, here is IO.

Keep going we add read into our program:

import           System.IO

main :: IO ()
main = do
  who <- getLine
  putStrLn ("Hello, " ++ who)

getLine would read the text you typed until a newline in as a string. Here we see a new symbol <-, it might weird at the beginning that it means = in do notation(we actually can use let who = replace <-). What <- do is make a Monad a be a. Then we can use it at the next function. ("Hello, " ++ who) is required, since Haskell doesn't use function_name(parameter*) this form, distinguish the argument belongs to which function call can be quite complex even undecidable and to make our brain work easier better add () for all function call, and tend to use temporary variables for the argument to explain code better.

Now, you probably already found Haskell does not use {} for block body. In Haskell, indent has meaning. For example:

import           System.Environment
import           System.IO

main :: IO ()
main = do
  args <- getArgs
  case args of
    [] -> putStrLn "no arg"
    [one] -> putStrLn "one arg"
    rest ->
      case rest of
        [one, two] -> putStrLn "two args"
        _          -> putStrLn "many args"

We use getArgs from System.Environment and case of syntax. Can see how indent makes the case syntax became different blocks. Of course, I would say better do not have too many indents, its quite easy to confuse yourself.

p.s. I didn't explain list patterns in matching, I hope the output is clean enough to understand those list patterns.

Now let's back to type binding and binding, so why we have to write them twice? In fact, we can ignore type binding:

main = do
  putStrLn "Hello, World!"

I really don't like this idea, at the beginning it sounds like a good idea: Let compiler inferences and tells us what is the type of binding. This is a trap when the compiler does inference, it has to rely on the using case to guess the type of binding. We have a trivial example:

id x = x

When we do function call by id 1, x might be Int, when we call it by id "wow", x might be String. Now imagine a bigger function and the type of it was always changing since we didn't give it a type, can anyone work with it quite happy? I don't think so. So make sure you give it a good type. In fact, the semantic checker would warn those global level binding which didn't with type binding. Well, we can't ignore any type of bindings? I think that's ok in where clause. In Haskell where clause can put some helpers which we don't want other functions to use it.

foo = bar
  where
    bar = 1

In where we can put many private bindings, and since they are usually short and easy to understand, without type binding might be ok, but if you found without type binding they would be hard to understand, then please still give it a type.

Type

Now, we need to define some new types. In Haskell, we usually use data keyword to create a new type. data syntax is quite complex, we can take a look at few examples to understand it.

The first example creates a Bool

data Bool = True | False

To use it: False, True. We call True and False as constructors of Bool. You can see that | separate different constructors. This is called algebra data type. In fact, constructors can with arguments.

data Position = MakePosition Double Double

We can use like: MakePosition 1.0 0.0

When we do pattern matching on the type made by data, we can use their constructors:

case bool of
  True -> -- ...
  False -> -- ...
-- or
case pos of
  MakePosition x y -> -- ...

p.s. -- is the comment in Haskell

Well, MakePosition makes a new question: Can we use pos in the branch of MakePosition? Yes, by @ pattern, we can get the constructors:

case pos of
  p1@MakePosition x y -> -- ...

It seems useless because pos is p1 in case. But it's very helpful when Position has several constructors. A nice thing is Haskell would do exhaustiveness checking to make sure all variants of constructors were covered by your pattern matching.

Keep move forward, sometimes we would like to create a type and some operations that can be reused by different type-arguments. It called type parameters. You probably already found that in Haskell all of the types were started with upper case. That's because the start of the lower case was reserved for the type parameter.

The first example is Maybe:

data Maybe a =
  Just a
  | Nothing

What is Maybe for? In Haskell, we do not have the bottom type. What's the bottom type? In Java, every object can be null, null can be seen as a value of bottom type. The bottom type represents a subtype of any type, so its value can be the value of any type. Of course, null in Java is not so correctly means a bottom type since the primitive type work under another system, but it's good enough to make we keep going.

So we actually need a type to represent nothing, that is Maybe, Maybe has two constructors, for has value: Just a and no value: Nothing. But doing operations on Maybe is annoying, if without Control.Applicative. We can see how it work with Applicative:

import Control.Applicative

(+) <$> Just 2 <*> Just 3
-- Just 5
(*) <$> Just 2 <*> Just 3
-- Just 6
(+) <$> Just 2 <*> Nothing
-- Nothing

You can understand Applicative like this: + takes two parameters, <$> means we start to give it arguments, use <*> join more arguments if there is more than one argument.

There has a structure-like syntax for constructors:

data Position = MakePosition {
  getX :: Double
  , getY :: Double
  }

An unfortunate problem is getX and getY is not in the global environment, so if now we add:

data Wow = MakeWow {
  getX :: Double
  , getY :: Double
  }

The compiler would complain about there are redefined symbols.

Conclusion

I hope you already learn a little thing that enough to start programming with Haskell. There still have many features were not mentioned in the article. Originally as https://dannypsnl.github.io/docs/golang-quick-start/, I want to show all major features in Haskell, but it probably would be really hard. Explain Monad might need an alone article. And high-order function and Kind also quite not suitable in an article prepared for beginner. Understand fold, map and recursive also be out of the topic of the article, so I would write the others for them. Thanks for the read.