generate (helpers: unknown) {
        const self = this;
        const tasks: Task<unknown, NodeJS.ErrnoException | UnknownError>[] = [];

        if (self.generatorSettings.copyAssets) {
            tasks.push(self.copyAssets());
        }

        // TODO: Remove the files settings, probably walk the dir for .tpl files
        for (let i = 0; i < self.generatorSettings.files.length; i++) {
            // Create the object in charge of rendering the html
            const renderObject = new HtmlWriterFile({
                inputFile: self.generatorSettings.files[i] + '.tpl',
                outputFile: self.generatorSettings.outputDir + '/' + self.generatorSettings.files[i] + '.html',
                renderer: self.renderer
            });

            // ...
            renderObject.setHelpers(helpers);

            // Generate the html
            tasks.push(renderObject.render());
        }

        return Task.all(tasks);
    }

    generate () {
        const self = this;
        const tasks: ReturnType<typeof writeFileCreateDir>[] = [];

        self.metadata.renderedFragments = {};

        // For each markdown, create the html fragment
        for (const mdTemplate in self.metadata.jsonml) {
            try {
                const tree = markdown.toHTMLTree(self.metadata.jsonml[mdTemplate]);
                const html = markdown.renderJsonML(tree);

                const outputFilename = self.generatorSettings.outputDir + '/' + mdTemplate + '.html';
                // mhmhmh TODO: This is sooo hardcoded
                self.metadata.renderedFragments[mdTemplate] = 'fragment/' + mdTemplate + '.html';

                tasks.push(writeFileCreateDir(outputFilename, html));

            } catch (e) {
                // TODO: Catch this better
                console.log(red('Problem with ') + mdTemplate);
                throw e;
            }
        }

        return Task.all(tasks);
    }

 render () {
     const self = this;
     return Task.resolve(this)
         .map(({inputFile, helpers}) => this.renderer.render(inputFile, {mddoc: helpers}))
         .chain(html => writeFileCreateDir(self.outputFile, html))
         .map(tap(_ => console.log(green('We wrote ') + grey(self.outputFile))));
 }

 .catch(err => {
     if (err.code === 'ENOENT') {
         return mkdir(path);
     } else {
         return Task.reject(err);
     }
 });

 const loop = (index: number) => (curr: A): Task<A, E | UnknownError> => {
     if (index >= items.length) {
         return Task.resolve(curr);
     } else {
         return taskReducer(curr, items[index])
             .chain(loop(index + 1));
     }
 };

 return function (stat: fs.Stats) {
     // If its not a directory, resolve it on the spot with the name of the file
     if (!stat.isDirectory()) {
         return Task.resolve([filename]);
     }
     // If it is, resolve it once its subdirectory is resolved
     else {
         return doWalkDir(filename, options);
     }
 };

export function sequence<E1> (steps: Step<E1>[]): Task<void, E1> {
    // clone the steps
    const newSteps = [...steps] as [Step<any>];
    // Remove the next step from the array
    const nextStep = newSteps.shift();
    // If there are any left, resolve inmediatly
    if (!nextStep) {
        return Task.resolve(void 0);
    } else {
        // If there is a step invoke it
        return nextStep().chain(
            () => sequence(newSteps)
        );
    }
}

export function traverseDictionary<T, E> (objOfTasks: Dictionary<Task<T, E>>): Task<Dictionary<T>, UnknownError | E> {
    // Create an array of task with a tuple containing the key and the value
    const tasks =
        Object.keys(objOfTasks)
            .map(key => objOfTasks[key]
                        .map(value => ({key, value}))
            );
    // Wait until all tasks are resolved
    return Task.all(tasks)
                // And transform the array back into an object
                .map(pairs => {
                    const ans: Dictionary<T> = {};
                    pairs.forEach(({key, value}) => ans[key] = value);
                    return ans;
                });
}

        .chain(function (files) {
            const promises: ReturnType<typeof copyFile>[] = [];

            for (let i = 0; i < files.length; i++) {
                const m = files[i].match(matchRe);
                if (m) {
                    const inputFilename = files[i];
                    const outputFilename = dst + '/' + files[i].substr(dirNameLength + 1);
                    // console.log(inputFilename.grey + " => ".green + outputFilename.grey);

                    // Copy the file
                    promises.push(copyFile(inputFilename, outputFilename));
                }
            }
            return Task.all(promises);
        });