haskell-programming-from-first-principles's Introduction

Haskell Programming from First Principles

This repository hosts my notes and solutions to exercises in the book Haskell Programming from First Principles.

Dependencies

The only dependency is Stack. Once setup, Stack takes care of any Haskell package dependencies.

Project structure

This repository is organized as a single Stack project as follows

.
├── benchmark/
├── ChangeLog.md
├── haskell-programming-from-first-principles.cabal
├── LICENSE
├── package.yaml
├── README.md
├── Setup.hs
├── src/
├── stack.yaml
└── test/

where src are solutions whose name follows the pattern

ChapterName/SectionName/ExerciseName.hs

test and benchmark are test and benchmark suites following the same naming convention.

Run tests

All test suites can be discovered by hspec-discover. To run tests, simply do

stack test

stack --fast test

if you want avoid GHC optimization (hence faster).

Run benchmarks

Run

stack bench

Never use the --fast flag for benchmarks otherwise you will get wrong results.

Reference benchmark results are included in each benchmark file as block comment.

haskell-programming-from-first-principles's People

Contributors

Stargazers

Watchers

haskell-programming-from-first-principles's Issues

stack overflow in your solution for McCarthy91 problem

Proposed Enhancement: for AlgebraicDataTypes/ChapterExercises/AsPatterns.hs

At src/AlgebraicDataTypes/ChapterExercises/AsPatterns.hs

Expected:

isSubsequenceOf "blah" "wootbla" == False
isSubsequenceOf "blah" "halbwoot" == False

as stated in page 695 of the eBook "Haskell from the First Principle"

Actual:

isSubsequenceOf "blah" "wootbla" == True
isSubsequenceOf "blah" "halbwoot" == True

Proposed enhancement:

  indexOf :: (Eq a) => a -> [a] -> Int
  indexOf x ys = case elemIndex x ys of 
    Just a -> a 
    Nothing -> -1

  splitBy :: (Eq a) => a -> [a] -> ([a], [a])
  splitBy x = span (/= x)

  joinWithout :: (Eq a) => a -> [a] -> [a]
  joinWithout x ys = let (a, b) = splitBy x ys in (a ++ tail b)  

  isSubseqOf :: (Eq a) => [a] -> [a] -> Bool
  isSubseqOf [] _ = True 
  isSubseqOf _ [] = False
  -- @TODO: strip each element of the referenced list after each recursion
  isSubseqOf (x : xs) ys 
    | null ys'' = False
    | otherwise = 
        case xs of 
          (z : _) -> 
            let idX = indexOf x ys
                idZ = indexOf z ys in
            case (compare idX idZ) of 
              LT -> isSubseqOf xs (joinWithout x ys)
              _  -> False
          _       -> isSubseqOf xs (joinWithout x ys)
    where (ys', ys'') = splitBy x ys

Recommend Projects