fp-ts-strict
fp-ts can help you write safer code, but nothing stops you (or your teammates!) to write unsafe code. Well, it shouldn't be so!
ESLint plugin used to enforce functional programming types and patterns using fp-ts.
npm install --save-dev eslint-plugin-fp-ts-strict
module.exports = {
parser: "@typescript-eslint/parser",
plugins: ["fp-ts-strict"],
extends: ["plugin:fp-ts-strict/recommended"],
};
Motivation
fp-ts is awesome. Using functional programming, you can make your code safer and easier to read. Nonetheless, it's always javascript we are talking about! Therefore, nothing stops a distracted version of yourself from writing unsafe code!
ESLint can help! ESLint can look at your code and point out your typing mistakes. Well, it's time to use ESLint in its full power to enforce functional programming with fp-ts.
Welcome fp-ts-strict
!
Rules
option-over-undefined
Avoid using undefined
in your type unions. Instead of using Type | undefined
, use Option<Type>
.
export const undefinedOption1 = (): string | undefined => {
return "abc";
};
export function undefinedOption2(): number | undefined {
return 1;
}
export function undefinedOption3(): number {
const a: number | undefined = 10;
return a ?? 0;
}
export const undefinedOption1 = (): Option<string> => {
return "abc";
};
export function undefinedOption2(): Option<number> {
return 1;
}
export function undefinedOption3(): number {
const a: Option<number> = some(10);
return pipe(
a,
getOrElse((): number => 0)
);
}
option-over-null
Avoid using null
in your type unions. Instead of using Type | null
, use Option<Type>
.
export const nullOption1 = (): string | null => {
return "abc";
};
export function nullOption2(): number | null {
return 1;
}
export function nullOption3(): number {
const a: number | null = 10;
return a ?? 0;
}
export const nullOption1 = (): Option<string> => {
return "abc";
};
export function nullOption2(): Option<number> {
return 1;
}
export function nullOption3(): number {
const a: Option<number> = some(10);
return pipe(
a,
getOrElse((): number => 0)
);
}
array-head
Accessing the first element of an array using array[0]
is unsafe, what if the array is empty?. Use head
from fp-ts instead.
const list = [1, 2, 3, 4, 5];
export const headAccess = list[0];
const list = [1, 2, 3, 4, 5];
export const headAccess = pipe(list, head);
array-lookup
Accessing an element of an array using array[1]
is unsafe, what if the element is undefined?. Use lookup
from fp-ts instead.
const list = [1, 2, 3, 4, 5];
export const headAccess = list[1];
const list = [1, 2, 3, 4, 5];
export const headAccess = pipe(list, lookup(1));
record-lookup
Accessing an element of a record (map) using record['a']
or record.a
is unsafe, what if the element is undefined?. Use lookup
from fp-ts instead.
const record: Record<string, number> = { a: 1, b: 2, c: 3 };
export const recordLookup1 = record["ma"];
export const recordLookup2 = record.ma;
const record: Record<string, number> = { a: 1, b: 2, c: 3 };
export const recordLookup = pipe(record, lookup("ma"));
💡 More rules?
Of course! If you have any other rule in mind that you would like to propose, feel free to report an issue. Make typescript safe again, together!
📃 Versioning
😀 Support
Currently the best way to support me would be to follow me on my Twitter.
Another option (or Option
) would be to buy me a coffee.
👀 License
MIT License, see the LICENSE.md file for details.