首页 Ocaml(1) | Vincent's Technical Reports (Vol. 2)
文章
取消

Ocaml(1) | Vincent's Technical Reports (Vol. 2)

发表于 2025/07/03 更新于 2026/01/02
作者
23 分钟阅读

Ocaml编程语言初探

简介

OCaml (Objective Caml)是一种功能强大、兼具函数式、命令式和面向对象编程特性的通用编程语言。它由 INRIA(法国国家信息与自动化研究所)开发，最初设计于 1980 年代，是 Caml (Categorical Abstract Machine Language)语言的扩展版本，而 Caml 是 ML(Meta Language)语言家族的一员。ML 语言起源于 1970 年代的 Edinburgh LCF 项目，旨在为形式化证明系统提供编程支持。OCaml专注于函数式编程，以其类型安全、性能高效和表达力强等特点，在学术研究、工业开发和教学领域广受欢迎。

特性

强静态类型系统

  • OCaml采用静态类型检查，无需显式声明类型，编译器通过类型推导自动推断变量类型。
  • 类型系统非常严格，防止运行时类型错误。例如：
    1
2

    let add x y = x + y
(* 编译器推断类型为 int -> int -> int *)
  • 支持多态类型，如 'a list 表示任意类型的列表。

函数式编程

  • 函数是一等公民，支持高阶函数、闭包和递归。
  • 强调不可变性(immutability)，默认情况下数据是不可变的，减少副作用。
  • 强大的模式匹配(pattern matching)机制，用于处理复杂的数据结构。例如：
    1
2
3

    let rec factorial n = match n with
  | 0 -> 1
  | n -> n * factorial (n - 1)

命令式编程

  • 支持可变状态(如 ref 类型)和循环结构，允许命令式编程风格。
  • 示例：使用可变引用计算累加和：
    1
2
3
4

    let sum_list lst =
  let sum = ref 0 in
  List.iter (fun x -> sum := !sum + x) lst;
  !sum

面向对象编程

  • OCaml 支持类、对象、继承和多态，适合需要面向对象设计的场景。
  • 示例：定义一个简单的类：
    1
2
3
4
5
6
7

    class point x_init y_init = object
  val mutable x = x_init
  val mutable y = y_init
  method move dx dy = x <- x + dx; y <- y + dy
  method get_x = x
  method get_y = y
end

模块系统

  • OCaml 提供强大的模块系统，支持抽象数据类型和代码组织。
  • 模块可以包含类型、值和函数，支持函子(functor)实现模块的泛型编程。
  • 示例：定义一个简单模块：
    1
2
3
4

    module IntSet = Set.Make(struct
  type t = int
  let compare = compare
end)

高效性能

  • OCaml 编译器生成高效的本机代码，性能接近 C/C++。
  • 提供增量式垃圾回收(Garbage Collection)，优化内存管理。
  • 支持直接调用 C 函数(通过外部接口)，便于与底层系统集成。

并发与并行支持

  • OCaml 5.x 引入了多核 OCaml，支持并行计算，使用域(domains)和效果系统(effect system)处理并发。
  • 提供了轻量级线程(如 Lwt 和 Async 库)用于异步编程。

异常处理

  • 支持异常机制，允许优雅地处理错误。
  • 示例：
    1
2

    try List.find (fun x -> x > 10) [1; 2; 3]
with Not_found -> 0

强大的工具生态

  • 编译器：OCaml 提供快速的原生代码编译器和字节码编译器。
  • 包管理：使用 opam(OCaml Package Manager)管理库和依赖。
  • 工具：支持 dune(构建工具)、ocamlformat(代码格式化)、merlin(IDE 支持)等。

安装

1
2

sudo apt install ocaml
sudo apt install utop
  • UTop 是Ocaml的REPL(read evaluate print loop)，在Ocaml中也叫做toplevel。
  • 输入表达式，可以看到对应的带有类型的输出，需要记得在每行后结尾加两个分号;;。
  • 关闭UTop可以使用快捷键ctrl+d或者在UTop中执行exit 0;;。
1
2
3
4
5

─( 20:01:07 )─< command 0 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # 1 + 2;;
- : int = 3
─( 20:01:07 )─< command 1 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # exit 0;;

语法与编程风格

OCaml 的语法简洁优雅，结合了函数式和命令式的特点。

基本类型与操作

  • 基本类型：int、float、bool、string、char 等。
  • 列表：[1; 2; 3]，使用分号分隔元素。
  • 元组：(1, "hello")，表示异构数据集合。

模式匹配

模式匹配是 OCaml 的核心特性，用于解构数据和控制流。

1
2
3

let rec length lst = match lst with
  | [] -> 0
  | _ :: tail -> 1 + length tail

高阶函数

支持函数作为参数或返回值。

1
2
3

