Language Guide: Haskell

このページはただいま翻訳中です

This guide will help you get started with a basic Haskell application on CircleCI 2.0. If you’re in a rush, feel free to copy the sample configuration below into a .circleci/config.yml in your project’s root directory and start building.

Sample Configuration
Config Walkthrough
Common Trouble Shooting

Overview

You can view an example Haskell project that build with CircleCI at the following link:

Demo Haskell Project on GitHub

In the project you will find a commented CircleCI configuration file .circleci/config.yml.

Sample Configuration

version: 2.1
jobs:
  build:
    docker:
      - image: fpco/stack-build:lts
    steps:
      - checkout
      - restore_cache:
          # Read about caching dependencies: https://circleci.com/docs/2.0/caching/
          name: Restore Cached Dependencies
          keys:
            - cci-demo-haskell-v1-{{ checksum "package.yaml" }}-{{ checksum "stack.yaml" }}
      - run:
          name: Resolve/Update Dependencies
          command: stack setup
      - run:
          name: Run tests
          command: stack test
      - run:
          name: Install executable
          command: stack install
      - save_cache:
          name: Cache Dependencies
          key: cci-demo-haskell-v1-{{ checksum "package.yaml" }}-{{ checksum "stack.yaml" }}
          paths:
            - "/root/.stack"
            - ".stack-work"
      - store_artifacts:
          # Upload test summary for display in Artifacts: https://circleci.com/docs/2.0/artifacts/ 
          path: ~/.local/bin/circleci-demo-haskell-exe
          destination: circleci-demo-haskell-exe

Config Walkthrough

Every config.yml starts with the version key. This key is used to issue warnings about breaking changes.

version: 2.1

Next, we have a jobs key. Each job represents a phase in your workflow. Our sample app only needs a build job, so all our steps and commands will live under that key.

A run is comprised of one or more jobs. Because this run does not use workflows, it must have a build job.

The steps of a job occur in a virtual environment called an executor.

In this example, the docker executor is used to specify a custom Docker image. The first image listed becomes the job’s primary container.

All commands for a job execute in this container.

jobs:
  build:
    docker:
      - image: fpco/stack-build:lts

We are now set to run the Haskell build tool stack in our environment. The remainder of our config.yml file all falls under the steps key.

Our first step is to run checkout to pull our repository’s code down and set it up in our environment.

Next we check if there are any dependencies that can be restored, enabling our build to speed up. Following that, we run stack setup to pull in the Haskell compiler as specified in the stack.yaml config.

    steps:
      - checkout
      - restore_cache:
          name: Restore Cached Dependencies
          keys:
            - cci-demo-haskell-v1-{{ checksum "package.yaml" }}-{{ checksum "stack.yaml" }}
      - run:
          name: Resolve/Update Dependencies
          command: stack setup
      - save_cache:
          name: Cache Dependencies
          key: cci-demo-haskell-v1-{{ checksum "package.yaml" }}-{{ checksum "stack.yaml" }}
          paths:
            - ~/.stack
            - ~/.stack-work

Note: It’s also possible to use a cabal build file for caching dependencies. stack, however, is commonly recommended, especially for those new to the Haskell ecosystem. Because this demo app leverages stack.yaml and package.yaml, we use these two files as the cache key for our dependencies. You can read more about the differences between stack and cabal on The Haskell Tool Stack docs.

Finally, we can run our application build commands. We’ll run our tests first and then move on to install our executable. Running stack install will create a binary and move it to ~/.local/bin.

      - run:
          name: Run tests
          command: stack test
      - run:
          name: Install executable
          command: stack install

Finally, we can take the built executable and store it as an artifact.

      - store_artifacts:
          # Upload buildresults for display in Artifacts: https://circleci.com/docs/2.0/artifacts/ 
          path: ~/.local/bin/circleci-demo-haskell-exe 
          destination: circleci-demo-haskell-exe

Excellent! You are now setup on CircleCI with a Haskell app.

Common Trouble Shooting

The command stack test may fail with an out of memory error. Consider adding the -j1 flag to the stack test command as seen below (Note: this will reduce test execution to one core, decreasing memory usage as well, but may also increase your test execution time).

      - run:
          name: Run tests
          command: stack test -j1

Search Results for ""

Language Guide: Haskell

Overview

Sample Configuration

Config Walkthrough

Common Trouble Shooting

See Also