anchor.diff:         # while
          compare "fooa" "a" => 1
     */
  -  splitByAndCompare = p: yes: no: a: b:
  +  splitByAndCompare =
  +    # Predicate
  +    p:
  +    # Comparison function if predicate holds for both values
  +    yes:
  +    # Comparison function if predicate holds for neither value
  +    no:
  +    # First value to compare
  +    a:
  +    # Second value to compare
  +    b:
       if p a
       then if p b then yes a b else -1
       else if p b then 1 else no a b;
   
   
  -  /* Reads a JSON file. */
  +  /* Reads a JSON file.
  +
  +     Type :: path -> any
  +  */
     importJSON = path:
       builtins.fromJSON (builtins.readFile path);
   
   
     ## Warnings
   
  -  /* See https://github.com/NixOS/nix/issues/749. Eventually we'd like these
  -     to expand to Nix builtins that carry metadata so that Nix can filter out
  -     the INFO messages without parsing the message string.
  -
  -     Usage:
  -     {
  -       foo = lib.warn "foo is deprecated" oldFoo;
  -     }
  -
  -     TODO: figure out a clever way to integrate location information from
  -     something like __unsafeGetAttrPos.
  -  */
  +  # See https://github.com/NixOS/nix/issues/749. Eventually we'd like these
  +  # to expand to Nix builtins that carry metadata so that Nix can filter out
  +  # the INFO messages without parsing the message string.
  +  #
  +  # Usage:
  +  # {
  +  #   foo = lib.warn "foo is deprecated" oldFoo;
  +  # }
  +  #
  +  # TODO: figure out a clever way to integrate location information from
  +  # something like __unsafeGetAttrPos.
  +
     warn = msg: builtins.trace "WARNING: ${msg}";
     info = msg: builtins.trace "INFO: ${msg}";
   
  
positive.code:      second subtype, compare elements of a single subtype with `yes`
       and `no` respectively.
  
       Example:
  
         let cmp = splitByAndCompare (hasPrefix "foo") compare compare; in
  
         cmp "a" "z" => -1
  
negative.code:   bitNot = builtins.sub (-1);
  
    /* Convert a boolean to a string.
  
       This function uses the strings "true" and "false" to represent
       boolean values. Calling `toString` on a bool instead returns "1"
       and "" (sic!).
  
       Type: boolToString :: bool -> string
    */
    boolToString = b: if b then "true" else "false";
  
    /* Merge two attribute sets shallowly, right side trumps left
  
       mergeAttrs :: attrs -> attrs -> attrs
  
       Example:
         mergeAttrs { a = 1; b = 2; } { b = 3; c = 4; }
         => { a = 1; b = 3; c = 4; }
    */
    mergeAttrs =
      # Left attribute set
      x:
      # Right attribute set (higher precedence for equal keys)
      y: x // y;
  
    /* Flip the order of the arguments of a binary function.
  
       Type: flip :: (a -> b -> c) -> (b -> a -> c)
  
       Example:
         flip concat [1] [2]
  