let apply_twice f x = f (f x)
let square x = x * x
let result = apply_twice square 3 (* the result is 81 *)

模块与函子

模块系统支持代码抽象和复用：

1
2
3
4
5
6
7
8
9

module type Comparable = sig
  type t
  val compare : t -> t -> int
end

module SetMaker (C : Comparable) = struct
  type t = C.t
  let compare = C.compare
end

详细介绍

  • 可以使用let定义变量，但Ocaml中的变量值是不可变的。
  • =相当于C语言中的双等号==，代表判定等号两侧是否相等。
  • 变量名必须以小写字母或者下划线开头。
1
2
3
4
5
6
7
8
9

─( 20:01:58 )─< command 0 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let x = 50;;
val x : int = 50
─( 20:01:58 )─< command 1 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # x = 50;;
- : bool = true
─( 20:03:28 )─< command 2 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # x = 500;;
- : bool = false
  • 可以使用let+in的语法来计算函数值。
1
2
3
4
5
6

─( 20:03:54 )─< command 3 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let x = 100 in x * (x - 1);;
- : int = 9900
─( 20:15:07 )─< command 4 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let x = 10 in let y = 100 in x * y;;
- : int = 1000
  • let也可以用来定义一元函数甚至多元函数。
1
2
3
4
5
6
7
8
9

─( 20:17:51 )─< command 5 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let square x = x * x;;
val square : int -> int = <fun>
─( 20:17:53 )─< command 6 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let area = square 100;;
val area : int = 10000
─( 20:18:18 )─< command 7 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let multiply x y = x * y;;
val multiply : int -> int -> int = <fun>
  • 可以使用let rec来定义递归函数。
1
2
3
4
5
6

─( 20:18:33 )─< command 8 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let rec range a b = if a > b then [] else a :: range (a + 1) b;;
val range : int -> int -> int list = <fun>
─( 20:20:21 )─< command 9 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let digits = range 0 9;;
val digits : int list = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9]
  • Ocaml是强静态类型语言，运行前编译器会自动进行类型推断，基本类型和其他语言类似。
  • Ocaml中禁止隐式的类型转换。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

─( 20:23:53 )─< command 10 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # 1 + 1;;
- : int = 2
─( 20:25:08 )─< command 11 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # 1.0 +. 1.0;;
- : float = 2.
─( 20:25:17 )─< command 12 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # false;;
- : bool = false
─( 20:25:47 )─< command 13 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # 's';;
- : char = 's'
─( 20:26:22 )─< command 14 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # "Vincent";;
- : string = "Vincent"
  • 可以使用模式匹配方便地处理各种情况，非常适合corner case很多的情况。
1
2
3
4
5
6
7
8
9

─( 20:27:51 )─< command 15 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop #  let rec factorial n =
match n with
| 0 | 1 -> 1
| _ -> n * factorial (n - 1);;
val factorial : int -> int = <fun>
─( 20:51:20 )─< command 16 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # factorial 5;;
- : int = 120
  • 列表list
1
2
3
4
5
6
7
8
9
10
11
12

─( 20:52:55 )─< command 17 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # [];;
- : 'a list = []
─( 20:53:12 )─< command 18 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # [1;1];;
- : int list = [1; 1]
─( 20:55:47 )─< command 19 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # [true;false];;
- : bool list = [true; false]
─( 20:55:47 )─< command 20 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # [[1;2];[1;2]];;
- : int list list = [[1;2];[1;2]]
  • 操作符有::(用来在列表前添加一个元素)和@(用来连接两个列表)。
  • List的方法hd和tl可以分别获得列表头尾的元素。
1
2
3
4
5
6
7
8
9
10
11
12

─( 20:56:02 )─< command 21 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # 1 :: [2;3];;
- : int list = [1; 2; 3]
─( 20:56:43 )─< command 22 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # [1] @ [2;3];;
- : int list = [1; 2; 3]
─( 21:00:45 )─< command 23 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # List.hd [1;2;3;4];;
- : int = 1
─( 21:00:59 )─< command 24 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # List.tl [1;2;3;4];;
- : int list = [2; 3; 4]
  • partial application特性，可以给一个多元函数部分参数得到另一个函数。
1
2
3
4
5
6
7
8
9

─( 15:27:40 )─< command 1 >──────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let add a b = a + b;;
val add : int -> int -> int = <fun>
─( 15:30:09 )─< command 2 >──────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let add1 = add 1;;
val add1 : int -> int = <fun>
─( 15:30:14 )─< command 3 >──────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # add1 6;;
- : int = 7
  • 元组tuple，可以是不同类型数据的组合，之前的list必须是相同类型元素的组合。
  • tuple不具备list可以改变长度的特性，tuple的长度是固定的。
  • 自定义枚举类型，注意首字母必须大写。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

