added more doc comments to interface files

Author: woeps

lib/Fabricators.rei

@@ -1 +1,6 @@
+/** Built-in Fabricators
+ *  See Types module for explanation on the namings and types.
+ */
+
 let md: Types.fabricator(string);
+/** Load Markdown files from a specified (relative) path */

lib/Factories.rei

@@ -1 +1,4 @@
+/** Built-in Factories
+ *  See Types module for explanation on the namings and types.
+ */
 let log: Types.factory(unit);

lib/Fs.rei

@@ -1,7 +1,13 @@
+/** Utility Functions for the filesystem */
+
 let readFiles: string => list(string);
+/** Get a list of all files (absolute path) in a given relative path */
 
 let filterMd: list(string) => list(string);
+/** Get only Markdown files from a list of files */
 
 let file2string: string => string;
+/** Read a file (absolute path) in as a string */
 
-let writeFile: (string, string) => unit;
+let writeFile: (/*path*/ string, /*content*/ string) => unit;
+/** Write a string into a file at the specified path */

lib/Md.rei

@@ -1 +1,4 @@
+/** Utility Functions for Markdown files */
+
 let string2html: string => string;
+/** Parse string as markdown into string of html */

lib/Print.rei

@@ -1,3 +1,5 @@
+/** Utility Functions to write to the stdout */
+
 let info: string => unit;
 let success: string => unit;
 let error: string => unit;

lib/Refabricators.rei

@@ -1 +1,4 @@
+/** Built-in Refabricators
+ *  See Types module for explanation on the namings and types.
+ */
 let between: Types.refabricator((string, string));

lib/Types.re

@@ -1,9 +1,51 @@
+/** Common Types of the Refabricator Library
+ *
+ *  - Fabrics consist of a name and the actual content
+ *  - a fabric is a function taking a unit and returning a name and the actual content
+ *  - a fabricator is "generator" of fabrics
+ *  - a refabricator manipulates the result of a fabric
+ *  - a factory produces the SSG's output based on fabrics and their manipulations of refabricators
+ *  - an appliedFactory is an already configure factory which takes fabrics and processes them
+ */
+
 type name = string;
+/** Name of the result of a fabric */
+
 type content = string;
+/** Content of the result of a fabric */
+
 type t = (name, content);
+/** Result of a fabric */
+
 type fabric = unit => t;
+/** A fabric is a generator function for a source.
+ *  The function can be called later on to actually fetch sources
+ *  aka "lazyly loaded source"
+ */
+
 type fabrics = list(fabric);
+/** Multiple fabrics
+ *  aka "multiple lazyly loaded sources"
+ */
+
 type fabricator('a) = 'a => fabrics;
+/** Constructor of multple fabrics.
+ *  Each concrete type of fabricator has it's own set of arguments.
+ *  aka "loader of fabrics"
+ */
+
 type refabricator('a) = ('a, fabrics) => fabrics;
+/** Manipulates fabrics
+ *  Each concrete type of refabricator has it's own set of arguments
+ *  aka "rewriter of source's content"
+ */
+
 type factory('a) = ('a, fabrics) => result(unit, string);
+/** Construct an `appliedFactory`, which will process fabrics (e.g. write them to file)
+ *  aka "Processor of fetched & manipulated content"
+ */
+
 type appliedFactory = fabrics => result(unit, string);
+/** Construct an `appliedFactory`, which will process fabrics (e.g. write them to file)
+ *  aka "Processor of fetched & manipulated content"
+ */

lib/Util.re

@@ -1,6 +1,6 @@
 let concat = fabrics => List.concat(fabrics);
 
-let rename = (name, (_oldName, content)) => (name, content);
+let rename = (rename, (name, content)) => (name |> rename, content);
 
 let modify =
   (modify, (name, content)) => (name, modify(content));

lib/Util.rei

@@ -1,5 +1,10 @@
+/** Uility Functions for fabrics */
+
 let concat: list(Types.fabrics) => Types.fabrics;
+/** Combine a list of several `fabrics` into a single `fabrics`. */
 
-let rename: (string, Types.t) => Types.t;
+let rename: (string => string, Types.t) => Types.t;
+/** Rename the result of a fabric */
 
 let modify: (string => string, Types.t) => Types.t;
+/** Modify the content of a fabric */