haskellEngineer

The contribution demonstrates basic means of modularization (using Haskell's native module system), code organization (using where clauses for local scope), packaging (using Technology:Cabal), documentation (using Technology:Haddock), and unit testing (using Technology:HUnit). Other than that, only basic language constructs are exercised and a very limited feature set of the system:Company is implemented. The contribution is indeed more of a showcase for a pattern for modularization, code organization, packaging, documentation, and unit testing.

Illustration

Modular organization

The contribution consists of the modules as listed in following file:

name:                haskellEngineer
version:             0.1.0.0
synopsis:            Basic software engineering for Haskell
homepage:            http://101companies.org/wiki/Contribution:haskellEngineer
build-type:          Simple
cabal-version:       >=1.9.2

library
  exposed-modules:
    Main
    Company.Data
    Company.Sample
    Company.Total
    Company.Cut
  build-depends:       base >=4.4 && < 5.0, HUnit
  hs-source-dirs:      src

test-suite basic-tests
    main-is:           Main.hs
    build-depends:     base, HUnit
    hs-source-dirs:    src
    type:              exitcode-stdio-1.0

The modules implement features as follows:

Company/Data.hs: Feature:Flat company.
Company/Sample.hs: A sample company.
Company/Total.hs: Feature:Total.
Company/Cut.hs: Feature:Cut.
Main.hs: Unit tests for demonstration.

For instance, the implementation of Feature:Total takes this form:

{-| The operation of totaling all salaries of all employees in a company -}

module Company.Total where

import Company.Data

-- | Total all salaries in a company
total :: Company -> Float
total = sum . salaries
  where

    -- Extract all salaries in a company
    salaries :: Company -> [Salary]
    salaries (_, es) = getSalaries es
      where

        -- Extract all salaries of lists of employees
        getSalaries :: [Employee] -> [Salary]
        getSalaries [] = []
        getSalaries (e:es) = getSalary e : getSalaries es
          where

            -- Extract the salary from an employee
            getSalary :: Employee -> Salary
            getSalary (_, _, s) = s

Please note how "where clauses" are used to organize the declarations in such a way that it is expressed what function is a helper function to what other function. The declaration of such local scope also implies that the helper functions do not feed into the interface of the module.

Haddock comments

Technology:Haddock comments are used to enable documentation generation. Consider again the module shown above. Haddock comments are used for the functions total and salaries but not for the remaining functions, as they are not exported and thus, they do not need to be covered by the generated documentation.

External dependencies

The contribution has the following dependencies; see again the .cabal file:

build-depends: base >=4.4 && < 5.0, HUnit

These packages serve the following purposes:

base: This is the Haskell base package; a range of versions is permitted.
HUnit: This is the package for Technology:HUnit; its version is not explicitly constrained.

HUnit testcases

The contribution is tested by the following test cases:

tests =
  TestList [
    TestLabel "total" totalTest,
    TestLabel "cut" cutTest,
    TestLabel "serialization" serializationTest
  ]

For instance, the test case for serialization looks as follows:

serializationTest = sampleCompany ~=? read (show sampleCompany)

Relationships

The present contribution is an "engineered" variation on Contribution:haskellStarter. That is, modularization, packaging, documentation, and unit testing was applied.
Several other contributions derive from the present contribution more or less directly by demonstrating additional language or technology capabilities or implementing additional features of the system:Company.