─( 15:31:22 )─< command 4 >───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let tup = (7,"vincent",100.00);;
val tup : int * string * float = (7, "vincent", 100.)
─( 15:44:27 )─< command 14 >───────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type gender = Male | Female | Helicopter;;
type gender = Male | Female | Helicopter
─( 15:44:34 )─< command 15 >───────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let l =[Male;Female;Helicopter];;
val l : gender list = [Male; Female; Helicopter]
─( 15:46:07 )─< command 20 >───────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type gender = Male | Female | Helicopter | Mixture of int * int * int;;
type gender = Male | Female | Helicopter | Mixture of int * int * int
─( 15:46:08 )─< command 21 >───────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let l =[Male;Female;Helicopter;Mixture (1,2,6)];;
val l : gender list = [Male; Female; Helicopter; Mixture (1, 2, 6)]
  • Record类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

─( 15:35:31 )─< command 7 >────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type person = {name:string;nickname:string;age:int;};;
type person = { name : string; nickname : string; age : int; }
─( 15:39:38 )─< command 8 >────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let vincent = {name = "vincent";nickname="embracer";age=20;};;
val vincent : person = {name = "vincent"; nickname = "embracer"; age = 20}
─( 17:15:25 )─< command 50 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type person = {name:string;nickname:string;mutable age:int;};;
type person = { name : string; nickname : string; mutable age : int; }
─( 17:15:31 )─< command 51 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let birthday p = p.age <- p.age + 1;;
val birthday : person -> unit = <fun>
─( 17:21:54 )─< command 52 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let vincent = {name = "vincent";nickname="embracer";age=20;};;
val vincent : person = {name = "vincent"; nickname = "embracer"; age = 20}
─( 17:22:50 )─< command 54 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # birthday vincent;;
- : unit = ()
─( 17:23:02 )─< command 55 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # vincent;;
- : person = {name = "vincent"; nickname = "embracer"; age = 21}
  • 数据类型具有多态性和递归性
  • 多态性：数据类型可以引用其他的子类型
  • 递归性：数据类型可以递归地引用自身
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

─( 15:49:02 )─< command 22 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type 'a tree = | Leaf | Node of 'a tree * 'a * 'a tree;;
type 'a tree = Leaf | Node of 'a tree * 'a * 'a tree
─( 15:49:02 )─< command 23 >─────────────────────────────────────{ counter: 0 }─
utop # let rec total t = match t with | Leaf -> 0 | Node (l,x,r) -> total l + x + total r;;
val total : int tree -> int = <fun>
─( 16:43:13 )─< command 24 >─────────────────────────────────────{ counter: 0 }─
utop # let rec reverse t = match t with | Leaf -> Leaf | Node (l,x,r) -> Node (reverse r, x, reverse l);;
val reverse : 'a tree -> 'a tree = <fun>
─( 16:45:16 )─< command 25 >─────────────────────────────────────{ counter: 0 }─
utop # let t = Node(Node(Leaf,1,Leaf),2,Node(Node(Leaf,3,Leaf),4,Node(Leaf,5,Leaf)));;
val t : int tree =
  Node (Node (Leaf, 1, Leaf), 2,
   Node (Node (Leaf, 3, Leaf), 4, Node (Leaf, 5, Leaf)))
─( 16:48:00 )─< command 26 >─────────────────────────────────────{ counter: 0 }─
utop # let sum = total t;;
val sum : int = 15
─( 16:51:09 )─< command 27 >─────────────────────────────────────{ counter: 0 }─
utop # let mirror = reverse t;;
val mirror : int tree =
  Node (Node (Node (Leaf, 5, Leaf), 4, Node (Leaf, 3, Leaf)), 2,
   Node (Leaf, 1, Leaf))
─( 16:51:24 )─< command 28 >─────────────────────────────────────{ counter: 0 }─
utop # let sum = total mirror;;
val sum : int = 15
─( 16:51:59 )─< command 29 >─────────────────────────────────────{ counter: 0 }─
utop # t = reverse mirror;;
- : bool = true
  • 错误处理
  • 可以定义异常exception，同时为其添加子类型。
1
2
3
4
5
6
7
8
9
10
11
12

─( 16:56:53 )─< command 32 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # exception E;;
exception E
─( 16:57:01 )─< command 33 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # exception E1 of string;;
exception E1 of string
─( 16:57:33 )─< command 35 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let divide a b = if b = 0 then raise (E1 "division by zero") else a / b;;
val divide : int -> int -> int = <fun>
─( 16:59:27 )─< command 37 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let result = try divide 1 0 with E1 _ -> 0;;
val result : int = 0
  • option类型，类似Rust。
1
2
3
4
5
6

