mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
645 lines
26 KiB
HTML
645 lines
26 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>engineering-functional-programming</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/engineering-functional-programming.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/engineering-functional-programming">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/engineering-functional-programming.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>engineering-functional-programming</h1><p class="lede">Functional programming principles, immutability, pure functions, higher-order functions, and FP patterns</p><h1>Functional Programming Principles</h1>
|
|
<p><strong>Scope</strong>: Comprehensive guide to FP principles, immutability, pure functions, composition, and practical FP patterns <strong>Lines</strong>: ~350 <strong>Last Updated</strong>: 2025-10-27 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<hr>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Building data transformation pipelines</li><li>Implementing concurrent/parallel systems</li><li>Reducing bugs through immutability</li><li>Creating highly testable code</li><li>Working with React, Redux, or functional frameworks</li><li>Processing streams or collections</li><li>Implementing functional-first languages (Haskell, Elixir, F#)</li><li>Applying FP principles in multi-paradigm languages</li></ul>
|
|
<h2>Core Concepts</h2>
|
|
<h3>Concept 1: Pure Functions</h3>
|
|
<p><strong>Definition</strong>: Same inputs → Same outputs, no side effects</p>
|
|
<pre><code class="lang-python"># Pure function
|
|
def add(a: int, b: int) -> int:
|
|
return a + b
|
|
|
|
# Always returns same result for same inputs
|
|
assert add(2, 3) == 5
|
|
assert add(2, 3) == 5 # Deterministic!
|
|
|
|
# Impure function (side effects)
|
|
total = 0
|
|
def add_impure(a: int) -> int:
|
|
global total
|
|
total += a # Side effect: modifies external state
|
|
return total
|
|
|
|
# Returns different results!
|
|
assert add_impure(5) == 5
|
|
assert add_impure(5) == 10 # Not deterministic!</code></pre>
|
|
<p><strong>Benefits</strong>:</p>
|
|
<ul><li>Easy to test (no mocks needed)</li><li>Easy to reason about</li><li>Safe to parallelize</li><li>Cacheable (memoization)</li></ul>
|
|
<hr>
|
|
<h3>Concept 2: Immutability</h3>
|
|
<p><strong>Definition</strong>: Data never changes after creation</p>
|
|
<pre><code class="lang-typescript">// Mutable (bad)
|
|
const user = { name: "John", age: 30 };
|
|
user.age = 31; // Mutation!
|
|
|
|
// Immutable (good)
|
|
const user = { name: "John", age: 30 };
|
|
const olderUser = { ...user, age: 31 }; // New object
|
|
// user still has age 30</code></pre>
|
|
<p><strong>Why It Matters</strong>:</p>
|
|
<pre><code class="lang-python"># Mutable bug
|
|
def add_item(cart: List[str], item: str) -> List[str]:
|
|
cart.append(item) # Mutates input!
|
|
return cart
|
|
|
|
my_cart = ["apple"]
|
|
new_cart = add_item(my_cart, "banana")
|
|
print(my_cart) # ["apple", "banana"] - SURPRISE!
|
|
|
|
# Immutable fix
|
|
def add_item(cart: List[str], item: str) -> List[str]:
|
|
return cart + [item] # New list
|
|
|
|
my_cart = ["apple"]
|
|
new_cart = add_item(my_cart, "banana")
|
|
print(my_cart) # ["apple"] - unchanged!</code></pre>
|
|
<hr>
|
|
<h3>Concept 3: Higher-Order Functions</h3>
|
|
<p><strong>Definition</strong>: Functions that take functions as arguments or return functions</p>
|
|
<pre><code class="lang-javascript">// map: transform each element
|
|
const numbers = [1, 2, 3, 4];
|
|
const doubled = numbers.map(n => n * 2);
|
|
// [2, 4, 6, 8]
|
|
|
|
// filter: select elements
|
|
const evens = numbers.filter(n => n % 2 === 0);
|
|
// [2, 4]
|
|
|
|
// reduce: combine elements
|
|
const sum = numbers.reduce((acc, n) => acc + n, 0);
|
|
// 10</code></pre>
|
|
<p><strong>Function Composition</strong>:</p>
|
|
<pre><code class="lang-python">def compose(f, g):
|
|
return lambda x: f(g(x))
|
|
|
|
def add_one(x):
|
|
return x + 1
|
|
|
|
def double(x):
|
|
return x * 2
|
|
|
|
# Compose functions
|
|
add_one_then_double = compose(double, add_one)
|
|
result = add_one_then_double(5) # (5 + 1) * 2 = 12</code></pre>
|
|
<hr>
|
|
<h2>Patterns</h2>
|
|
<h3>Pattern 1: Map, Filter, Reduce</h3>
|
|
<p><strong>Imperative Style</strong> (mutating):</p>
|
|
<pre><code class="lang-python"># Imperative
|
|
numbers = [1, 2, 3, 4, 5]
|
|
result = []
|
|
for n in numbers:
|
|
if n % 2 == 0:
|
|
result.append(n * 2)
|
|
print(result) # [4, 8]</code></pre>
|
|
<p><strong>Functional Style</strong> (immutable):</p>
|
|
<pre><code class="lang-python"># Functional
|
|
numbers = [1, 2, 3, 4, 5]
|
|
result = list(
|
|
map(lambda n: n * 2,
|
|
filter(lambda n: n % 2 == 0, numbers))
|
|
)
|
|
print(result) # [4, 8]
|
|
|
|
# Even better: List comprehension
|
|
result = [n * 2 for n in numbers if n % 2 == 0]</code></pre>
|
|
<hr>
|
|
<h3>Pattern 2: Currying & Partial Application</h3>
|
|
<p><strong>Currying</strong>: Transform f(a, b, c) → f(a)(b)(c)</p>
|
|
<pre><code class="lang-javascript">// Not curried
|
|
function add(a, b, c) {
|
|
return a + b + c;
|
|
}
|
|
add(1, 2, 3); // 6
|
|
|
|
// Curried
|
|
function addCurried(a) {
|
|
return function(b) {
|
|
return function(c) {
|
|
return a + b + c;
|
|
};
|
|
};
|
|
}
|
|
addCurried(1)(2)(3); // 6
|
|
|
|
// Partially apply
|
|
const add1 = addCurried(1);
|
|
const add1and2 = add1(2);
|
|
const result = add1and2(3); // 6</code></pre>
|
|
<p><strong>Practical Use</strong>:</p>
|
|
<pre><code class="lang-typescript">// Reusable validators
|
|
const hasMinLength = (min: number) => (str: string) => str.length >= min;
|
|
const hasMaxLength = (max: number) => (str: string) => str.length <= max;
|
|
|
|
const isValidUsername = hasMinLength(3);
|
|
const isValidPassword = hasMinLength(8);
|
|
const isValidTweet = hasMaxLength(280);
|
|
|
|
console.log(isValidUsername("ab")); // false
|
|
console.log(isValidPassword("secret123")); // true
|
|
console.log(isValidTweet("Hello world!")); // true</code></pre>
|
|
<hr>
|
|
<h3>Pattern 3: Immutable Data Updates</h3>
|
|
<p><strong>Nested Object Updates</strong>:</p>
|
|
<pre><code class="lang-typescript">// Bad: Mutation
|
|
const user = {
|
|
name: "John",
|
|
address: {
|
|
city: "Boston",
|
|
zip: "02101"
|
|
}
|
|
};
|
|
user.address.city = "Cambridge"; // Mutation!
|
|
|
|
// Good: Immutable
|
|
const updatedUser = {
|
|
...user,
|
|
address: {
|
|
...user.address,
|
|
city: "Cambridge"
|
|
}
|
|
};</code></pre>
|
|
<p><strong>Using Libraries</strong> (Immer):</p>
|
|
<pre><code class="lang-typescript">import produce from "immer";
|
|
|
|
const updatedUser = produce(user, draft => {
|
|
draft.address.city = "Cambridge";
|
|
// Looks like mutation, but returns new object!
|
|
});</code></pre>
|
|
<hr>
|
|
<h3>Pattern 4: Function Composition</h3>
|
|
<p><strong>Manual Composition</strong>:</p>
|
|
<pre><code class="lang-python">def add_one(x):
|
|
return x + 1
|
|
|
|
def double(x):
|
|
return x * 2
|
|
|
|
def square(x):
|
|
return x ** 2
|
|
|
|
# Nested calls (hard to read)
|
|
result = square(double(add_one(5))) # ((5 + 1) * 2)^2 = 144
|
|
|
|
# Compose helper
|
|
def compose(*fns):
|
|
def composed(x):
|
|
for fn in reversed(fns):
|
|
x = fn(x)
|
|
return x
|
|
return composed
|
|
|
|
# Readable pipeline
|
|
pipeline = compose(square, double, add_one)
|
|
result = pipeline(5) # 144</code></pre>
|
|
<p><strong>Pipe Operator</strong> (JavaScript):</p>
|
|
<pre><code class="lang-javascript">// Without pipe
|
|
const result = square(double(addOne(5)));
|
|
|
|
// With pipe (future JS syntax)
|
|
const result = 5
|
|
|> addOne
|
|
|> double
|
|
|> square;</code></pre>
|
|
<hr>
|
|
<h3>Pattern 5: Monads (Error Handling)</h3>
|
|
<p><strong>Optional/Maybe Monad</strong>:</p>
|
|
<pre><code class="lang-python">from typing import Optional, TypeVar, Callable
|
|
|
|
T = TypeVar('T')
|
|
U = TypeVar('U')
|
|
|
|
class Maybe:
|
|
def __init__(self, value: Optional[T]):
|
|
self._value = value
|
|
|
|
def map(self, fn: Callable[[T], U]) -> 'Maybe[U]':
|
|
if self._value is None:
|
|
return Maybe(None)
|
|
return Maybe(fn(self._value))
|
|
|
|
def flat_map(self, fn: Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
|
|
if self._value is None:
|
|
return Maybe(None)
|
|
return fn(self._value)
|
|
|
|
def get_or_else(self, default: T) -> T:
|
|
return self._value if self._value is not None else default
|
|
|
|
# Usage: Chain operations safely
|
|
def find_user(id: str) -> Maybe[User]:
|
|
user = database.get(id)
|
|
return Maybe(user)
|
|
|
|
def get_email(user: User) -> Maybe[str]:
|
|
return Maybe(user.email)
|
|
|
|
# Safe chaining (no null checks!)
|
|
email = (find_user("123")
|
|
.flat_map(get_email)
|
|
.get_or_else("[email protected]"))</code></pre>
|
|
<p><strong>Result Monad</strong> (Rust-style):</p>
|
|
<pre><code class="lang-typescript">class Result<T, E> {
|
|
constructor(
|
|
private value?: T,
|
|
private error?: E
|
|
) {}
|
|
|
|
static ok<T>(value: T): Result<T, never> {
|
|
return new Result(value, undefined);
|
|
}
|
|
|
|
static err<E>(error: E): Result<never, E> {
|
|
return new Result(undefined, error);
|
|
}
|
|
|
|
map<U>(fn: (value: T) => U): Result<U, E> {
|
|
if (this.error !== undefined) {
|
|
return Result.err(this.error);
|
|
}
|
|
return Result.ok(fn(this.value!));
|
|
}
|
|
|
|
unwrapOr(defaultValue: T): T {
|
|
return this.value !== undefined ? this.value : defaultValue;
|
|
}
|
|
}
|
|
|
|
// Usage
|
|
function divide(a: number, b: number): Result<number, string> {
|
|
if (b === 0) {
|
|
return Result.err("Division by zero");
|
|
}
|
|
return Result.ok(a / b);
|
|
}
|
|
|
|
const result = divide(10, 2).map(x => x * 2);
|
|
console.log(result.unwrapOr(0)); // 10</code></pre>
|
|
<hr>
|
|
<h3>Pattern 6: Functors & Applicatives</h3>
|
|
<p><strong>Functor</strong>: Container with <code>map</code></p>
|
|
<pre><code class="lang-go">// Functor: List
|
|
func Map[T, U any](xs []T, f func(T) U) []U {
|
|
result := make([]U, len(xs))
|
|
for i, x := range xs {
|
|
result[i] = f(x)
|
|
}
|
|
return result
|
|
}
|
|
|
|
numbers := []int{1, 2, 3}
|
|
doubled := Map(numbers, func(n int) int { return n * 2 })
|
|
// [2, 4, 6]</code></pre>
|
|
<hr>
|
|
<h3>Pattern 7: Recursion Over Loops</h3>
|
|
<p><strong>Imperative Loop</strong>:</p>
|
|
<pre><code class="lang-python">def sum_list(numbers):
|
|
total = 0
|
|
for n in numbers:
|
|
total += n
|
|
return total</code></pre>
|
|
<p><strong>Functional Recursion</strong>:</p>
|
|
<pre><code class="lang-python">def sum_list(numbers):
|
|
if not numbers:
|
|
return 0
|
|
return numbers[0] + sum_list(numbers[1:])
|
|
|
|
# Tail-recursive (optimizable)
|
|
def sum_list_tail(numbers, acc=0):
|
|
if not numbers:
|
|
return acc
|
|
return sum_list_tail(numbers[1:], acc + numbers[0])</code></pre>
|
|
<hr>
|
|
<h3>Pattern 8: Lazy Evaluation</h3>
|
|
<p><strong>Python Generators</strong> (lazy):</p>
|
|
<pre><code class="lang-python"># Eager (loads all into memory)
|
|
def squares_eager(n):
|
|
return [x**2 for x in range(n)]
|
|
|
|
squares = squares_eager(1000000) # Memory intensive!
|
|
|
|
# Lazy (generates on demand)
|
|
def squares_lazy(n):
|
|
for x in range(n):
|
|
yield x**2
|
|
|
|
squares = squares_lazy(1000000) # No memory used yet!
|
|
for sq in squares: # Generated as needed
|
|
print(sq)</code></pre>
|
|
<p><strong>Functional Streams</strong>:</p>
|
|
<pre><code class="lang-javascript">// Infinite stream
|
|
function* naturals() {
|
|
let n = 0;
|
|
while (true) {
|
|
yield n++;
|
|
}
|
|
}
|
|
|
|
function* map(stream, fn) {
|
|
for (const value of stream) {
|
|
yield fn(value);
|
|
}
|
|
}
|
|
|
|
function* take(stream, n) {
|
|
let count = 0;
|
|
for (const value of stream) {
|
|
if (count++ >= n) break;
|
|
yield value;
|
|
}
|
|
}
|
|
|
|
// Lazy evaluation
|
|
const numbers = naturals();
|
|
const doubled = map(numbers, n => n * 2);
|
|
const first5 = take(doubled, 5);
|
|
|
|
console.log([...first5]); // [0, 2, 4, 6, 8]</code></pre>
|
|
<hr>
|
|
<h2>Best Practices</h2>
|
|
<h3>Functional Programming Guidelines</h3>
|
|
<p><strong>Do's</strong>:</p>
|
|
<ul><li>Prefer pure functions</li><li>Use immutable data structures</li><li>Compose small functions</li><li>Avoid shared mutable state</li><li>Use recursion for iteration</li><li>Leverage higher-order functions</li><li>Make illegal states unrepresentable</li></ul>
|
|
<p><strong>Don'ts</strong>:</p>
|
|
<ul><li>Mutate function arguments</li><li>Use global variables</li><li>Perform I/O in pure functions</li><li>Write deeply nested code</li><li>Ignore performance implications</li><li>Force FP in inappropriate contexts</li></ul>
|
|
<hr>
|
|
<h2>Anti-Patterns</h2>
|
|
<h3>Common FP Mistakes</h3>
|
|
<pre><code>❌ Forcing FP Everywhere
|
|
→ Use imperative code when clearer (loops for performance)
|
|
|
|
❌ Over-Abstraction
|
|
→ Don't curry every function - only when useful
|
|
|
|
❌ Ignoring Performance
|
|
→ Immutability has costs - profile and optimize
|
|
|
|
❌ Deep Nesting
|
|
→ Use pipeline/composition for readability
|
|
|
|
❌ Recreating Arrays Repeatedly
|
|
→ Use transducers or optimize with libraries
|
|
|
|
❌ No Side Effects Ever
|
|
→ I/O is necessary - isolate side effects
|
|
|
|
❌ Monads for Everything
|
|
→ Use when beneficial, not dogmatically</code></pre>
|
|
<hr>
|
|
<h2>Language-Specific Examples</h2>
|
|
<h3>Python (functools, itertools)</h3>
|
|
<pre><code class="lang-python">from functools import reduce
|
|
from itertools import chain, groupby
|
|
|
|
# Reduce
|
|
sum = reduce(lambda acc, x: acc + x, [1, 2, 3, 4], 0)
|
|
|
|
# Chain iterables
|
|
combined = chain([1, 2], [3, 4], [5, 6])
|
|
|
|
# Group by
|
|
data = [("A", 1), ("B", 2), ("A", 3)]
|
|
grouped = {k: list(g) for k, g in groupby(sorted(data), key=lambda x: x[0])}</code></pre>
|
|
<h3>JavaScript/TypeScript (Lodash/FP)</h3>
|
|
<pre><code class="lang-typescript">import { compose, map, filter } from "lodash/fp";
|
|
|
|
const process = compose(
|
|
map((x: number) => x * 2),
|
|
filter((x: number) => x > 5)
|
|
);
|
|
|
|
const result = process([1, 3, 5, 7, 9]);
|
|
// [14, 18]</code></pre>
|
|
<h3>Rust (Iterators)</h3>
|
|
<pre><code class="lang-rust">let result: Vec<i32> = vec![1, 2, 3, 4, 5]
|
|
.iter()
|
|
.filter(|&x| x % 2 == 0)
|
|
.map(|&x| x * 2)
|
|
.collect();
|
|
// [4, 8]</code></pre>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><strong>engineering-test-driven-development</strong>: Pure functions are easy to test</li><li><strong>engineering-refactoring-patterns</strong>: Refactoring to functional style</li><li><strong>engineering-code-quality</strong>: FP improves code quality</li><li><strong>engineering-design-patterns</strong>: FP alternatives to OOP patterns</li></ul>
|
|
<hr>
|
|
<h2>References</h2>
|
|
<ul><li><a href="https://www.manning.com/books/functional-programming-in-javascript">Functional Programming in JavaScript by Luis Atencio</a></li><li><a href="https://mostly-adequate.gitbook.io/mostly-adequate-guide/">Professor Frisby's Mostly Adequate Guide</a></li><li><a href="https://www.coursera.org/learn/scala-functional-programming">Functional Programming Principles by Martin Odersky</a></li><li><a href="https://ramdajs.com/">Ramda Documentation</a></li></ul>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/engineering-functional-programming.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |