精煉集合檢查器

集合 檢查器 可與 原語檢查器 結合，以精煉更複雜的值。

array()

根據類型為 Checker<T> 的值檢查器，驗證值為 $ReadOnlyArray<T>。

// define checker
const check = array(number());

// test a value
const result = check([1,2,3]);
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnlyArray<number> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check(['test', 'other']).type === 'failure');

tuple()

嚴格驗證值為已分型的序列。

// define checker
const check = tuple(number(), string(), bool());

// test a value
const result = check([1,'2', false]);
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnly<[number, string, boolean]> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check(['test', 'other']).type === 'failure');

dict()

根據類型為 Checker<T> 的值檢查器，驗證值為 $ReadOnly<{[key: string]: T}>。

// define checker
const check = dict(number());

// test a value
const result = check({a: 1, b: 2, c: 3});
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnly<{[key: string]: number}> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check({a: 'test', b: 'other', c: 3}).type === 'failure');

object()

根據類型為 {[key: K]: Checker<T>} 的檢查器物件，驗證值為 $ReadOnly<{[key: K]: T}>。

// define checker
const check = object({
  a: number(),
  b: string(),
  c: optional(string()) // use `optional` for optional properties
});

// test a value
const result = check({a: 1, b: 'test'});
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnly<{a: number, b: string}> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check({a: 'test', b: 1}).type === 'failure');
assert(check({a: 1, c: 'test'}).type === 'failure');

set()

檢查器用於聲明混合值是否為具有有效值的 Set 類型。

// define checker
const check = set(number());

// test a value
const result = check(new Set([1, 2]));
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnlySet<number> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check({a: 'test', b: 'other', c: 3}).type === 'failure');

map()

檢查器用於聲明混合值是否為 Map 類型且具備有效的鍵和值。

// define checker
const check = map(date(), number());

// test a value
const result = check(new Map([[new Date(), 1], [new Date(2), 2]]));
assert(result.type === 'success');

// result should typecheck
const value: $ReadOnlyMap<Date, number> = result.value;

// test an invalid value
assert(check('test').type === 'failure');
assert(check({a: 'test', b: 'other', c: 3}).type === 'failure');

writableArray()

與 array() 相同，但回傳類型為 Array<>，而非 $ReadOnlyArray<>

const coerce = writableArray(number());
const result = coerce([1, 2, 3]);

assert(result.type === 'success', 'should succeed');
result.value[0] = 3;

writableObject()

與 object 相同，但回傳類型為可寫入的物件，非 $ReadOnly<>

const coerce = writableObject({
  name: string(),
  job: object({
    years: number(),
    title: string(),
  }),
});

const result = coerce({name: 'Elsa', job: {title: 'Engineer', years: 3}});
assert(result.type === 'success', 'should succeed');

// should Flow check as writable
result.value.name = 'MechaElsa';

writableDict()

與 dict() 相同，但傳回的類型是可寫入物件，而非 $ReadOnly<>

const coerce = writableDict(number());
const result = coerce({a: 1, b: 2});
assert(result.type === 'success', 'should succeed');

// should Flow check as writable
result.value.a = 3;