─( 16:59:53 )─< command 38 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # type 'a option = None | Some of 'a;;
type 'a option = None | Some of 'a
─( 17:00:06 )─< command 39 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let list_find_option p l = match List.find p l with | v -> Some(v) | exception Not_found -> None;;
val list_find_option : ('a -> bool) -> 'a list -> 'a option = <fun>
  • 可变引用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

─( 17:09:06 )─< command 41 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let r = ref 50;;
val r : int ref = {contents = 50}
─( 17:10:58 )─< command 42 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # r := 100;;
- : unit = ()
─( 17:12:50 )─< command 43 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # !r;;
- : int = 100
─( 17:13:01 )─< command 44 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let a = r;;
val a : int ref = {contents = 100}
─( 17:13:10 )─< command 45 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # a := 100;;
- : unit = ()
─( 17:13:16 )─< command 46 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # !r;;
- : int = 100
  • 可变数组。
1
2
3
4
5
6
7
8
9

─( 17:13:27 )─< command 47 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let arr = [|1;1;1|];;
val arr : int array = [|1; 1; 1|]
─( 17:13:35 )─< command 48 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # arr.(0) <- 100;;
- : unit = ()
─( 17:15:13 )─< command 49 >─────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # arr;;
- : int array = [|100; 1; 1|]
  • 示例：列表求和函数。
  • Ocaml编译器会对模式匹配中忽略的情况发出警告。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

─( 21:01:33 )─< command 25 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let rec total l =
match l with
| [] -> 0
| h :: t -> h + total t;;
val total : int list -> int = <fun>
─( 21:01:37 )─< command 26 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # total [1;2;3;4;5;6;7;8;9];;
- : int = 45
─( 21:05:14 )─< command 27 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let rec total l =
match l with
| h :: t -> h + total t;;
Lines 2-3, characters 0-23:
Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
[]
val total : int list -> int = <fun>
  • 示例：映射函数。
1
2
3
4
5
6

─( 21:05:31 )─< command 28 >──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────{ counter: 0 }─
utop # let rec map f l =
match l with
| [] -> []
| h :: t -> f h :: map f t;;
val map : ('a -> 'b) -> 'a list -> 'b list = <fun>
  • 示例：快速排序(quicksort)算法。
1
2
3
4
5
6
7
8
9
10
11

let rec quicksort = function
  | [] -> []  (* 空列表直接返回 *)
  | pivot :: rest ->
      let rec partition left right = function
        | [] -> (left, right)
        | x :: xs ->
            if x <= pivot then partition (x :: left) right xs
            else partition left (x :: right) xs
      in
      let (left, right) = partition [] [] rest in
      quicksort left @ [pivot] @ quicksort right
  • 示例：算式解释器。
1
2
3
4
5
6
7
8
9
10
11
12

type expr =
  | Num of int
  | Add of expr * expr
  | Sub of expr * expr

let rec eval = function
  | Num n -> n
  | Add (e1, e2) -> eval e1 + eval e2
  | Sub (e1, e2) -> eval e1 - eval e2

let example = Add (Num 5, Sub (Num 10, Num 3))
let result = eval example (* the result is 12 *)

OCaml的应用场景

OCaml在多个领域有广泛应用，尤其在对类型安全和性能要求高的场景：

学术研究

  • 形式化验证：OCaml 是 Coq 定理证明器的实现语言，用于开发形式化验证工具。
  • 编程语言研究：OCaml 的类型系统和模块系统使其成为编译器和解释器开发的理想选择。

工业应用

  • 金融系统：如 Jane Street 广泛使用 OCaml 开发高性能交易系统，因其类型安全和低延迟。
  • 静态分析工具：如 Facebook 的 Flow(JavaScript 静态类型检查器)和 Infer(代码分析工具)用 OCaml 实现。
  • 区块链：Tezos 区块链的协议实现大量使用 OCaml。

系统编程

  • MirageOS：一个用 OCaml 编写的轻量级 Unikernel 系统，用于构建高效、安全的操作系统。
  • 编译器与工具：OCaml 自身编译器、FFmpeg 的部分组件等都用 OCaml 编写。

OCaml学习资源

  • 官方文档：OCaml 官方网站提供教程和参考手册。
  • 书籍：
    • 《Real World OCaml》：面向实际应用的 OCaml 教程。
    • 《OCaml from the Very Beginning》：适合初学者。
  • 工具：
    • opam：安装 OCaml 和管理依赖。
    • dune：现代构建工具。
    • utop：交互式 REPL，适合学习和实验。
  • 社区：OCaml Discourse、Reddit 和 Stack Overflow 上的 OCaml 标签。
Vincent's Technical Reports
Ocaml Programming Language
本文由作者按照 CC BY 4.0 进行授权
最近更新
文章内容

A Try on Reverse Engineering | Vincent's Technical Reports (Vol. 1)

Productivity Tool Recommendations | Workflow Wizards (Vol. 1)