This document discusses using TypeScript to communicate program intention through functional types. It covers function signatures, avoiding overuse of the "any" type, limiting strings to valid values, representing invalid states, immutability, and final thoughts on thinking about the next person maintaining code and being mindful of function signatures and types. Key topics include using union types for errors, avoiding null values with optional types, and representing domain entities as immutable records to prevent invalid states.

1. Communicating Intention
with Functional TypeScript

5. What don’t you like
about TypeScript?

7. λ
+

8. !101

9. Thiago Temple
Software Engineer
@SurveyMonkey

13. Function
Signatures
The Any
Type
Strings
Invalid
Object
States
Immutability

14. What is This Function
Doing?

15. Function Signatures

17. function add(n1: number, n2: number) { }
function processOrder(order: Order, options: Orde

19. type OrderResult =
ProcessedOrder |
OrderAction |
string;
function processOrder
( order: Order,
options: OrderOptions): OrderResult {

20. type OrderResult =
ProcessedOrder |
OrderAction |
string;

21. type OrderProcessingError = string;
type OrderResult =
ProcessedOrder |
OrderAction |
string;

22. type OrderProcessingError = string;
type OrderResult =
ProcessedOrder |
OrderAction |
OrderProcessingError;

23. Error Handling

24. function processOrder
( order: Order,
options: OrderOptions) {

25. Avoiding Throwing Exceptions

26. type Result<TResult, TError> =
Success<TResult> |
Failure<TError>;
type Success<T> = {
kind: "successfulResult";
value: T;
};
type Failure<T> = {
kind: "failedResult";
error: T;
};

27. type OrderResult =
Result<ProcessedOrder | OrderAction,
OrderProcessingError>;
function processOrder(
order: Order,
options: OrderOptions): OrderResult {

28. type OrderResult =
Result<ProcessedOrder | OrderAction,
OrderProcessingError>;
function processOrder(
order: Order,
options: OrderOptions): OrderResult {

29. type OrderResult =
Result<ProcessedOrder | OrderAction,
OrderProcessingError>;
function processOrder(
order: Order,
options: OrderOptions): OrderResult {

30. const result =
processOrder(order, orderOptions);
if (result.kind === "failedResult") {
result.error;
// OrderProcessingError A.K.A. string
} else {
result.value;
// ProcessedOrder | OrderAction
}

31. null

32. • Not Found
• An Error Has Occurred
• Unpredicted Case
• Something is Not Required
• Condition as False-y
• And More…
Versatile

33. Don’t Use null

34. function findUserById(id: string):
User | null {

35. type Option<T> =
Some<T> | None;
type Some<T> = {
kind: "someOption";
value: T;
};
type None = {
kind: "noneOption";
}

36. type Option<T> =
Some<T> | None;
function findUserById(id: string):
Option<User> {

37. const user =
findUserById(userId);
if (user.kind === "someOption") {
user.value; // User
}

38. Any What?

39. –Thiago Temple
“Don’t use any as a catch-all for types you’re unsure
of, also, don’t be lazy.”

40. Valid Uses of any
• When you know nothing about the given value
• When you don’t care about the given value

41. unknown

42. function exec(args: unknown) {
args["someKey"] // Compile Error
}

43. function exec<T extends { someKey: string }>(args: T) {
args["someKey"] // OK
}

44. const val1 = lib.someFun();
lib2.otherFunc(val1);
// Err: val2 is of != type

45. const val1: any = lib.someFun();
lib2.otherFunc(val1);

46. const val1 = lib.someFun();
lib2.otherFunc(val1 as any);

47. L
I
M
I
T
I
N
G
S
T
R
I
N
G
S

48. function findByGenre(genre: string): Movie[]

49. type Genre =
"Drama" |
"Comedy" |
"Action";
function findByGenre(genre: Genre): Movie[] {

50. type OrderStatus =
"New" |
"Paid" |
"Shipped" |
"Completed";
type Order = {
status: OrderStatus
// ...
};

51. function processOrder(order: Order): Order {
switch(order.status) {
case "New":
return ...;
case "Paid":
return ...;
case "Shipped":
return ...;
case "Completed":
return ...;
}
}

52. function processOrder(order: Order): Order {
switch(order.status) {
case "New":
return ...;
case "Paid":
return ...;
case "Shipped":
return ...;
case "Completed":
return ...;
}
}

53. nvalid States Impossible to Re

54. type Payment = {
amount: number;
creditCardInfo?: CreditCardInfo;
payPalInfo?: PayPalInfo;
cash: boolean;
}

55. const payment: Payment = {
amount: 42,
cash: false
};

56. type Payment = {
amount: number;
paymentInfo: PaymentInfo;
}
type PaymentInfo =
CreditCardInfo |
PayPalInfo |
Cash;

57. type CreditCardInfo = {
kind: "creditCardInfo";
// ...
};
type PayPalInfo = {
kind: "payPalInfo";
// ...
};
type Cash = {
kind: "cash";
}

58. const payment: Payment = {
amount: 42,
paymentInfo: {
kind: "creditCardInfo",
number: 12321312312312312312312
}
};

59. type Order = {
orderId: string;
billingAddress: Address;
shippingAddress?: Address;
};

60. type Order = {
orderId: string;
billingAddress: Address;
shipping: ShippingInfo;
};
type ShippingInfo =
SameAsBilling |
DownloadableContent |
ShippingAddress;

61. type SameAsBilling = {
kind: "sameAsBilling";
}
type DownloadableContent = {
kind: "downloadableContent";
}
type ShippingAddress = {
kind: "shippingAddress";
address: Address;
}

62. ShippingResult {
switch(order.shipping.kind) {
case "downloadableContent":
return ...;
case "sameAsBilling":
return ...;
case "shippingAddress":
order.shipping.address; // Address

63. ShippingResult {
switch(order.shipping.kind) {
case "downloadableContent":
return ...;
case "sameAsBilling":
return ...;
case "shippingAddress":
order.shipping.address; // Address

64. ShippingResult {
switch(order.shipping.kind) {
case "downloadableContent":
return ...;
case "sameAsBilling":
return ...;
case "shippingAddress":
order.shipping.address; // Address

65. ShippingResult {
switch(order.shipping.kind) {
case "downloadableContent":
return ...;
case "sameAsBilling":
return ...;
case "shippingAddress":
order.shipping.address; // Address

66. ShippingResult {
switch(order.shipping.kind) {
case "downloadableContent":
return ...;
case "sameAsBilling":
return ...;
case "shippingAddress":
order.shipping.address; // Address

67. What Happened With my Data

70. function processOrders(orders: readonly Order[]) {
orders.push({...}) // Error
orders.pop() // Error
orders.reverse() // Error
}

71. function processOrders(order: readonly Order) {

72. function processOrders
(order: Readonly<Order>) {
order.orderId = 123; // Error
order.customer.customerId = 123; // OK
}

73. type Immutable<T> = {
readonly [K in keyof T]: Immutable<T[K]>;
}
type Order = Immutable<{
orderId: string;
customer: Customer;
billingAddress: Address;
shipping: ShippingInfo;
}>;

74. function processOrder(order: Immutable<Order>)

75. function processOrder(order: Immutable<Order>) {
order.orderId = ""; // Error
order.customer.customerId = ""; // Error
order.shipping = { kind: "sameAsBilling" }; // Error
}

76. Final Thoughts and
Recap

77. Compiled Code Doesn’t Get Stale

78. Think About The Next Person
(and yourself)

79. nest About Your Function Sign

80. Be Mindful With Your Use of any

81. Limit the Scope of Strings

82. nvalid States Impossible to Re

83. surveymonkey.com/careers

84. Thank You
@ThiagoTemple