[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7CK0C8SNV1YN4CKFPQ3PRTC":3,"skill-same:01M7CK0C8SNV1YN4CKFPQ3PRTC":50},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":27,"commitSha":28,"skillDirectory":29,"forksCount":30,"repositoryHtmlUrl":31,"repositoryHomepageUrl":32,"ownerHtmlUrl":33,"ownerBlogUrl":6,"ownerDescription":34,"updatedAt":35,"install":36,"resources":49},"01M7CK0C8SNV1YN4CKFPQ3PRTC","fp-ts-pragmatic",null,"A practical, jargon-free guide to fp-ts functional programming - the 80\u002F20 approach that gets results without the academic overhead. Use when writing TypeScript with fp-ts library.","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fskills\u002Ffp-ts-pragmatic\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: fp-ts-pragmatic\ndescription: \"A practical, jargon-free guide to fp-ts functional programming - the 80\u002F20 approach that gets results without the academic overhead. Use when writing TypeScript with fp-ts library.\"\nrisk: safe\nsource: \"https:\u002F\u002Fgithub.com\u002Fwhatiskadudoing\u002Ffp-ts-skills\"\ndate_added: \"2026-02-27\"\n---\n\n# Pragmatic Functional Programming\n\n**Read this first.** This guide cuts through the academic jargon and shows you what actually matters. No category theory. No abstract nonsense. Just patterns that make your code better.\n\n## When to Use This Skill\n\n- When starting with fp-ts and need practical guidance\n- When writing TypeScript code that handles nullable values, errors, or async operations\n- When you want cleaner, more maintainable functional code without the academic overhead\n- When refactoring imperative code to functional style\n\n## The Golden Rule\n\n> **If functional programming makes your code harder to read, don't use it.**\n\nFP is a tool, not a religion. Use it when it helps. Skip it when it doesn't.\n\n---\n\n## The 80\u002F20 of FP\n\nThese five patterns give you most of the benefits. Master these before exploring anything else.\n\n### 1. Pipe: Chain Operations Clearly\n\nInstead of nesting function calls or creating intermediate variables, chain operations in reading order.\n\n```typescript\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Hard to read (inside-out)\nconst result = format(validate(parse(input)))\n\n\u002F\u002F Before: Too many variables\nconst parsed = parse(input)\nconst validated = validate(parsed)\nconst result = format(validated)\n\n\u002F\u002F After: Clear, linear flow\nconst result = pipe(\n  input,\n  parse,\n  validate,\n  format\n)\n```\n\n**When to use pipe:**\n- 3+ transformations on the same data\n- You find yourself naming throwaway variables\n- Logic reads better top-to-bottom\n\n**When to skip pipe:**\n- Just 1-2 operations (direct call is fine)\n- The operations don't naturally chain\n\n### 2. Option: Handle Missing Values Without null Checks\n\nStop writing `if (x !== null && x !== undefined)` everywhere.\n\n```typescript\nimport * as O from 'fp-ts\u002FOption'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Defensive null checking\nfunction getUserCity(user: User | null): string {\n  if (user === null) return 'Unknown'\n  if (user.address === null) return 'Unknown'\n  if (user.address.city === null) return 'Unknown'\n  return user.address.city\n}\n\n\u002F\u002F After: Chain through potential missing values\nconst getUserCity = (user: User | null): string =>\n  pipe(\n    O.fromNullable(user),\n    O.flatMap(u => O.fromNullable(u.address)),\n    O.flatMap(a => O.fromNullable(a.city)),\n    O.getOrElse(() => 'Unknown')\n  )\n```\n\n**Plain language translation:**\n- `O.fromNullable(x)` = \"wrap this value, treating null\u002Fundefined as 'nothing'\"\n- `O.flatMap(fn)` = \"if we have something, apply this function\"\n- `O.getOrElse(() => default)` = \"unwrap, or use this default if nothing\"\n\n### 3. Either: Make Errors Explicit\n\nStop throwing exceptions for expected failures. Return errors as values.\n\n```typescript\nimport * as E from 'fp-ts\u002FEither'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Hidden failure mode\nfunction parseAge(input: string): number {\n  const age = parseInt(input, 10)\n  if (isNaN(age)) throw new Error('Invalid age')\n  if (age \u003C 0) throw new Error('Age cannot be negative')\n  return age\n}\n\n\u002F\u002F After: Errors are visible in the type\nfunction parseAge(input: string): E.Either\u003Cstring, number> {\n  const age = parseInt(input, 10)\n  if (isNaN(age)) return E.left('Invalid age')\n  if (age \u003C 0) return E.left('Age cannot be negative')\n  return E.right(age)\n}\n\n\u002F\u002F Using it\nconst result = parseAge(userInput)\nif (E.isRight(result)) {\n  console.log(`Age is ${result.right}`)\n} else {\n  console.log(`Error: ${result.left}`)\n}\n```\n\n**Plain language translation:**\n- `E.right(value)` = \"success with this value\"\n- `E.left(error)` = \"failure with this error\"\n- `E.isRight(x)` = \"did it succeed?\"\n\n### 4. Map: Transform Without Unpacking\n\nTransform values inside containers without extracting them first.\n\n```typescript\nimport * as O from 'fp-ts\u002FOption'\nimport * as E from 'fp-ts\u002FEither'\nimport * as A from 'fp-ts\u002FArray'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Transform inside Option\nconst maybeUser: O.Option\u003CUser> = O.some({ name: 'Alice', age: 30 })\nconst maybeName: O.Option\u003Cstring> = pipe(\n  maybeUser,\n  O.map(user => user.name)\n)\n\n\u002F\u002F Transform inside Either\nconst result: E.Either\u003CError, number> = E.right(5)\nconst doubled: E.Either\u003CError, number> = pipe(\n  result,\n  E.map(n => n * 2)\n)\n\n\u002F\u002F Transform arrays (same concept!)\nconst numbers = [1, 2, 3]\nconst doubled = pipe(\n  numbers,\n  A.map(n => n * 2)\n)\n```\n\n### 5. FlatMap: Chain Operations That Might Fail\n\nWhen each step might fail, chain them together.\n\n```typescript\nimport * as E from 'fp-ts\u002FEither'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\nconst parseJSON = (s: string): E.Either\u003Cstring, unknown> =>\n  E.tryCatch(() => JSON.parse(s), () => 'Invalid JSON')\n\nconst extractEmail = (data: unknown): E.Either\u003Cstring, string> => {\n  if (typeof data === 'object' && data !== null && 'email' in data) {\n    return E.right((data as { email: string }).email)\n  }\n  return E.left('No email field')\n}\n\nconst validateEmail = (email: string): E.Either\u003Cstring, string> =>\n  email.includes('@') ? E.right(email) : E.left('Invalid email format')\n\n\u002F\u002F Chain all steps - if any fails, the whole thing fails\nconst getValidEmail = (input: string): E.Either\u003Cstring, string> =>\n  pipe(\n    parseJSON(input),\n    E.flatMap(extractEmail),\n    E.flatMap(validateEmail)\n  )\n\n\u002F\u002F Success path: Right('user@example.com')\n\u002F\u002F Any failure: Left('specific error message')\n```\n\n**Plain language:** `flatMap` means \"if this succeeded, try the next thing\"\n\n---\n\n## When NOT to Use FP\n\nFunctional programming is not always the answer. Here's when to keep it simple.\n\n### Simple Null Checks\n\n```typescript\n\u002F\u002F Just use optional chaining - it's built into the language\nconst city = user?.address?.city ?? 'Unknown'\n\n\u002F\u002F DON'T overcomplicate it\nconst city = pipe(\n  O.fromNullable(user),\n  O.flatMap(u => O.fromNullable(u.address)),\n  O.flatMap(a => O.fromNullable(a.city)),\n  O.getOrElse(() => 'Unknown')\n)\n```\n\n### Simple Loops\n\n```typescript\n\u002F\u002F A for loop is fine when you need early exit or complex logic\nfunction findFirst(items: Item[], predicate: (i: Item) => boolean): Item | null {\n  for (const item of items) {\n    if (predicate(item)) return item\n  }\n  return null\n}\n\n\u002F\u002F DON'T force FP when it doesn't help\nconst result = pipe(\n  items,\n  A.findFirst(predicate),\n  O.toNullable\n)\n```\n\n### Performance-Critical Code\n\n```typescript\n\u002F\u002F For hot paths, imperative is faster (no intermediate arrays)\nfunction sumLarge(numbers: number[]): number {\n  let sum = 0\n  for (let i = 0; i \u003C numbers.length; i++) {\n    sum += numbers[i]\n  }\n  return sum\n}\n\n\u002F\u002F fp-ts creates intermediate structures\nconst sum = pipe(numbers, A.reduce(0, (acc, n) => acc + n))\n```\n\n### When Your Team Doesn't Know FP\n\nIf you're the only one who can read the code, it's not good code.\n\n```typescript\n\u002F\u002F If your team knows this pattern\nasync function getUser(id: string): Promise\u003CUser | null> {\n  try {\n    const response = await fetch(`\u002Fapi\u002Fusers\u002F${id}`)\n    if (!response.ok) return null\n    return await response.json()\n  } catch {\n    return null\n  }\n}\n\n\u002F\u002F Don't force this on them\nconst getUser = (id: string): TE.TaskEither\u003CError, User> =>\n  pipe(\n    TE.tryCatch(() => fetch(`\u002Fapi\u002Fusers\u002F${id}`), E.toError),\n    TE.flatMap(r => r.ok ? TE.right(r) : TE.left(new Error('Not found'))),\n    TE.flatMap(r => TE.tryCatch(() => r.json(), E.toError))\n  )\n```\n\n---\n\n## Quick Wins: Easy Changes That Improve Code Today\n\n### 1. Replace Nested Ternaries with pipe + fold\n\n```typescript\n\u002F\u002F Before: Nested ternary nightmare\nconst message = user === null\n  ? 'No user'\n  : user.isAdmin\n    ? `Admin: ${user.name}`\n    : `User: ${user.name}`\n\n\u002F\u002F After: Clear case handling\nconst message = pipe(\n  O.fromNullable(user),\n  O.fold(\n    () => 'No user',\n    (u) => u.isAdmin ? `Admin: ${u.name}` : `User: ${u.name}`\n  )\n)\n```\n\n### 2. Replace try-catch with tryCatch\n\n```typescript\n\u002F\u002F Before: try-catch everywhere\nlet config\ntry {\n  config = JSON.parse(rawConfig)\n} catch {\n  config = defaultConfig\n}\n\n\u002F\u002F After: One-liner\nconst config = pipe(\n  E.tryCatch(() => JSON.parse(rawConfig), () => 'parse error'),\n  E.getOrElse(() => defaultConfig)\n)\n```\n\n### 3. Replace undefined Returns with Option\n\n```typescript\n\u002F\u002F Before: Caller might forget to check\nfunction findUser(id: string): User | undefined {\n  return users.find(u => u.id === id)\n}\n\n\u002F\u002F After: Type forces caller to handle missing case\nfunction findUser(id: string): O.Option\u003CUser> {\n  return O.fromNullable(users.find(u => u.id === id))\n}\n```\n\n### 4. Replace Error Strings with Typed Errors\n\n```typescript\n\u002F\u002F Before: Just strings\nfunction validate(data: unknown): E.Either\u003Cstring, User> {\n  \u002F\u002F ...\n  return E.left('validation failed')\n}\n\n\u002F\u002F After: Structured errors\ntype ValidationError = {\n  field: string\n  message: string\n}\n\nfunction validate(data: unknown): E.Either\u003CValidationError, User> {\n  \u002F\u002F ...\n  return E.left({ field: 'email', message: 'Invalid format' })\n}\n```\n\n### 5. Use const Assertions for Error Types\n\n```typescript\n\u002F\u002F Create specific error types without classes\nconst NotFound = (id: string) => ({ _tag: 'NotFound' as const, id })\nconst Unauthorized = { _tag: 'Unauthorized' as const }\nconst ValidationFailed = (errors: string[]) =>\n  ({ _tag: 'ValidationFailed' as const, errors })\n\ntype AppError =\n  | ReturnType\u003Ctypeof NotFound>\n  | typeof Unauthorized\n  | ReturnType\u003Ctypeof ValidationFailed>\n\n\u002F\u002F Now you can pattern match\nconst handleError = (error: AppError): string => {\n  switch (error._tag) {\n    case 'NotFound': return `Item ${error.id} not found`\n    case 'Unauthorized': return 'Please log in'\n    case 'ValidationFailed': return error.errors.join(', ')\n  }\n}\n```\n\n---\n\n## Common Refactors: Before and After\n\n### Callback Hell to Pipe\n\n```typescript\n\u002F\u002F Before\nfetchUser(id, (user) => {\n  if (!user) return handleNoUser()\n  fetchPosts(user.id, (posts) => {\n    if (!posts) return handleNoPosts()\n    fetchComments(posts[0].id, (comments) => {\n      render(user, posts, comments)\n    })\n  })\n})\n\n\u002F\u002F After (with TaskEither for async)\nimport * as TE from 'fp-ts\u002FTaskEither'\n\nconst loadData = (id: string) =>\n  pipe(\n    fetchUser(id),\n    TE.flatMap(user => pipe(\n      fetchPosts(user.id),\n      TE.map(posts => ({ user, posts }))\n    )),\n    TE.flatMap(({ user, posts }) => pipe(\n      fetchComments(posts[0].id),\n      TE.map(comments => ({ user, posts, comments }))\n    ))\n  )\n\n\u002F\u002F Execute\nconst result = await loadData('123')()\npipe(\n  result,\n  E.fold(handleError, ({ user, posts, comments }) => render(user, posts, comments))\n)\n```\n\n### Multiple null Checks to Option Chain\n\n```typescript\n\u002F\u002F Before\nfunction getManagerEmail(employee: Employee): string | null {\n  if (!employee.department) return null\n  if (!employee.department.manager) return null\n  if (!employee.department.manager.email) return null\n  return employee.department.manager.email\n}\n\n\u002F\u002F After\nconst getManagerEmail = (employee: Employee): O.Option\u003Cstring> =>\n  pipe(\n    O.fromNullable(employee.department),\n    O.flatMap(d => O.fromNullable(d.manager)),\n    O.flatMap(m => O.fromNullable(m.email))\n  )\n\n\u002F\u002F Use it\npipe(\n  getManagerEmail(employee),\n  O.fold(\n    () => sendToDefault(),\n    (email) => sendTo(email)\n  )\n)\n```\n\n### Validation with Multiple Checks\n\n```typescript\n\u002F\u002F Before: Throws on first error\nfunction validateUser(data: unknown): User {\n  if (!data || typeof data !== 'object') throw new Error('Must be object')\n  const obj = data as Record\u003Cstring, unknown>\n  if (typeof obj.email !== 'string') throw new Error('Email required')\n  if (!obj.email.includes('@')) throw new Error('Invalid email')\n  if (typeof obj.age !== 'number') throw new Error('Age required')\n  if (obj.age \u003C 0) throw new Error('Age must be positive')\n  return obj as User\n}\n\n\u002F\u002F After: Returns first error, type-safe\nconst validateUser = (data: unknown): E.Either\u003Cstring, User> =>\n  pipe(\n    E.Do,\n    E.bind('obj', () =>\n      typeof data === 'object' && data !== null\n        ? E.right(data as Record\u003Cstring, unknown>)\n        : E.left('Must be object')\n    ),\n    E.bind('email', ({ obj }) =>\n      typeof obj.email === 'string' && obj.email.includes('@')\n        ? E.right(obj.email)\n        : E.left('Valid email required')\n    ),\n    E.bind('age', ({ obj }) =>\n      typeof obj.age === 'number' && obj.age >= 0\n        ? E.right(obj.age)\n        : E.left('Valid age required')\n    ),\n    E.map(({ email, age }) => ({ email, age }))\n  )\n```\n\n### Promise Chain to TaskEither\n\n```typescript\n\u002F\u002F Before\nasync function processOrder(orderId: string): Promise\u003CReceipt> {\n  const order = await fetchOrder(orderId)\n  if (!order) throw new Error('Order not found')\n\n  const validated = await validateOrder(order)\n  if (!validated.success) throw new Error(validated.error)\n\n  const payment = await processPayment(validated.order)\n  if (!payment.success) throw new Error('Payment failed')\n\n  return generateReceipt(payment)\n}\n\n\u002F\u002F After\nconst processOrder = (orderId: string): TE.TaskEither\u003Cstring, Receipt> =>\n  pipe(\n    fetchOrderTE(orderId),\n    TE.flatMap(order =>\n      order ? TE.right(order) : TE.left('Order not found')\n    ),\n    TE.flatMap(validateOrderTE),\n    TE.flatMap(processPaymentTE),\n    TE.map(generateReceipt)\n  )\n```\n\n---\n\n## The Readability Rule\n\nBefore using any FP pattern, ask: **\"Would a junior developer understand this?\"**\n\n### Too Clever (Avoid)\n\n```typescript\nconst result = pipe(\n  data,\n  A.filter(flow(prop('status'), equals('active'))),\n  A.map(flow(prop('value'), multiply(2))),\n  A.reduce(monoid.concat, monoid.empty),\n  O.fromPredicate(gt(threshold))\n)\n```\n\n### Just Right (Prefer)\n\n```typescript\nconst activeItems = data.filter(item => item.status === 'active')\nconst doubledValues = activeItems.map(item => item.value * 2)\nconst total = doubledValues.reduce((sum, val) => sum + val, 0)\nconst result = total > threshold ? O.some(total) : O.none\n```\n\n### The Middle Ground (Often Best)\n\n```typescript\nconst result = pipe(\n  data,\n  A.filter(item => item.status === 'active'),\n  A.map(item => item.value * 2),\n  A.reduce(0, (sum, val) => sum + val),\n  total => total > threshold ? O.some(total) : O.none\n)\n```\n\n---\n\n## Cheat Sheet\n\n| What you want | Plain language | fp-ts |\n|--------------|----------------|-------|\n| Handle null\u002Fundefined | \"Wrap this nullable\" | `O.fromNullable(x)` |\n| Default for missing | \"Use this if nothing\" | `O.getOrElse(() => default)` |\n| Transform if present | \"If something, change it\" | `O.map(fn)` |\n| Chain nullable operations | \"If something, try this\" | `O.flatMap(fn)` |\n| Return success | \"Worked, here's the value\" | `E.right(value)` |\n| Return failure | \"Failed, here's why\" | `E.left(error)` |\n| Wrap throwing function | \"Try this, catch errors\" | `E.tryCatch(fn, onError)` |\n| Handle both cases | \"Do this for error, that for success\" | `E.fold(onLeft, onRight)` |\n| Chain operations | \"Then do this, then that\" | `pipe(x, fn1, fn2, fn3)` |\n\n---\n\n## When to Level Up\n\nOnce comfortable with these patterns, explore:\n\n1. **TaskEither** - Async operations that can fail (replaces Promise + try\u002Fcatch)\n2. **Validation** - Collect ALL errors instead of stopping at first\n3. **Reader** - Dependency injection without classes\n4. **Do notation** - Cleaner syntax for multiple bindings\n\nBut don't rush. The basics here will handle 80% of real-world scenarios. Get comfortable with these before adding more tools to your belt.\n\n---\n\n## Summary\n\n1. **Use pipe** for 3+ operations\n2. **Use Option** for nullable chains\n3. **Use Either** for operations that can fail\n4. **Use map** to transform wrapped values\n5. **Use flatMap** to chain operations that might fail\n6. **Skip FP** when it hurts readability\n7. **Keep it simple** - if your team can't read it, it's not good code\n\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\n","# Pragmatic Functional Programming\n\n**Read this first.** This guide cuts through the academic jargon and shows you what actually matters. No category theory. No abstract nonsense. Just patterns that make your code better.\n\n## When to Use This Skill\n\n- When starting with fp-ts and need practical guidance\n- When writing TypeScript code that handles nullable values, errors, or async operations\n- When you want cleaner, more maintainable functional code without the academic overhead\n- When refactoring imperative code to functional style\n\n## The Golden Rule\n\n> **If functional programming makes your code harder to read, don't use it.**\n\nFP is a tool, not a religion. Use it when it helps. Skip it when it doesn't.\n\n---\n\n## The 80\u002F20 of FP\n\nThese five patterns give you most of the benefits. Master these before exploring anything else.\n\n### 1. Pipe: Chain Operations Clearly\n\nInstead of nesting function calls or creating intermediate variables, chain operations in reading order.\n\n```typescript\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Hard to read (inside-out)\nconst result = format(validate(parse(input)))\n\n\u002F\u002F Before: Too many variables\nconst parsed = parse(input)\nconst validated = validate(parsed)\nconst result = format(validated)\n\n\u002F\u002F After: Clear, linear flow\nconst result = pipe(\n  input,\n  parse,\n  validate,\n  format\n)\n```\n\n**When to use pipe:**\n- 3+ transformations on the same data\n- You find yourself naming throwaway variables\n- Logic reads better top-to-bottom\n\n**When to skip pipe:**\n- Just 1-2 operations (direct call is fine)\n- The operations don't naturally chain\n\n### 2. Option: Handle Missing Values Without null Checks\n\nStop writing `if (x !== null && x !== undefined)` everywhere.\n\n```typescript\nimport * as O from 'fp-ts\u002FOption'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Defensive null checking\nfunction getUserCity(user: User | null): string {\n  if (user === null) return 'Unknown'\n  if (user.address === null) return 'Unknown'\n  if (user.address.city === null) return 'Unknown'\n  return user.address.city\n}\n\n\u002F\u002F After: Chain through potential missing values\nconst getUserCity = (user: User | null): string =>\n  pipe(\n    O.fromNullable(user),\n    O.flatMap(u => O.fromNullable(u.address)),\n    O.flatMap(a => O.fromNullable(a.city)),\n    O.getOrElse(() => 'Unknown')\n  )\n```\n\n**Plain language translation:**\n- `O.fromNullable(x)` = \"wrap this value, treating null\u002Fundefined as 'nothing'\"\n- `O.flatMap(fn)` = \"if we have something, apply this function\"\n- `O.getOrElse(() => default)` = \"unwrap, or use this default if nothing\"\n\n### 3. Either: Make Errors Explicit\n\nStop throwing exceptions for expected failures. Return errors as values.\n\n```typescript\nimport * as E from 'fp-ts\u002FEither'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Before: Hidden failure mode\nfunction parseAge(input: string): number {\n  const age = parseInt(input, 10)\n  if (isNaN(age)) throw new Error('Invalid age')\n  if (age \u003C 0) throw new Error('Age cannot be negative')\n  return age\n}\n\n\u002F\u002F After: Errors are visible in the type\nfunction parseAge(input: string): E.Either\u003Cstring, number> {\n  const age = parseInt(input, 10)\n  if (isNaN(age)) return E.left('Invalid age')\n  if (age \u003C 0) return E.left('Age cannot be negative')\n  return E.right(age)\n}\n\n\u002F\u002F Using it\nconst result = parseAge(userInput)\nif (E.isRight(result)) {\n  console.log(`Age is ${result.right}`)\n} else {\n  console.log(`Error: ${result.left}`)\n}\n```\n\n**Plain language translation:**\n- `E.right(value)` = \"success with this value\"\n- `E.left(error)` = \"failure with this error\"\n- `E.isRight(x)` = \"did it succeed?\"\n\n### 4. Map: Transform Without Unpacking\n\nTransform values inside containers without extracting them first.\n\n```typescript\nimport * as O from 'fp-ts\u002FOption'\nimport * as E from 'fp-ts\u002FEither'\nimport * as A from 'fp-ts\u002FArray'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\n\u002F\u002F Transform inside Option\nconst maybeUser: O.Option\u003CUser> = O.some({ name: 'Alice', age: 30 })\nconst maybeName: O.Option\u003Cstring> = pipe(\n  maybeUser,\n  O.map(user => user.name)\n)\n\n\u002F\u002F Transform inside Either\nconst result: E.Either\u003CError, number> = E.right(5)\nconst doubled: E.Either\u003CError, number> = pipe(\n  result,\n  E.map(n => n * 2)\n)\n\n\u002F\u002F Transform arrays (same concept!)\nconst numbers = [1, 2, 3]\nconst doubled = pipe(\n  numbers,\n  A.map(n => n * 2)\n)\n```\n\n### 5. FlatMap: Chain Operations That Might Fail\n\nWhen each step might fail, chain them together.\n\n```typescript\nimport * as E from 'fp-ts\u002FEither'\nimport { pipe } from 'fp-ts\u002Ffunction'\n\nconst parseJSON = (s: string): E.Either\u003Cstring, unknown> =>\n  E.tryCatch(() => JSON.parse(s), () => 'Invalid JSON')\n\nconst extractEmail = (data: unknown): E.Either\u003Cstring, string> => {\n  if (typeof data === 'object' && data !== null && 'email' in data) {\n    return E.right((data as { email: string }).email)\n  }\n  return E.left('No email field')\n}\n\nconst validateEmail = (email: string): E.Either\u003Cstring, string> =>\n  email.includes('@') ? E.right(email) : E.left('Invalid email format')\n\n\u002F\u002F Chain all steps - if any fails, the whole thing fails\nconst getValidEmail = (input: string): E.Either\u003Cstring, string> =>\n  pipe(\n    parseJSON(input),\n    E.flatMap(extractEmail),\n    E.flatMap(validateEmail)\n  )\n\n\u002F\u002F Success path: Right('user@example.com')\n\u002F\u002F Any failure: Left('specific error message')\n```\n\n**Plain language:** `flatMap` means \"if this succeeded, try the next thing\"\n\n---\n\n## When NOT to Use FP\n\nFunctional programming is not always the answer. Here's when to keep it simple.\n\n### Simple Null Checks\n\n```typescript\n\u002F\u002F Just use optional chaining - it's built into the language\nconst city = user?.address?.city ?? 'Unknown'\n\n\u002F\u002F DON'T overcomplicate it\nconst city = pipe(\n  O.fromNullable(user),\n  O.flatMap(u => O.fromNullable(u.address)),\n  O.flatMap(a => O.fromNullable(a.city)),\n  O.getOrElse(() => 'Unknown')\n)\n```\n\n### Simple Loops\n\n```typescript\n\u002F\u002F A for loop is fine when you need early exit or complex logic\nfunction findFirst(items: Item[], predicate: (i: Item) => boolean): Item | null {\n  for (const item of items) {\n    if (predicate(item)) return item\n  }\n  return null\n}\n\n\u002F\u002F DON'T force FP when it doesn't help\nconst result = pipe(\n  items,\n  A.findFirst(predicate),\n  O.toNullable\n)\n```\n\n### Performance-Critical Code\n\n```typescript\n\u002F\u002F For hot paths, imperative is faster (no intermediate arrays)\nfunction sumLarge(numbers: number[]): number {\n  let sum = 0\n  for (let i = 0; i \u003C numbers.length; i++) {\n    sum += numbers[i]\n  }\n  return sum\n}\n\n\u002F\u002F fp-ts creates intermediate structures\nconst sum = pipe(numbers, A.reduce(0, (acc, n) => acc + n))\n```\n\n### When Your Team Doesn't Know FP\n\nIf you're the only one who can read the code, it's not good code.\n\n```typescript\n\u002F\u002F If your team knows this pattern\nasync function getUser(id: string): Promise\u003CUser | null> {\n  try {\n    const response = await fetch(`\u002Fapi\u002Fusers\u002F${id}`)\n    if (!response.ok) return null\n    return await response.json()\n  } catch {\n    return null\n  }\n}\n\n\u002F\u002F Don't force this on them\nconst getUser = (id: string): TE.TaskEither\u003CError, User> =>\n  pipe(\n    TE.tryCatch(() => fetch(`\u002Fapi\u002Fusers\u002F${id}`), E.toError),\n    TE.flatMap(r => r.ok ? TE.right(r) : TE.left(new Error('Not found'))),\n    TE.flatMap(r => TE.tryCatch(() => r.json(), E.toError))\n  )\n```\n\n---\n\n## Quick Wins: Easy Changes That Improve Code Today\n\n### 1. Replace Nested Ternaries with pipe + fold\n\n```typescript\n\u002F\u002F Before: Nested ternary nightmare\nconst message = user === null\n  ? 'No user'\n  : user.isAdmin\n    ? `Admin: ${user.name}`\n    : `User: ${user.name}`\n\n\u002F\u002F After: Clear case handling\nconst message = pipe(\n  O.fromNullable(user),\n  O.fold(\n    () => 'No user',\n    (u) => u.isAdmin ? `Admin: ${u.name}` : `User: ${u.name}`\n  )\n)\n```\n\n### 2. Replace try-catch with tryCatch\n\n```typescript\n\u002F\u002F Before: try-catch everywhere\nlet config\ntry {\n  config = JSON.parse(rawConfig)\n} catch {\n  config = defaultConfig\n}\n\n\u002F\u002F After: One-liner\nconst config = pipe(\n  E.tryCatch(() => JSON.parse(rawConfig), () => 'parse error'),\n  E.getOrElse(() => defaultConfig)\n)\n```\n\n### 3. Replace undefined Returns with Option\n\n```typescript\n\u002F\u002F Before: Caller might forget to check\nfunction findUser(id: string): User | undefined {\n  return users.find(u => u.id === id)\n}\n\n\u002F\u002F After: Type forces caller to handle missing case\nfunction findUser(id: string): O.Option\u003CUser> {\n  return O.fromNullable(users.find(u => u.id === id))\n}\n```\n\n### 4. Replace Error Strings with Typed Errors\n\n```typescript\n\u002F\u002F Before: Just strings\nfunction validate(data: unknown): E.Either\u003Cstring, User> {\n  \u002F\u002F ...\n  return E.left('validation failed')\n}\n\n\u002F\u002F After: Structured errors\ntype ValidationError = {\n  field: string\n  message: string\n}\n\nfunction validate(data: unknown): E.Either\u003CValidationError, User> {\n  \u002F\u002F ...\n  return E.left({ field: 'email', message: 'Invalid format' })\n}\n```\n\n### 5. Use const Assertions for Error Types\n\n```typescript\n\u002F\u002F Create specific error types without classes\nconst NotFound = (id: string) => ({ _tag: 'NotFound' as const, id })\nconst Unauthorized = { _tag: 'Unauthorized' as const }\nconst ValidationFailed = (errors: string[]) =>\n  ({ _tag: 'ValidationFailed' as const, errors })\n\ntype AppError =\n  | ReturnType\u003Ctypeof NotFound>\n  | typeof Unauthorized\n  | ReturnType\u003Ctypeof ValidationFailed>\n\n\u002F\u002F Now you can pattern match\nconst handleError = (error: AppError): string => {\n  switch (error._tag) {\n    case 'NotFound': return `Item ${error.id} not found`\n    case 'Unauthorized': return 'Please log in'\n    case 'ValidationFailed': return error.errors.join(', ')\n  }\n}\n```\n\n---\n\n## Common Refactors: Before and After\n\n### Callback Hell to Pipe\n\n```typescript\n\u002F\u002F Before\nfetchUser(id, (user) => {\n  if (!user) return handleNoUser()\n  fetchPosts(user.id, (posts) => {\n    if (!posts) return handleNoPosts()\n    fetchComments(posts[0].id, (comments) => {\n      render(user, posts, comments)\n    })\n  })\n})\n\n\u002F\u002F After (with TaskEither for async)\nimport * as TE from 'fp-ts\u002FTaskEither'\n\nconst loadData = (id: string) =>\n  pipe(\n    fetchUser(id),\n    TE.flatMap(user => pipe(\n      fetchPosts(user.id),\n      TE.map(posts => ({ user, posts }))\n    )),\n    TE.flatMap(({ user, posts }) => pipe(\n      fetchComments(posts[0].id),\n      TE.map(comments => ({ user, posts, comments }))\n    ))\n  )\n\n\u002F\u002F Execute\nconst result = await loadData('123')()\npipe(\n  result,\n  E.fold(handleError, ({ user, posts, comments }) => render(user, posts, comments))\n)\n```\n\n### Multiple null Checks to Option Chain\n\n```typescript\n\u002F\u002F Before\nfunction getManagerEmail(employee: Employee): string | null {\n  if (!employee.department) return null\n  if (!employee.department.manager) return null\n  if (!employee.department.manager.email) return null\n  return employee.department.manager.email\n}\n\n\u002F\u002F After\nconst getManagerEmail = (employee: Employee): O.Option\u003Cstring> =>\n  pipe(\n    O.fromNullable(employee.department),\n    O.flatMap(d => O.fromNullable(d.manager)),\n    O.flatMap(m => O.fromNullable(m.email))\n  )\n\n\u002F\u002F Use it\npipe(\n  getManagerEmail(employee),\n  O.fold(\n    () => sendToDefault(),\n    (email) => sendTo(email)\n  )\n)\n```\n\n### Validation with Multiple Checks\n\n```typescript\n\u002F\u002F Before: Throws on first error\nfunction validateUser(data: unknown): User {\n  if (!data || typeof data !== 'object') throw new Error('Must be object')\n  const obj = data as Record\u003Cstring, unknown>\n  if (typeof obj.email !== 'string') throw new Error('Email required')\n  if (!obj.email.includes('@')) throw new Error('Invalid email')\n  if (typeof obj.age !== 'number') throw new Error('Age required')\n  if (obj.age \u003C 0) throw new Error('Age must be positive')\n  return obj as User\n}\n\n\u002F\u002F After: Returns first error, type-safe\nconst validateUser = (data: unknown): E.Either\u003Cstring, User> =>\n  pipe(\n    E.Do,\n    E.bind('obj', () =>\n      typeof data === 'object' && data !== null\n        ? E.right(data as Record\u003Cstring, unknown>)\n        : E.left('Must be object')\n    ),\n    E.bind('email', ({ obj }) =>\n      typeof obj.email === 'string' && obj.email.includes('@')\n        ? E.right(obj.email)\n        : E.left('Valid email required')\n    ),\n    E.bind('age', ({ obj }) =>\n      typeof obj.age === 'number' && obj.age >= 0\n        ? E.right(obj.age)\n        : E.left('Valid age required')\n    ),\n    E.map(({ email, age }) => ({ email, age }))\n  )\n```\n\n### Promise Chain to TaskEither\n\n```typescript\n\u002F\u002F Before\nasync function processOrder(orderId: string): Promise\u003CReceipt> {\n  const order = await fetchOrder(orderId)\n  if (!order) throw new Error('Order not found')\n\n  const validated = await validateOrder(order)\n  if (!validated.success) throw new Error(validated.error)\n\n  const payment = await processPayment(validated.order)\n  if (!payment.success) throw new Error('Payment failed')\n\n  return generateReceipt(payment)\n}\n\n\u002F\u002F After\nconst processOrder = (orderId: string): TE.TaskEither\u003Cstring, Receipt> =>\n  pipe(\n    fetchOrderTE(orderId),\n    TE.flatMap(order =>\n      order ? TE.right(order) : TE.left('Order not found')\n    ),\n    TE.flatMap(validateOrderTE),\n    TE.flatMap(processPaymentTE),\n    TE.map(generateReceipt)\n  )\n```\n\n---\n\n## The Readability Rule\n\nBefore using any FP pattern, ask: **\"Would a junior developer understand this?\"**\n\n### Too Clever (Avoid)\n\n```typescript\nconst result = pipe(\n  data,\n  A.filter(flow(prop('status'), equals('active'))),\n  A.map(flow(prop('value'), multiply(2))),\n  A.reduce(monoid.concat, monoid.empty),\n  O.fromPredicate(gt(threshold))\n)\n```\n\n### Just Right (Prefer)\n\n```typescript\nconst activeItems = data.filter(item => item.status === 'active')\nconst doubledValues = activeItems.map(item => item.value * 2)\nconst total = doubledValues.reduce((sum, val) => sum + val, 0)\nconst result = total > threshold ? O.some(total) : O.none\n```\n\n### The Middle Ground (Often Best)\n\n```typescript\nconst result = pipe(\n  data,\n  A.filter(item => item.status === 'active'),\n  A.map(item => item.value * 2),\n  A.reduce(0, (sum, val) => sum + val),\n  total => total > threshold ? O.some(total) : O.none\n)\n```\n\n---\n\n## Cheat Sheet\n\n| What you want | Plain language | fp-ts |\n|--------------|----------------|-------|\n| Handle null\u002Fundefined | \"Wrap this nullable\" | `O.fromNullable(x)` |\n| Default for missing | \"Use this if nothing\" | `O.getOrElse(() => default)` |\n| Transform if present | \"If something, change it\" | `O.map(fn)` |\n| Chain nullable operations | \"If something, try this\" | `O.flatMap(fn)` |\n| Return success | \"Worked, here's the value\" | `E.right(value)` |\n| Return failure | \"Failed, here's why\" | `E.left(error)` |\n| Wrap throwing function | \"Try this, catch errors\" | `E.tryCatch(fn, onError)` |\n| Handle both cases | \"Do this for error, that for success\" | `E.fold(onLeft, onRight)` |\n| Chain operations | \"Then do this, then that\" | `pipe(x, fn1, fn2, fn3)` |\n\n---\n\n## When to Level Up\n\nOnce comfortable with these patterns, explore:\n\n1. **TaskEither** - Async operations that can fail (replaces Promise + try\u002Fcatch)\n2. **Validation** - Collect ALL errors instead of stopping at first\n3. **Reader** - Dependency injection without classes\n4. **Do notation** - Cleaner syntax for multiple bindings\n\nBut don't rush. The basics here will handle 80% of real-world scenarios. Get comfortable with these before adding more tools to your belt.\n\n---\n\n## Summary\n\n1. **Use pipe** for 3+ operations\n2. **Use Option** for nullable chains\n3. **Use Either** for operations that can fail\n4. **Use map** to transform wrapped values\n5. **Use flatMap** to chain operations that might fail\n6. **Skip FP** when it hurts readability\n7. **Keep it simple** - if your team can't read it, it's not good code\n\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\n",{"name":5,"risk":24,"source":25,"date_added":26,"description":7},"safe","https:\u002F\u002Fgithub.com\u002Fwhatiskadudoing\u002Ffp-ts-skills","2026-02-27","main","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fskills\u002Ffp-ts-pragmatic",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":37,"prompt":47,"zipAvailable":48},[38,41,44],{"tool":39,"command":40},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill fp-ts-pragmatic",{"tool":42,"command":43},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill fp-ts-pragmatic",{"tool":45,"command":46},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill fp-ts-pragmatic","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fskills\u002Ffp-ts-pragmatic\u002FSKILL.md",true,[],[51,58,65,72,79,86],{"skillNo":52,"name":53,"nameZh":6,"description":54,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":61,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]