@nockdev/awf 6.2.0

package/.agent/skills/languages/haskell/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: haskell
+detect: ["*.hs", "*.cabal", "stack.yaml", "cabal.project", "package.yaml"]
+version: "6.1.2"
+category: functional
+tier: 2
+---
+
+# Haskell Patterns — DOMYH Awesome Code
+
+> **Version**: GHC 9.8+ (2025-2026)
+> **Framework**: Servant, Yesod
+> **Philosophy**: Pure functions, strong types, lazy evaluation
+
+---
+
+## 🎯 When to Use This Skill
+
+Use for: Compilers, parsers, formal verification, type-safe APIs.
+**NOT for**: Rapid prototyping (→ python), web UI (→ react).
+
+---
+
+## 📦 Recommended Stack
+
+| Library        | Use Case            | Install                    |
+| -------------- | ------------------- | -------------------------- |
+| **Servant**    | Type-safe APIs 🏆   | `cabal install servant`    |
+| **Aeson**      | JSON parsing        | `cabal install aeson`      |
+| **Lens**       | Optics              | `cabal install lens`       |
+| **Persistent** | Database ORM        | `cabal install persistent` |
+| **QuickCheck** | Property testing 🏆 | `cabal install QuickCheck` |
+
+---
+
+## 🔧 Project Setup
+
+```bash
+# With cabal
+mkdir myproject && cd myproject
+cabal init --interactive
+
+# With stack
+stack new myproject
+cd myproject
+stack build
+```
+
+### Project Structure
+
+```
+myproject/
+├── app/
+│   └── Main.hs
+├── src/
+│   ├── Lib.hs
+│   └── Types.hs
+├── test/
+│   └── Spec.hs
+├── myproject.cabal
+└── cabal.project
+```
+
+---
+
+## 🔄 Core Patterns
+
+### Algebraic Data Types
+
+```haskell
+-- ✅ Sum type (enum)
+data Status = Active | Inactive | Pending
+  deriving (Show, Eq)
+
+-- ✅ Product type (record)
+data User = User
+  { userId    :: Int
+  , userName  :: Text
+  , userEmail :: Text
+  , userStatus :: Status
+  } deriving (Show, Eq, Generic)
+
+-- ✅ Parameterized types
+data Result e a = Error e | Success a
+  deriving (Show, Eq, Functor)
+
+-- ✅ GADT for type safety
+data Expr a where
+  LitInt  :: Int -> Expr Int
+  LitBool :: Bool -> Expr Bool
+  Add     :: Expr Int -> Expr Int -> Expr Int
+  If      :: Expr Bool -> Expr a -> Expr a -> Expr a
+```
+
+### Functor, Applicative, Monad
+
+```haskell
+-- ✅ Functor: map over context
+data Maybe a = Nothing | Just a
+
+instance Functor Maybe where
+  fmap _ Nothing  = Nothing
+  fmap f (Just a) = Just (f a)
+
+-- ✅ Applicative: combine contexts
+instance Applicative Maybe where
+  pure = Just
+  Nothing <*> _ = Nothing
+  _ <*> Nothing = Nothing
+  Just f <*> Just a = Just (f a)
+
+-- Usage: validate multiple fields
+data Person = Person { name :: Text, age :: Int }
+
+validatePerson :: Maybe Text -> Maybe Int -> Maybe Person
+validatePerson mName mAge = Person <$> mName <*> mAge
+
+-- ✅ Monad: sequence dependent operations
+instance Monad Maybe where
+  Nothing >>= _ = Nothing
+  Just a >>= f = f a
+
+-- Usage: chain operations
+findUser :: Int -> Maybe User
+getUserPosts :: User -> Maybe [Post]
+
+getUserPostsById :: Int -> Maybe [Post]
+getUserPostsById id = do
+  user <- findUser id
+  posts <- getUserPosts user
+  pure posts
+```
+
+### Error Handling
+
+```haskell
+import Control.Monad.Except
+
+-- ✅ Either for errors
+data AppError
+  = NotFound Text
+  | ValidationError Text
+  | DatabaseError Text
+  deriving (Show, Eq)
+
+type AppM = ExceptT AppError IO
+
+findUser :: Int -> AppM User
+findUser id = do
+  mUser <- liftIO $ queryUser id
+  case mUser of
+    Nothing -> throwError (NotFound "User not found")
+    Just user -> pure user
+
+-- Run with error handling
+runApp :: AppM a -> IO (Either AppError a)
+runApp = runExceptT
+```
+
+---
+
+## 🌐 Servant API
+
+```haskell
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE TypeOperators #-}
+
+import Servant
+
+-- ✅ Type-level API definition
+type UserAPI =
+       "users" :> Get '[JSON] [User]
+  :<|> "users" :> Capture "id" Int :> Get '[JSON] User
+  :<|> "users" :> ReqBody '[JSON] CreateUser :> Post '[JSON] User
+  :<|> "users" :> Capture "id" Int :> Delete '[JSON] NoContent
+
+-- ✅ Handler implementation
+server :: Server UserAPI
+server = listUsers :<|> getUser :<|> createUser :<|> deleteUser
+  where
+    listUsers :: Handler [User]
+    listUsers = liftIO $ queryAllUsers
+
+    getUser :: Int -> Handler User
+    getUser id = do
+      mUser <- liftIO $ queryUser id
+      maybe (throwError err404) pure mUser
+
+    createUser :: CreateUser -> Handler User
+    createUser dto = liftIO $ insertUser dto
+
+    deleteUser :: Int -> Handler NoContent
+    deleteUser id = do
+      liftIO $ removeUser id
+      pure NoContent
+
+-- ✅ Run server
+main :: IO ()
+main = run 8080 $ serve (Proxy @UserAPI) server
+```
+
+---
+
+## 🔍 Lens Patterns
+
+```haskell
+{-# LANGUAGE TemplateHaskell #-}
+
+import Control.Lens
+
+data Address = Address
+  { _city    :: Text
+  , _street  :: Text
+  , _zipCode :: Text
+  } deriving (Show)
+
+data Person = Person
+  { _name    :: Text
+  , _age     :: Int
+  , _address :: Address
+  } deriving (Show)
+
+makeLenses ''Address
+makeLenses ''Person
+
+-- ✅ View (get)
+getName :: Person -> Text
+getName p = p ^. name
+
+-- ✅ Set
+setName :: Text -> Person -> Person
+setName n p = p & name .~ n
+
+-- ✅ Modify
+incrementAge :: Person -> Person
+incrementAge = age %~ (+1)
+
+-- ✅ Nested access
+getCity :: Person -> Text
+getCity p = p ^. address . city
+
+setCity :: Text -> Person -> Person
+setCity c = address . city .~ c
+```
+
+---
+
+## 🧪 Testing with QuickCheck
+
+```haskell
+import Test.QuickCheck
+import Test.Hspec
+
+-- ✅ Property-based testing
+prop_reverseReverse :: [Int] -> Bool
+prop_reverseReverse xs = reverse (reverse xs) == xs
+
+prop_sortIdempotent :: [Int] -> Bool
+prop_sortIdempotent xs = sort (sort xs) == sort xs
+
+-- ✅ Custom generators
+instance Arbitrary User where
+  arbitrary = do
+    id <- arbitrary
+    name <- elements ["Alice", "Bob", "Carol"]
+    email <- arbitrary
+    pure $ User id name email
+
+-- ✅ HSpec tests
+spec :: Spec
+spec = do
+  describe "User validation" $ do
+    it "rejects empty names" $
+      validateUser (User 1 "" "a@b.com") `shouldBe` Left "Name required"
+
+    it "satisfies reverse property" $
+      property prop_reverseReverse
+```
+
+---
+
+## ✅ Production Checklist
+
+### Code Quality
+
+- [ ] HLint suggestions addressed
+- [ ] Ormolu/fourmolu formatting
+- [ ] GHC warnings clean (-Wall -Werror)
+- [ ] Type signatures on all exports
+
+### Performance
+
+- [ ] Strictness annotations where needed
+- [ ] No space leaks (profiling done)
+- [ ] Lazy IO avoided
+
+### Testing
+
+- [ ] Property tests with QuickCheck
+- [ ] Unit tests with HSpec
+- [ ] Coverage > 70%
+
+---
+
+_DOMYH Awesome Code • Haskell GHC 9.8+_

