本文整理汇总了TypeScript中spica/sequence.Sequence类的典型用法代码示例。如果您正苦于以下问题：TypeScript Sequence类的具体用法？TypeScript Sequence怎么用？TypeScript Sequence使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Sequence类的9个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的TypeScript代码示例。
示例1: match
function match(pattern: string, segment: string): boolean {
const [p = '', ...ps] = [...pattern];
const [s = '', ...ss] = [...segment];
assert(typeof p === 'string');
assert(typeof s === 'string');
switch (p) {
case '':
return s === '';
case '?':
return s !== ''
&& s !== '/'
&& match(ps.join(''), ss.join(''));
case '*':
return s === '/'
? match(ps.join(''), segment)
: Sequence
.zip(
Sequence.cycle([ps.join('')]),
Sequence.from(segment)
.tails()
.map(ss => ss.join('')))
.filter(uncurry(match))
.take(1)
.extract()
.length > 0;
default:
return s === p
&& match(ps.join(''), ss.join(''));
}
}示例2: compare
export function compare(pattern: string, path: URL.Pathname<StandardURL>): boolean {
assert(path[0] === '/');
assert(!path.includes('?'));
const regSegment = /\/|[^/]+\/?/g;
const regTrailingSlash = /\/$/;
assert(expand(pattern).every(pat => pat.match(regSegment)!.join('') === pat));
return Sequence
.zip(
Sequence.from(expand(pattern)),
Sequence.cycle([path]))
.map(([pattern, path]) =>
[
pattern.match(regSegment) || [],
pattern.match(regTrailingSlash)
? path.match(regSegment) || []
: path.replace(regTrailingSlash, '').match(regSegment) || []
])
.filter(([ps, ss]) =>
ps.length <= ss.length &&
Sequence
.zip(
Sequence.from(ps),
Sequence.from(ss))
.dropWhile(uncurry(match))
.take(1)
.extract()
.length === 0)
.take(1)
.extract()
.length > 0;
}示例3:
.filter(([ps, ss]) =>
ps.length <= ss.length &&
Sequence
.zip(
Sequence.from(ps),
Sequence.from(ss))
.dropWhile(uncurry(match))
.take(1)
.extract()
.length === 0)示例4: match
function match(actualContentType: string | null, expectedContentType: string): boolean {
assert(actualContentType === null || actualContentType.split(':').length === 1);
return Sequence
.intersect(
Sequence.from(parse(actualContentType || '').sort()),
Sequence.from(parse(expectedContentType).sort()),
(a, b) => a.localeCompare(b))
.take(1)
.extract()
.length > 0;
function parse(headerValue: string): string[] {
return headerValue.split(/\s*;\s*/)
.filter(v => v.length > 0);
}
}示例5: it
it('char', () => {
assert(match('', ''));
assert(!match('', 'a'));
assert(match('a', 'a'));
assert(!match('a', 'A'));
assert(!match('A', 'a'));
Sequence.mappend(
Sequence.from(['a', 'b', 'c'])
.subsequences(),
Sequence.from(['a', 'b', 'c'])
.permutations())
.map(subs => subs.join(''))
.extract()
.forEach(subs =>
assert(match('abc', subs) === (subs === 'abc')));
});示例6: it
it('match', () => {
Sequence.from(['text/html', 'text/html'])
.mapM(type =>
Sequence.from([type, type + ';']))
.extract()
.forEach(([a, b]) =>
assert(match(a, b)));
Sequence.from(['text/plain', 'text/html'])
.permutations()
.bind(types =>
Sequence.from([types[0], types.join('; ')])
.permutations())
.extract()
.forEach(([a, b]) =>
assert(match(a, b)));
});示例7: return
return (url: string) => {
const { path, pathname } = new URL(standardize(url));
return Sequence.from(Object.keys(config).filter(([c]) => c === '/').sort().reverse())
.filter(flip(compare)(pathname))
.map(pattern => config[pattern])
.take(1)
.extract()
.pop()!
.call(config, path);
};示例8: expand
function expand(pattern: string): string[] {
if (pattern.match(/\*\*|[\[\]]/)) throw new Error(`Invalid pattern: ${pattern}`);
assert(pattern === '' || pattern.match(/{[^{}]*}|.[^{]*/g)!.join('') === pattern);
return pattern === ''
? [pattern]
: Sequence.from(pattern.match(/{[^{}]*}|.[^{]*/g)!)
.map(p =>
p.match(/^{[^{}]*}$/)
? p.slice(1, -1).split(',')
: [p])
.mapM(Sequence.from)
.map(ps => ps.join(''))
.bind(p =>
p === pattern
? Sequence.from([p])
: Sequence.from(expand(p)))
.unique()
.extract();
}示例9: scope
export function scope(
config: Config,
path: {
orig: URL.Pathname<StandardURL>;
dest: URL.Pathname<StandardURL>;
}
): Maybe<Config> {
const scope = { '/': {}, ...config.scope };
return Sequence.from(Object.keys(scope).sort().reverse())
.dropWhile(pattern =>
!! !compare(pattern, path.orig)
&& !compare(pattern, path.dest))
.take(1)
.filter(pattern =>
!! compare(pattern, path.orig)
&& compare(pattern, path.dest))
.map<Option | undefined>(pattern => scope[pattern])
.map<Maybe<Config>>(option =>
option
? Just(new Config(extend<Option>({}, config, option)))
: Nothing)
.extract()
.reduce((_, m) => m, Nothing);
}