How to Make Cursor Follow a Specific Coding Style

1---
2description: Enforce functional programming patterns
3globs: "*.ts,*.tsx,*.js,*.jsx"
4alwaysApply: true
5---
6
7# Functional Programming Style
8
9## ALWAYS:
10- Write pure functions with no side effects
11- Use const for all declarations (never let or var)
12- Use Array.map, .filter, .reduce instead of for loops
13- Return new objects/arrays instead of mutating existing ones
14- Use function composition and pipe patterns
15- Prefer readonly types in TypeScript
16- Use discriminated unions over class hierarchies
17
18## NEVER:
19- Mutate function arguments
20- Use class keyword (use plain objects and functions)
21- Use this keyword
22- Use for, while, or do-while loops
23- Use push, pop, splice, or other mutating array methods
24- Use delete operator on objects
25
26## Pattern:
27```typescript
28// Correct: pure function, immutable
29const addItem = (items: readonly Item[], newItem: Item): readonly Item[] =>
30  [...items, newItem];
31
32// Wrong: mutation
33const addItem = (items: Item[], newItem: Item): void => {
34  items.push(newItem);
35};
36```

1@functional-style.mdc
2
3Write a data transformation pipeline for processing user records:
41. A pure function to filter users older than 18
52. A pure function to normalize email addresses to lowercase
63. A pure function to group users by their country
74. A compose/pipe utility that chains these transformations
8
9All functions must be pure with no side effects.
10Use readonly types. Return new arrays, never mutate.

1Rewrite this code in functional programming style:
2- Replace all for loops with .map(), .filter(), or .reduce()
3- Replace mutations with immutable operations (spread operator)
4- Replace class with pure functions and plain objects
5- Remove all uses of 'this', 'let', and 'var'
6- Keep all behavior identical

1export const pipe = <T>(...fns: Array<(arg: T) => T>) =>
2  (value: T): T =>
3    fns.reduce((acc, fn) => fn(acc), value);
4
5export const compose = <T>(...fns: Array<(arg: T) => T>) =>
6  (value: T): T =>
7    fns.reduceRight((acc, fn) => fn(acc), value);
8
9export const mapArray = <T, U>(fn: (item: T) => U) =>
10  (arr: readonly T[]): readonly U[] =>
11    arr.map(fn);
12
13export const filterArray = <T>(predicate: (item: T) => boolean) =>
14  (arr: readonly T[]): readonly T[] =>
15    arr.filter(predicate);
16
17export const prop = <T, K extends keyof T>(key: K) =>
18  (obj: T): T[K] =>
19    obj[key];

1@functional-style.mdc @src/lib/fp-utils.ts
2
3Create a complete user management module with these files:
4- src/users/types.ts (readonly interfaces, discriminated unions)
5- src/users/validators.ts (pure validation functions)
6- src/users/transformers.ts (pure data transformation functions)
7- src/users/repository.ts (database access using the pipe pattern)
8
9All functions must be pure. Use pipe from @/lib/fp-utils.
10No classes, no mutations, no for loops.