package/.agent/skills/languages/haskell/data/core.yaml

@@ -0,0 +1,347 @@
+# =============================================================================
+# Haskell Core Patterns (Feb 2026)
+# Version: GHC 9.8/9.10
+# =============================================================================
+
+metadata:
+  skill: haskell
+  domain: core
+  version: "9.10"
+  updated: "2026-02-05"
+  patterns_count: 5
+
+patterns:
+  - id: hs001
+    name: Type Classes
+    category: types
+    version: "Haskell"
+    description: |
+      Polymorphism via type classes.
+      Custom instances, constraints.
+    text: class instance typeclass constraint deriving
+    example: |
+      -- ✅ Define a type class
+      class Printable a where
+        printValue :: a -> String
+        
+        -- Default implementation
+        printLine :: a -> String
+        printLine x = printValue x ++ "\n"
+
+      -- ✅ Instances
+      instance Printable Int where
+        printValue = show
+
+      instance Printable Bool where
+        printValue True  = "yes"
+        printValue False = "no"
+
+      instance Printable a => Printable [a] where
+        printValue xs = "[" ++ intercalate ", " (map printValue xs) ++ "]"
+
+      -- ✅ Multiple constraints
+      combine :: (Show a, Ord a) => [a] -> String
+      combine = show . sort
+
+      -- ✅ Data type with deriving
+      data User = User
+        { userId   :: Int
+        , userName :: String
+        , userAge  :: Int
+        } deriving (Show, Eq, Ord, Generic)
+
+      -- Generic JSON
+      instance ToJSON User
+      instance FromJSON User
+
+      -- ✅ Newtype with deriving via
+      newtype UserId = UserId Int
+        deriving (Show, Eq, Ord)
+        deriving (ToJSON, FromJSON) via Int
+
+      -- ✅ Associated types
+      class Container c where
+        type Elem c
+        empty :: c
+        insert :: Elem c -> c -> c
+        member :: Elem c -> c -> Bool
+
+      instance Container [a] where
+        type Elem [a] = a
+        empty = []
+        insert = (:)
+        member = elem
+    severity: HIGH
+    docs_url: https://wiki.haskell.org/Type_class
+
+  - id: hs002
+    name: Monads
+    category: types
+    version: "Haskell"
+    description: |
+      Monadic composition.
+      do notation, common monads.
+    text: monad bind do maybe either io return
+    example: |
+      -- ✅ Maybe monad for nullable values
+      safeDivide :: Int -> Int -> Maybe Int
+      safeDivide _ 0 = Nothing
+      safeDivide x y = Just (x `div` y)
+
+      -- Chain with do notation
+      calculate :: Int -> Int -> Int -> Maybe Int
+      calculate a b c = do
+        x <- safeDivide a b
+        y <- safeDivide x c
+        return (x + y)
+
+      -- ✅ Either monad for errors
+      data AppError = NotFound | InvalidInput String | DatabaseError
+        deriving Show
+
+      getUser :: Int -> Either AppError User
+      getUser id
+        | id <= 0   = Left (InvalidInput "Invalid ID")
+        | id > 1000 = Left NotFound
+        | otherwise = Right (User id "John" 30)
+
+      processUser :: Int -> Either AppError String
+      processUser id = do
+        user <- getUser id
+        validated <- validateUser user
+        return (userName validated)
+
+      -- ✅ IO monad
+      main :: IO ()
+      main = do
+        putStrLn "Enter your name:"
+        name <- getLine
+        putStrLn $ "Hello, " ++ name ++ "!"
+
+      -- ✅ List monad for nondeterminism
+      pairs :: [(Int, Int)]
+      pairs = do
+        x <- [1, 2, 3]
+        y <- [4, 5, 6]
+        guard (x + y > 6)
+        return (x, y)
+      -- Result: [(1,6),(2,5),(2,6),(3,4),(3,5),(3,6)]
+
+      -- ✅ Reader monad for config
+      type Config = String
+      type App = Reader Config
+
+      getConfigValue :: App String
+      getConfigValue = ask
+
+      runApp :: Config -> App a -> a
+      runApp config app = runReader app config
+    severity: HIGH
+    docs_url: https://wiki.haskell.org/Monad
+
+  - id: hs003
+    name: Algebraic Data Types
+    category: types
+    version: "Haskell"
+    description: |
+      Sum and product types.
+      Pattern matching, records.
+    text: data type sum product pattern record
+    example: |
+      -- ✅ Sum type (tagged union)
+      data Shape
+        = Circle Double           -- radius
+        | Rectangle Double Double -- width, height
+        | Triangle Double Double Double -- sides
+        deriving (Show, Eq)
+
+      area :: Shape -> Double
+      area (Circle r) = pi * r * r
+      area (Rectangle w h) = w * h
+      area (Triangle a b c) =
+        let s = (a + b + c) / 2
+        in sqrt (s * (s-a) * (s-b) * (s-c))
+
+      -- ✅ Product type (record)
+      data Person = Person
+        { personName :: String
+        , personAge  :: Int
+        , personEmail :: Maybe String
+        } deriving (Show, Eq)
+
+      -- Record update
+      birthday :: Person -> Person
+      birthday p = p { personAge = personAge p + 1 }
+
+      -- ✅ Recursive types
+      data List a = Nil | Cons a (List a)
+        deriving (Show, Eq, Functor)
+
+      data Tree a
+        = Leaf a
+        | Node (Tree a) a (Tree a)
+        deriving (Show, Eq, Functor, Foldable, Traversable)
+
+      -- ✅ GADT (advanced)
+      {-# LANGUAGE GADTs #-}
+      data Expr a where
+        LitInt  :: Int -> Expr Int
+        LitBool :: Bool -> Expr Bool
+        Add     :: Expr Int -> Expr Int -> Expr Int
+        If      :: Expr Bool -> Expr a -> Expr a -> Expr a
+
+      eval :: Expr a -> a
+      eval (LitInt n)    = n
+      eval (LitBool b)   = b
+      eval (Add e1 e2)   = eval e1 + eval e2
+      eval (If cond t f) = if eval cond then eval t else eval f
+
+      -- ✅ Phantom types
+      data Validated
+      data Unvalidated
+
+      newtype Email (status :: *) = Email String
+
+      validateEmail :: Email Unvalidated -> Maybe (Email Validated)
+      validateEmail (Email s)
+        | '@' `elem` s = Just (Email s)
+        | otherwise    = Nothing
+    severity: HIGH
+    docs_url: https://wiki.haskell.org/Algebraic_data_type
+
+  - id: hs004
+    name: Functors and Applicatives
+    category: types
+    version: "Haskell"
+    description: |
+      Higher-kinded abstractions.
+      Functor, Applicative, Traversable.
+    text: functor fmap applicative traverse pure
+    example: |
+      -- ✅ Functor - apply function inside context
+      -- fmap :: Functor f => (a -> b) -> f a -> f b
+
+      doubled :: Maybe Int
+      doubled = fmap (*2) (Just 5)  -- Just 10
+
+      -- Infix <$>
+      result = (*2) <$> Just 5  -- Just 10
+
+      -- ✅ Custom Functor
+      data Box a = Box a deriving Show
+
+      instance Functor Box where
+        fmap f (Box a) = Box (f a)
+
+      -- ✅ Applicative - function in context applied to value in context
+      -- (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+
+      add :: Int -> Int -> Int
+      add = (+)
+
+      result :: Maybe Int
+      result = add <$> Just 3 <*> Just 5  -- Just 8
+
+      -- Using liftA2
+      result' = liftA2 add (Just 3) (Just 5)
+
+      -- ✅ Validate multiple fields
+      data User = User String Int deriving Show
+
+      mkUser :: Maybe String -> Maybe Int -> Maybe User
+      mkUser name age = User <$> name <*> age
+
+      -- ✅ Traversable - sequence effects
+      -- traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+
+      -- Parse all strings, fail if any fails
+      parseAll :: [String] -> Maybe [Int]
+      parseAll = traverse readMaybe
+
+      -- Fetch all users in parallel
+      fetchUsers :: [Int] -> IO [User]
+      fetchUsers ids = traverse fetchUser ids
+
+      -- ✅ sequence - swap container and effect
+      -- sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+
+      maybeList :: [Maybe Int] -> Maybe [Int]
+      maybeList = sequence
+
+      ioList :: [IO a] -> IO [a]
+      ioList = sequence
+    severity: MEDIUM
+    docs_url: https://wiki.haskell.org/Functor
+
+  - id: hs005
+    name: Servant API
+    category: web
+    version: "Servant"
+    description: |
+      Type-safe REST APIs.
+      API types, handlers, clients.
+    text: servant api handler server client type
+    example: |
+      {-# LANGUAGE DataKinds #-}
+      {-# LANGUAGE TypeOperators #-}
+
+      import Servant
+
+      -- ✅ Define API as types
+      type UserAPI =
+             "users" :> Get '[JSON] [User]
+        :<|> "users" :> Capture "id" Int :> Get '[JSON] User
+        :<|> "users" :> ReqBody '[JSON] CreateUser :> Post '[JSON] User
+        :<|> "users" :> Capture "id" Int :> Delete '[JSON] NoContent
+
+      -- ✅ Data types
+      data User = User
+        { userId   :: Int
+        , userName :: String
+        , userEmail :: String
+        } deriving (Generic, Show)
+
+      instance ToJSON User
+      instance FromJSON User
+
+      data CreateUser = CreateUser
+        { newName  :: String
+        , newEmail :: String
+        } deriving (Generic)
+
+      instance FromJSON CreateUser
+
+      -- ✅ Handlers
+      server :: Server UserAPI
+      server = getUsers :<|> getUser :<|> createUser :<|> deleteUser
+        where
+          getUsers :: Handler [User]
+          getUsers = return [User 1 "John" "john@email.com"]
+          
+          getUser :: Int -> Handler User
+          getUser id = do
+            case lookup id userDb of
+              Just user -> return user
+              Nothing   -> throwError err404
+          
+          createUser :: CreateUser -> Handler User
+          createUser req = do
+            let user = User 2 (newName req) (newEmail req)
+            return user
+          
+          deleteUser :: Int -> Handler NoContent
+          deleteUser _ = return NoContent
+
+      -- ✅ Run server
+      main :: IO ()
+      main = run 8080 $ serve (Proxy :: Proxy UserAPI) server
+
+      -- ✅ Generate client
+      getUsers' :: ClientM [User]
+      getUser' :: Int -> ClientM User
+      createUser' :: CreateUser -> ClientM User
+      deleteUser' :: Int -> ClientM NoContent
+
+      (getUsers' :<|> getUser' :<|> createUser' :<|> deleteUser') = client (Proxy :: Proxy UserAPI)
+    severity: MEDIUM
+    docs_url: https://docs.servant.dev/