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
// .eslintrc.js
module.exports = {
parser: "@typescript-eslint/parser",
plugins: ["fp-ts-strict"],
extends: ["plugin:fp-ts-strict/recommended"],
};
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
!
Avoid using undefined
in your type unions. Instead of using Type | undefined
, use Option<Type>
.
/** Example of invalid code π */
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;
}
/** Example of valid code π */
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)
);
}
Avoid using null
in your type unions. Instead of using Type | null
, use Option<Type>
.
/** Example of invalid code π */
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;
}
/** Example of valid code π */
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)
);
}
Accessing the first element of an array using array[0]
is unsafe, what if the array is empty?. Use head
from fp-ts instead.
/** Example of invalid code π */
const list = [1, 2, 3, 4, 5];
export const headAccess = list[0];
/** Example of valid code π */
const list = [1, 2, 3, 4, 5];
export const headAccess = pipe(list, head);
Accessing an element of an array using array[1]
is unsafe, what if the element is undefined?. Use lookup
from fp-ts instead.
/** Example of invalid code π */
const list = [1, 2, 3, 4, 5];
export const headAccess = list[1];
/** Example of valid code π */
const list = [1, 2, 3, 4, 5];
export const headAccess = pipe(list, lookup(1));
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.
/** Example of invalid code π */
const record: Record<string, number> = { a: 1, b: 2, c: 3 };
export const recordLookup1 = record["ma"];
export const recordLookup2 = record.ma;
/** Example of valid code π */
const record: Record<string, number> = { a: 1, b: 2, c: 3 };
export const recordLookup = pipe(record, lookup("ma"));
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!
- v0.1.1 - 13 October 2021
- v0.1.0 - 13 October 2021
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.
MIT License, see the LICENSE.md file for details.