SkillAgentSearch skills...

nw-fp-principles

Core functional programming thinking patterns and type system foundations, language-agnostic

Install / Use

npx skills add nWave-ai/nWave --skill nw-fp-principles

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

86/100

Supported Platforms

Universal

Our assessment of nw-fp-principles

nw-fp-principles scores 86/100 on our quality scale, 2478th of 4,702 Development & Engineering skills we index.

Its SKILL.md is 8.8 KB long, well organised into 19 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.

It has 617 GitHub stars, a meaningful sign that others use it.

Substance
29/30
Structure
18/20
Description
12/15
Adoption
12/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so nw-fp-principles is actively maintained.
  • Our last check on 2026-11-03 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-08. Automated pattern scan on 2026-10-08. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

nw-fp-principles compared with similar skills

All 4 of these similar skills score higher than nw-fp-principles; compare them before choosing.

SkillScoreStarsUpdatedFormat
nw-fp-principles (this skill)by nWave-ai866172mo agoSKILL.md
taste-skillby Leonxlnx100117.6k9d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.3ktodayCLAUDE.md
claude-howtoby luongnv8910047.4k3d agoCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.9k8d agoCLAUDE.md

Frequently asked questions

How do I install nw-fp-principles?
Run npx skills add nWave-ai/nWave --skill nw-fp-principles. The install tabs above show the steps for each supported agent.
Which AI agents does nw-fp-principles work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is nw-fp-principles safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is nw-fp-principles still maintained?
The repository was last updated about 2 months ago, so nw-fp-principles is actively maintained.

name: nw-fp-principles agent: nw-functional-software-crafter description: Core functional programming thinking patterns and type system foundations, language-agnostic user-invocable: false disable-model-invocation: true

FP Principles

Core functional programming thinking patterns. Language-agnostic.

Cross-references: fp-domain-modeling | fp-hexagonal-architecture | fp-algebra-driven-design


1. Higher-Order Functions as Problem Decomposition

[STARTER]

Three operations replace most loops:

| Operation | Purpose | Replaces | |-----------|---------|----------| | Map | Transform each element, preserve structure | Loop building new collection | | Filter | Keep elements matching condition | Loop with conditional | | Fold | Accumulate elements into single result | Loop with running total |

When to use Map: Transform every element without changing collection shape. Nested maps handle nested structures. When to use Filter: Select elements without changing their values. When to use Fold: Reduce collection to single value. Accumulator IS your state. Combining function IS your state transition. Folds make state machines explicit.

Decision: "Am I transforming, selecting, or accumulating?" Pick matching operation. If none fit, compose two.

Why: These operations communicate intent. Map says "same shape, different values." Fold says "many inputs, one output." Loops say nothing about intent until you read every line.


2. Type-Driven Design

[STARTER]

Write the type signature before implementation. The type tells you what the function can and cannot do.

Process:

  1. Declare what the function consumes and produces
  2. Ask: "which type-specific operations do I actually use?"
  3. Replace concrete types with type variables for everything you don't inspect
  4. Add constraints only for capabilities you use (equality, ordering, display)

Design progression: Concrete types -> type variables -> constrained type variables. Each step increases reuse while documenting minimal assumptions.

Why: Function's type signature is a contract. Narrower types mean fewer possible implementations, fewer bugs.


3. Pattern Matching as Decision Decomposition

[STARTER]

Decompose decisions by data shape, not boolean conditions. Each clause handles one concrete case. Compiler verifies exhaustiveness.

When to use pattern matching: "What shape is this data?" When to use guards/conditions: "What property does this value have?" When to use named bindings: Intermediate results need a name to avoid repetition.

Heuristic: Prefer small extracted functions over giant match expressions. Pattern match on top-level shape, delegate to named functions for sub-decisions.

Exhaustiveness as safety net: When you add a new variant to a choice type, compiler flags every match that doesn't handle it.


4. Composition Patterns

[INTERMEDIATE]

Partial Application

Fix some arguments of a general function to create specialized version. Eliminates throwaway helper functions.

When: General function exists and you need specialized version for specific context.

Function Composition (Pipelines)

Chain functions where output of one feeds into next. Each function has single responsibility.

Why: Composition reveals architecture of computation. Pipelines read as sequence of steps, making business process visible.

Point-Free Style

Omit explicit argument when function is just a composition. Use when it reveals intent. Avoid when it obscures meaning.


5. Container Abstractions

[INTERMEDIATE] -> [ADVANCED]

