function lint(
        projectFile: string,
        shared: Shared,
        configuration: Configs
    ): OneOfThree<Issue[], ts.Diagnostic[], Line<Severity>[]> {

        const runners = toRunners(configuration);
        if (bt.isLuck(runners)) {
            const [configured, unconfigured] = partition<bm.Some<Runner<Shared>>, bm.None>(runners.luck, bm.isSome);
            if (configured.length > 0) {
                const linted = run(
                    projectFile,
                    shared,
                    insteadEach(configured, bm.someOf)
                );
                if (bt.isLuck(linted)) {
                    return firstFrom(linted.luck);
                } else {
                    return secondFrom(linted.fuck);
                }
            } else {
                return thirdFrom(
                    fold(
                        unconfigured,
                        [lineFrom(Severity.Info, 'There are no available rules.')],
                        (result, unconfigured) => append(result, lineFrom(Severity.Info, unconfigured.none))
                    )
                );
            }
        } else {
            return thirdFrom(
                fold(
                    runners.fuck,
                    [lineFrom(Severity.Error, 'Unable to get runners ready.')],
                    (result, failure) => append(result, lineFrom(Severity.Error, failure))
                )
            );
        }
    }

function run(args: string): void {
    const optionsTried = readOptions(args);
    const { log, dump } = toBeingStandardConsoleLogging(Severity.Info);
    if (bt.isLuck(optionsTried)) {
        const options = optionsTried.luck;
        log(Severity.Info, 'Reading configuration from: ' + options.configFile);
        const configuration = loadConfigs(options.configFile);
        if (bt.isLuck(configuration)) {
            const beingLogging = toBeingStandardConsoleLogging(options.verbosity);
            const beingOpening = toBeingOpening(
                beingLogging,
                toBeingConfiguring(ts.sys.readFile, ts.sys, beingLogging)
            );
            const pivotDirPath = process.cwd(); // TODO: consider allowing a parameter
            const beingTypeScriptFormatting = toBeingTypeScriptFormatting(filePath => toRelativeTo(filePath, pivotDirPath));
            const beingLintingFormatting = toBeingLintingFormatting(beingTypeScriptFormatting);
            const shared = toShared();
            const { lint, dumpDiagnostics, dumpIssues } = toBeingLinting(beingLogging, beingOpening, toRunners, beingTypeScriptFormatting, beingLintingFormatting);
            const output = lint(options.project, shared, configuration.luck);
            if (bf.isFirst(output)) {
                dumpIssues(output.first, options.maxNumberOfIssues);
            } else if (bf.isSecond(output)) {
                dumpDiagnostics(output.second, options.maxNumberOfDiagnostics);
            } else {
                ba.forEach(
                    output.third,
                    line => log(line.severity, line.message)
                );
            }
        } else {
            log(Severity.Error, 'Unable to load the configuration of the rules. ' + configuration.fuck.message);
        }
    } else {
        const problems = optionsTried.fuck;
        log(Severity.Info, 'Unable to start the linter.');
        dump(Severity.Info, problems, bb.same);
    }
}

export function betterBeNoIssues<r>(tried: TriedCompiling, haveCompiled: (compiled: Compiled) => r): r {

    if (bt.isLuck(tried)) {
        return haveCompiled(tried.luck);
    } else {

        const issues = ba.fromList(tried.fuck);
        ba.forEach(issues, issue => {
            console.warn(formatDiagnostic(issue));
        });

        return bb.fail('Stopped due to detected issues.');
    }
}

export function read<Parsing, Parsed>(
    value: string,
    parsing: Parsing,
    builder: Builder<Parsing>,
    asParsed: (parsing: Parsing) => Optional<Parsed>
): Tried<Parsed, Error> {
    const stand = standFrom(mightNeedCommandOrParameter, []);
    const started = keepReading(parsing, value, 0, stand, builder);
    if (isLuck(started)) {
        const finished = finishReading(started.luck.result, started.luck.stand, builder)
        if (isLuck(finished)) {
            const parsed = asParsed(finished.luck);
            if (isSome(parsed)) {
                return luckFrom(parsed.some);
            } else {
                return toFailedToFindBuilderInParameterState();
            }
        } else {
            return finished;
        }
    } else {
        return started;
    }
}

 dare(failure: string, format: (fail: b) => string): a {
     return isLuck(this.value) ? this.value.luck : fail(failure + ' ' + format(this.value.fuck));
 }