Studies Haskell

Haskell Installation

1. curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

2. [MacOS] copy the entire file (cat ~/.ghcup/env) into ~/.zshrc

3. ghcup tui open a GUI to install the rest part, (i for install; u for uninstall; s for set and enable)

4. [optional] set ghcup mirror: https://mirrors.ustc.edu.cn/help/ghcup.html

5. [optional] set cabal mirror: https://mirrors.ustc.edu.cn/help/hackage.html#cabal

Cabal

User Guide

• Creating a package: https://cabal.readthedocs.io/en/stable/cabal-package.html#creating-a-package

• Package install: cabal install --lib random

Lib Construction and Installation

1. cabal init to create a .cabal file

2. touch Setup.hs and put:

   #!/usr/bin/env runhaskell
   import Distribution.Simple
   main = defaultMain

3. runghc Setup configure --prefix=$HOME --user: config to user level's repo

4. runghc Setup build: build package

5. runghc Setup install: install package

6. ghc-pkg list: list all installed packages

7. ghc-pkg unregister: remove a package

VsCode Setting

settings.json (use ghcup tui to get ghc & hls versions):

  ...
  "haskell.manageHLS": "GHCup",
  "haskell.toolchain": {
    "ghc": "recommended", // otherwise, use specific version, or "latest"
    "hls": "recommended",
    "cabal": "recommended",
    "stack": "recommended"
  },
  "haskell.serverEnvironment": {
    "PATH": "${HOME}/.ghcup/bin:$PATH"
  },
  ...

Project Management

See implicit-hie

cd your-stack-or-cabal-package
stack install implicit-hie # or cabal install implicit-hie
gen-hie > hie.yaml

Test

• compile a single file: ghc --make capslocker.hs

Misc

• While using GHCI, it might show libgmp.so: cannot open shared object file: No such file or directory, and to solve this we can apt install libgmp-dev.

• libtinfo.so: cannot open shared object file: No such file or directory: apt install libtinfo-dev

• Cabal-fmt installation: cabal install cabal-fmt

Cheatsheets

• Symbol

Study Material

• Learn Me a Haskell: reading notes from "Learn you a haskell" [ link ]

  • Ch01 Introduction

  • Ch02 Starting Out

  • Ch03 Types and Typeclasses

  • Ch04 Syntax in Functions

  • Ch05 Recursion

  • Ch06 Higher Order Functions

  • Ch07 Modules

  • Ch08 Making Our Own Types and Typeclasses

  • Ch09 Input and Output

  • Ch10 Functionally Solving Problems

  • Ch11 Functors, Applicative Functors and Monoids

  • Ch12 A Fistful of Monads

  • Ch13 For a Few Monads More

  • Ch14 Zippers

• Learn Real World Haskell: reading notes from "Real World Haskell" [ link ]

  • Ch1 Getting started

  • Ch2 Types and functions

  • Ch3 Defining types, streamlining functions

  • Ch4 Functional programming

  • Ch5 Writing a library: working with JSON data

  • Ch6 Using typeclasses

  • Ch7 Input and output

  • Ch8 Efficient file processing, regular expressions, and file name matching

  • Ch9 I/O case study: a library for searching the filesystem

  • Ch10 Code case study: parsing a binary data format

  • Ch11 Testing and quality assurance

  • Ch12 Barcode recognition

  • Ch13 Data structures

  • Ch14 Monads

  • Ch15 Programming with monads

  • Ch16 The Parsec parsing library

  • Ch17 The foreign function interface

  • Ch18 Monad transformers

  • Ch19 Error handling

  • Ch20 Systems programming

  • Ch21 Working with databases

  • Ch22 Web client programming

  • Ch23 GUI programming

  • Ch24 Basic concurrent and parallel programming

  • Ch25 Profiling and tuning for performance

  • Ch26 Advanced library design: building a Bloom filter

  • Ch27 Network programming

  • Ch28 Software transactional memory

• Haskell in Depth

  • Ch1 Functions and types

  • Ch2 Type classes

  • Ch3 Developing an application: Stock quotes

  • Ch4 Haskell development with modules, packages, and projects

  • Ch5 Monads as practical functionality providers

  • Ch6 Structuring programs with monad transformers

  • Ch7 Error handling and logging

  • Ch8 Writing tests

  • Ch9 Haskell data and code at run time

  • Ch10 Benchmarking and profiling

  • Ch11 Type system advances

  • Ch12 Metaprogramming in Haskell

  • Ch13 More about types

  • Ch14 Data-processing pipelines

  • Ch15 Working with relational databases

  • Ch16 Concurrency

• Soar with Haskell

• Production Haskell

• Effective Haskell

Exercises

• Ninety-Nine Haskell Problems

Reference

• How to install Haskell toolchains (CN)

• H-99: Ninety-Nine Haskell Problems