Progressive hierarchy for working with values inside containers (nullables, lists, futures, results).

[INTERMEDIATE] Transformable Container (Functor)

What: Apply function to values inside container without changing structure. Plain English: "I have a value in a box. Transform the value without opening the box." When: You have nullable/optional/list/future and want to transform contents without inspecting the container. Guarantees: Transforming with identity does nothing. Can fuse or split transformations freely.

[INTERMEDIATE] Combinable Containers (Applicative)

What: Apply a function inside a container to values inside other containers. Plain English: "I have a function in a box AND values in boxes. Combine them." When: Validation -- check multiple fields independently, combine results only if all succeed. Doesn't short-circuit; collects all errors.

[INTERMEDIATE] Combinable Values (Monoid)

What: Combine two values of same type into one, with default element that changes nothing. Plain English: "I have many values. Smash them together into one." When: Folding/reducing collections. Combining operation must be associative, enabling parallelism. Examples: String concatenation with empty string | addition with zero | list append with empty list.

[ADVANCED] Chainable Operations (Monad)

What: Chain operations where each step produces wrapped value, next step depends on previous result. Plain English: "Step 1's output determines what step 2 does. Each step might fail/branch/have effects." When: Sequential dependent operations where each step can fail, branch, or produce effects.

Decision Tree: Which Abstraction Do I Need?

Do I need to transform values inside a container?
  YES, one function, one container --> Transformable (Functor)
  YES, combine multiple independent containers --> Combinable Containers (Applicative)
  YES, chain dependent operations sequentially --> Chainable Operations (Monad)
Do I need to combine values of the same type?
  YES --> Combinable Values (Monoid)

Progression Summary

Each level adds a new kind of combination:

  • Transformable: one function, one container
  • Combinable Containers: one function, multiple containers (independent)
  • Chainable: sequential dependent operations, each producing container
  • Combinable Values: same-type values collapsed into one

Runnable Example: Map, Filter, Fold on Domain Objects

orders = [Order(100, "pending"), Order(250, "shipped"), Order(50, "pending")]

pendingTotals = orders
  |> filter (o -> o.status == "pending")    -- [Order(100, "pending"), Order(50, "pending")]
  |> map (o -> o.amount)                    -- [100, 50]
  |> fold 0 (acc, x -> acc + x)            -- 150

6. Specialized Chainable Patterns

[ADVANCED]

| Pattern | What It Manages | When to Use | |---------|----------------|-------------| | Optional (Maybe/Option) | Possible absence | Operations that can fail without explanation | | Result (Either) | Failure with context | Operations that fail with error details | | Environment (Reader) | Shared read-only config | Dependency injection, configuration threading | | Accumulator (Writer) | Side-channel output | Logging, auditing, collecting metadata | | Stateful (State) | Sequential state changes | Counters, parsers, accumulators |

These compose: real applications stack multiple patterns. See fp-hexagonal-architecture for DI patterns.


7. Lazy Evaluation as Design Pattern

[INTERMEDIATE]

Separate WHAT to compute from WHEN it gets computed. Define potentially infinite sequences and let consumer determine how much to evaluate.

When: Generating candidates then selecting results | pagination and streaming | decoupling producers from consumers | build systems that only rebuild what changed.

Separation principle: Generate all possibilities, then filter. Declarative style says WHAT you want, not HOW to search.


8. The FP Problem-Solving Method

[STARTER]

  1. Start with type signature: What does this function consume and produce?
  2. Identify traversal pattern: Map, filter, fold, or search?
  3. Recognize accumulator: If folding, what is the state and how does each element change it?
  4. Decompose by data shape: Pattern match on constructors, handle each case independently
  5. Compose small functions: Build complex behavior from simple, tested pieces

Mindset shift: Describe WHAT to compute (transformations, compositions, constraints) rather than HOW (loops, mutations, control flow).

| Imperative Thinking | Functional Thinking | |---------------------|---------------------| | Loop through items | Map/filter/fold over collections | | Mutate variables | Transform immutable values | | Check conditions with if/else | Pattern match on data shapes | | Inherit from base class | Satisfy capability constraints | | Call methods on objects | Compose functions into pipelines | | Handle errors with try/catch | Use Optional/Result for explicit failure in types | | Pass dependencies explicitly | Use Environment pattern for implicit config |

Related Skills

View on GitHub
GitHub Stars617
CategoryDevelopment
Updated2mo ago
Forks63

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions