nWave-ai/nWave / nWave/skills/nw-fp-haskell
nw-fp-haskell
VerifiedHaskell language-specific patterns, GADTs, type classes, and effect systems
FP in Haskell -- Functional Software Crafter Skill
Cross-references: fp-principles | fp-domain-modeling | pbt-haskell
When to Choose Haskell
- Best for: correctness-critical systems | compiler-enforced purity | maximum type safety | financial systems
- Not ideal for: teams needing fast onboarding | rapid prototyping | .NET/JVM platform requirements
[STARTER] Quick Setup
# Install GHCup (manages GHC, cabal, stack, HLS)
# Never pipe a remote download into a shell: download a pinned released binary,
# verify the GPG signature of the published checksum file, check the digest,
# and install only the verified binary. (0.2.6.2 was current on 2026-11-10;
# check https://downloads.haskell.org/~ghcup/ for the current release and keep
# the version pinned while verifying.)
curl --proto '=https' --tlsv1.2 -sSf -o x86_64-linux-ghcup-0.2.6.2 https://downloads.haskell.org/~ghcup/0.2.6.2/x86_64-linux-ghcup-0.2.6.2
curl --proto '=https' --tlsv1.2 -sSf -o SHA256SUMS https://downloads.haskell.org/~ghcup/0.2.6.2/SHA256SUMS
curl --proto '=https' --tlsv1.2 -sSf -o SHA256SUMS.sig https://downloads.haskell.org/~ghcup/0.2.6.2/SHA256SUMS.sig
# 1. Verify the checksum file's GPG signature against the release key, pinned by
# fingerprint (Julian Ospald; a subkey of this key may have made the signature).
gpg --batch --keyserver keyserver.ubuntu.com --recv-keys 7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
gpg --verify SHA256SUMS.sig SHA256SUMS
# A Good signature is required and the printed primary key fingerprint MUST be
# 7D1E 8AFD 1D4A 16D7 1FAD A2F2 CCC8 5C0E 40C0 6A8C; on any mismatch, stop.
# 2. Check the binary digest against the signed checksum file:
sha256sum --check --ignore-missing SHA256SUMS
# Must print OK for x86_64-linux-ghcup-0.2.6.2; on failure or a missing OK, stop.
# 3. Install only the verified binary and let it manage the toolchain:
mkdir -p "$HOME/.ghcup/bin" && install x86_64-linux-ghcup-0.2.6.2 "$HOME/.ghcup/bin/ghcup"
ghcup install ghc cabal hls stack
# Create project
mkdir order-service && cd order-service && cabal init --interactive
# Or: stack new order-service simple && stack build && stack test
Test runner: cabal test or stack test. Add hspec, QuickCheck, hedgehog to build-depends.
[STARTER] Type System for Domain Modeling
Choice Types (Sum Types)
data PaymentMethod
= CreditCard CardNumber ExpiryDate
| BankTransfer AccountNumber
| Cash
deriving (Eq, Show)
Record Types and Newtypes
data Customer = Customer
{ customerId :: CustomerId
, customerName :: CustomerName
, customerEmail :: EmailAddress
} deriving (Eq, Show)
newtype OrderId = OrderId Int deriving (Eq, Ord, Show)
newtype EmailAddress = EmailAddress Text deriving (Eq, Show)
newtype is erased at compile time -- zero runtime overhead, full type safety.
[STARTER] Validated Construction (Smart Constructors)
module Domain.Email (EmailAddress, mkEmailAddress, emailToText) where
import Data.Text (Text)
import qualified Data.Text as T
newtype EmailAddress = EmailAddress Text deriving (Eq, Show)
mkEmailAddress :: Text -> Either ValidationError EmailAddress
mkEmailAddress raw
| "@" `T.isInfixOf` raw = Right (EmailAddress raw)
| otherwise = Left (InvalidEmail raw)
Export the type but not the constructor. Only mkEmailAddress can create values.
[INTERMEDIATE] Composition Style
Function Composition (Right-to-Left)
-- (.) composes right-to-left
processOrder :: RawOrder -> Either OrderError Confirmation
processOrder = confirmOrder . priceOrder . validateOrder
Monadic Chaining with do-notation
placeOrder :: RawOrder -> Either OrderError Confirmation
placeOrder raw = do
validated <- validateOrder raw
priced <- priceOrder validated
confirmOrder priced
Applicative for Independent Validation
mkCustomer :: Text -> Text -> Either ValidationError Customer
mkCustomer rawName rawEmail =
Customer
<$> mkCustomerId 0
<*> mkCustomerName rawName
<*> mkEmailAddress rawEmail
Error-Accumulating Validation
import Data.Validation (Validation, failure, success)
mkCustomerV :: Text -> Text -> Validation [ValidationError] Customer
mkCustomerV rawName rawEmail =
Customer
<$> validateName rawName -- Validation [ValidationError] CustomerName
<*> validateEmail rawEmail -- all errors collected, not short-circuited
Unlike Either which stops at first error, Validation accumulates all failures via its Applicative instance.
[INTERMEDIATE] Effect Management
Haskell enforces purity at the compiler level. IO in return type means side effects.
calculateTotal :: Order -> Money -- Pure: compiler guarantees no side effects
calculateTotal order = sumOf (orderLines order)
saveOrder :: Order -> IO () -- Impure: IO in the type
saveOrder order = writeToDatabase order
-- calculateTotal CANNOT call saveOrder -- compiler error
[ADVANCED] Three Layers Pattern (Hexagonal Architecture)
-- Layer 1: Pure domain (no IO, no effects)
module Domain.Order (calculateDiscount, validateOrder) where
calculateDiscount :: Order -> Discount
calculateDiscount order
| totalLines order > 10 = Discount 0.1
| otherwise = Discount 0.0
-- Layer 2: Effect interfaces (type classes as ports)
class Monad m => OrderRepo m where
findOrder :: OrderId -> m (Maybe Order)
saveOrder :: Order -> m ()
-- Layer 3: IO implementations (adapters)
instance OrderRepo IO where
findOrder orderId = queryDatabase orderId
saveOrder order = insertDatabase order
Effect libraries: Effectful (recommended starting point, best performance) | mtl (existing codebases) | Polysemy (algebraic effect semantics).
[INTERMEDIATE] Testing
Frameworks: QuickCheck (original PBT) | Hedgehog (integrated shrinking) | Hspec (BDD) | tasty (composable test tree). See pbt-haskell for detailed PBT patterns.
Property Test Example
import Test.Hspec
import Test.QuickCheck
spec :: Spec
spec = describe "validateOrder" $ do
it "round-trips through serialization" $
property $ \order ->
deserializeOrder (serializeOrder order) === Right order
it "validated orders always have positive totals" $
property $ \rawOrder ->
case validateOrder rawOrder of
Left _ -> discard
Right valid -> orderTotal valid > Money 0
Custom Generator
import Data.Text (pack)
import Test.QuickCheck
genValidEmail :: Gen EmailAddress
genValidEmail = do
user <- listOf1 (elements ['a'..'z'])
domain <- listOf1 (elements ['a'..'z'])
pure (EmailAddress (pack (user ++ "@" ++ domain ++ ".com")))
[ADVANCED] Idiomatic Patterns
GADTs for State Machines
{-# LANGUAGE GADTs, DataKinds #-}
data OrderState = Unvalidated | Validated | Priced
data Order (s :: OrderState) where
UnvalidatedOrder :: RawData -> Order 'Unvalidated
ValidatedOrder :: ValidData -> Order 'Validated
PricedOrder :: PricedData -> Order 'Priced
-- Type-safe transitions: only validated orders can be priced
priceOrder :: Order 'Validated -> Either PricingError (Order 'Priced)
priceOrder (ValidatedOrder d) = Right (PricedOrder (addPricing d))
Lazy Evaluation for Decoupled Pipelines
eligibleOrders :: [Order] -> [Order]
eligibleOrders = take 10 . filter isEligible . sortBy orderDate
Maturity and Adoption
- Steep learning curve: Monads, type classes, category-theory vocabulary create significant onboarding barrier. Budget extra ramp-up time.
- GHC extensions confusion: Over 100 language extensions; knowing which to enable requires experience. Start with
GHC2021defaults. - Space leaks from laziness: Default lazy evaluation causes subtle memory issues. Requires profiling discipline and strict annotations.
- Smaller talent pool: Hiring Haskell developers harder than mainstream languages. Consider team sustainability before committing.
Common Pitfalls
- Lazy space leaks: Use
foldl'(strict) instead offoldl. UseBangPatternsfor strict accumulators. - String vs Text: Never use
String([Char]) for real data. UseData.Text/Data.ByteString. - Orphan instances: Define instances in the module of the type or class. Use newtype wrappers otherwise.
- Over-abstracting with type-level programming: GADTs and type families increase compile times and error complexity. Use for genuine safety gains.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |