(built, recognized) => isSome(recognized)
     ? luckFrom(
         take(
             built,
             recognized.some
         )
     )
     : fuckFrom([recognized.none]),

function readVerbosity(value: string): bt.Tried<Severity, string> {
    const normalized = value.toLowerCase();
    switch (normalized) {
        case 'debug': return bt.luckFrom(Severity.Debug);
        case 'info': return bt.luckFrom(Severity.Info);
        case 'warning': return bt.luckFrom(Severity.Warning);
        case 'error': return bt.luckFrom(Severity.Error);
        default: return bt.fuckFrom('Unexpected value \'' + value + '\' for a verbosity.');
    }
}

export function readFlag(value: string): Tried<boolean, string> {
    switch (value) {
        case 'true':
        case '1':
        case 'y':
            return luckFrom(true);
        case 'false':
        case '0':
        case 'n':
            return luckFrom(false);
        default:
            return fuckFrom('Unexpected value \'' + value + '\' of a flag argument.');
    }
}

export function readClusions(config: ClusionsConfig): Crooked<Clusions, string[]> {
    const include = config.include === undefined
        ? [fuckFrom('The \'include\' property of a file filter is unspecified.')]
        : readClusion(config.include);
    const exclude = config.exclude === undefined
        ? []
        : readClusion(config.exclude);

    const [included, notIncluded] = partitionAsOfTried(include);
    const [excluded, notExcluded] = partitionAsOfTried(exclude);
    return crookedFrom(
        clusionsFrom(included, excluded),
        ba.concat(
            ba.insteadEach(notIncluded, problem => 'Invalid include. ' + problem),
            ba.insteadEach(notExcluded, problem => 'Invalid exclude. ' + problem)
        )
    );
}

export function toRunners<Shared extends PerNodeShared & PerFileShared>(
    configs: Configs
): bt.Tried<bo.Optional<Runner<Shared>>[], string[]> {

    const all = [
        toRunner('bad-comment', configs, config => readFileFilterOptions(config), building().stateless(toBadComment).perNode().file().perFile(x => x).rule),
        toRunner('no-throw', configs, toEmptyOptions, building().stateless(toNoThrow).perNode().file().perFile(x => x).rule),

        toRunner(
            'no-export-import', configs, config => readFileFilterOptions(config),
            building().stateless(noExportImport).perNode().file().perFile(x => x).rule
        ),

        toRunner('no-primitive-to-self', configs, config => readFileFilterOptions(config), building().stateless(toNoPrimitiveToSelf).perNode().file().perFile(x => x).rule),
        toRunner('no-expressionless-return', configs, toEmptyOptions, building().stateless(toNoExpressionlessReturn).perNode().file().perFile(x => x).rule),
        toRunner('no-unnecessary-annotations', configs, toEmptyOptions, building().stateless(toNoUnnecessaryAnnotations).perNode().file().perFile(x => x).rule),
        toRunner('no-unnecessary-assertions', configs, toEmptyOptions, building().stateless(toNoUnnecessaryAssertions).perNode().file().perFile(x => x).rule),
        toRunner('names-stat', configs, config => {
            const ruleOptions = nameStat.toOptions(config);
            const fileOptions = readFileFilterOptions(config);
            const options = bothLucks(ruleOptions, fileOptions, fuse, concat);
            return options;
        }, building().stateful(nameStat.toRule()).perNode().file().perFile(x => x).rule),
        toRunner(
            'no-const-lambdas', configs, config => readFileFilterOptions(config),
            building().stateless(noConstLambdas).perNode().file().perFile(x => x).rule
        ),
        toRunner('banned-names', configs, toEmptyOptions, building().stateful(toBannedNames).perNode().file().perFile(x => x).rule),
        toRunner('no-symbol', configs, toEmptyOptions, building().stateless(toNoUndeclaredSymbols).perNode().file().perFile(x => x).rule),
        toRunner('const-needed', configs, config => readFileFilterOptions(config), building().stateful(toConstNeeded).perNode().file().perFile(x => x).rule)
    ];

    const [goods, bads] = partition(all);
    return bads.length > 0
        ? bt.fuckFrom(
            ba.concatAll(bads)
        )
        : bt.luckFrom(goods);
}

export function allOrNothing(crooked: Crooked<Clusions, string[]>): Tried<Clusions, string[]> {
    return crooked.fuck.length > 0 ? fuckFrom(crooked.fuck) : luckFrom(crooked.luck);
}

export function readRegexp(config: RegexpConfig): Tried<RegExp, string> {
    return config.pattern === undefined
        ? fuckFrom('The "pattern" property is missing in a regex configuration object.')
        : insteadFuck(toRegexp(config.pattern, config.flags), messageOf)
}

import * as ba from 'basic/array';
import * as br from 'basic/runtime';
import { partitionAsOfTried } from 'basic/tried-array';
import { messageOf } from 'basic/problem';
import { toRegexp } from "basic/text";
import { insteadFuck, fuckFrom, Tried, Crooked, luckFrom, insteadLuck, crookedFrom } from "basic/tried";

export interface RegexpConfig { pattern?: string, flags?: string }
export type ClusionConfig = string | (string | RegexpConfig)[] | RegexpConfig;

export const fuckingUnspecified = fuckFrom('Unspecified');

export function readRegexp(config: RegexpConfig): Tried<RegExp, string> {
    return config.pattern === undefined
        ? fuckFrom('The "pattern" property is missing in a regex configuration object.')
        : insteadFuck(toRegexp(config.pattern, config.flags), messageOf)
}

export function readClusion(config: ClusionConfig): Tried<RegExp, string>[] {
    if (br.isString(config)) {
        return [insteadFuck(toRegexp(config), messageOf)];
    } else if (br.isArray(config)) {
        return ba.insteadEach(
            ba.insteadEach(
                config,
                config => br.isString(config)
                    ? insteadFuck(toRegexp(config), messageOf)
                    : readRegexp(config)
            ),
            (tried, index) => insteadFuck(tried, fuck => 'At #' + index + ': ' + fuck)
        );

export function fail(code: ErrorCode, message: string): Fuck<Error> {
    debugger;
    return fuckFrom(errorFrom(code, message));
}

export function toOptions(config: {}): Tried<Options, string[]> {
    return isOptions(config) ? luckFrom(config) : fuckFrom(['Invalid config.']);
}