00class MyInt implement MyInt {
01  // 加法
02  add(val: number | MyInt): MyInt {}
03  // 转字符串
04  toString() {}
05  // ... 其他实现
06}

00interface DragState {
01  // 描述当前是否在拖拽中 (比如 touchStart 的时候设置为 true)
02  isInDragging: boolean
03  // touchStart 的初始坐标轴位置
04  start?: [number, number]
05  // touchMove 计算两个坐标轴拖拽的位移
06  translation2D?: [number, number]
07  // 拖拽的方向 (string 为 Left Right Down Up 这些)
08  direction2D?: [string, string]
09}

00// adt-drag-define.tsx
01
02// 左右拖拽组件定义左和右
03export enum Direction {
04  Center,
05  Left,
06  Right,
07  Up,
08  Down,
09}
10
11// 记录拖拽的 2d 方向
12// 比如如果拖动到左上角则记录为 [.Left, .Up] 代表左上
13export type Direction2D = [Direction, Direction]
14
15// 描述 2d 坐标位移, 可以通过这个位移得到 Direction2D
16export type Translation2D = [number, number];
17
18// 拖拽组件: 不活跃
19export type Inactive = {
20  // 标记为不活跃状态
21  type: 'inactive'
22}
23
24// 拖拽组件: 拖拽中
25export type Dragging = {
26  // 标记为拖拽中状态
27  type: 'dragging',
28  // 记录 onTouchStart 的瞬间坐标
29  start: { x: number, y: number },
30  // 记录 x y 坐标轴的位移
31  translation: Translation2D,
32  // 记录 x y 坐标轴的方向
33  direction: Direction2D,
34}
35
36// 组合状态来描述拖拽组件的全部状态取值
37export type DragState = Inactive | Dragging

00enum DragState {
01  // 不活跃 
02  case inactive
03  // 活跃中, 关联两个值 start 和 translation
04  // CGPoint, CGSize 是内置的坐标类型 可以用来描述点和位移
05  case dragging(start: CGPoint, translation: CGSize)
06}
07
08func printState(state: DragState) {
09  switch state {
10    // 因为 state 类型是确定的所以这里可以缩写 .inative
11    case .inative:
12      print("不活跃")
13    // 匹配到拖拽中, 并将关联的两个值存储到变量中 
14    case .dragging(let myStart, let myTranslation)
15      print("拖拽中", myStart, myTranslation)
16  }
17}

00type Maybe<T> = null | undefined | T

00interface Person {
01  name: string
02  age: number
03}

00enum AppColor {
01  Primary,
02  Black,
03  Error,
04}

00type Colors = "RED" | "GREEN" | "BLUE"

00func divide(a float64, b float64) (float64, error) {
01  if b == 0 {
02    return 0, errors.New("除 0 错误")
03  }
04  return a / b, nil
05}
06
07func main() {
08  result, err := divide(10, 2)
09  if err != nil {
10    fmt.Println("Error:", err)
11  } else {
12    fmt.Println("Result:", result)
13  }
14}

00function divide(a: number, b: number): [number?, Error?] {
01  if (b === 0) return [undefined, new Error("除 0 错误")]
02  return [a / b, undefined]
03}
04const result = divide(123, 0)
05// result 类型是 [number?, Error?] 有四种取值可能性 ...

00interface Obj {
01  value?: number | null
02}
03// 1. { value: undefined }
04// 2. { value: null }
05// 3. { value: 3.1415926 }
06// 4. { value: 其他值 } 可能不是数字 ts 无法保证, 有的人喜欢 any
07
08// 有可能 1 和 2 两个对应的状态含义不是一样的... 于是:
09if (obj.value === undeinfed) {}
10else if (obj.value === null) {}
11else if (typeof obj.value === 'number' ) {}
12else {}

00data Tree a =
01    Empty
02  | Node a (Tree a) (Tree a)

00enum Tree<T> {
01  case empty
02  indirect case node(T, Tree, Tree)
03}

00sealed class Tree<T> {
01  data class Node<T>(
02    val value: T,
03    val left: Tree<T>?,
04    val right: Tree<T>?
05  ) : Tree<T>()
06}

00type Tree<T> =
01  | null
02  | { value: T, left: Tree<T>, right: Tree<T> }

00type Tree struct {
01    Value int
02    Left  *Tree
03    Right *Tree
04}

00class TreeNode<T> {
01    T val;
02    TreeNode<T> left;
03    TreeNode<T> right;
04    TreeNode(T val) {
05        this.val = val;
06        this.left = null;
07        this.right = null;
08    }
09}

00+++++[>++++[>++++<-]<-] # 声明根节点的值为5
01
02>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++. # 在根节点的右节点上存储9
03
04<+++++[-<++++++>]<. # 在根节点的左节点上存储7
05
06>>+++++++++++++++++++++++++++++++++++++++++. # 在右节点的左节点上存储17
07
08<<+++++++++++. # 在左节点的左节点上存储13
09
10>>+. # 在右节点的右节点上存储18
11
12# 上述这段代码描述了这颗树
13      5 
14    /   \ 
15   13    9 
16        / \ 
17       17  18

00// option.enum.ts
01import { Enum, EnumTypes } from '..';
02
03enum TypeNone { }
04export type None = { type: typeof TypeNone };
05function None<T>(d: T): None { return { type: TypeNone } };
06function isNone(x: any): x is None { return !!(x && x.type === TypeNone) };
07
08enum TypeSome { }
09export type Some<T> = { type: typeof TypeSome, data: [_: T] };
10function Some<T>(d: T): Some<T> { return { type: TypeSome, data: [d] } };
11export function isSome<T>(x: Option<T>): x is Some<T> { return !!(x && x.type === TypeSome) };
12
13export const Option = {
14  None, isNone, Some, isSome,
15  // 也可以这里补一个 unsafe_unwrap
16}
17
18export type Option<T> = ( // 注意要跟上面同名
19  | None
20  | Some<T>
21);

00// test.ts
01import { Option } from './option.enum';
02function handle(maybe: Option<number>) {
03  if (Option.isSome(maybe)) {
04    const [val] = maybe.data; // maybe is Some<number>
05    return;
06  }
07
08  maybe // ⬅️ is None
09}

00enum Option<T> {
01  None,
02  Some<T>
03}