Bits: C++ Generics

/*---------------------------------------------------------
  Cpp_Generics.cpp
  - demonstrates creating and using std::library generic 
    types: array, basic_string, vector, and map
  - demonstrates creating and using user-defined generic 
    types: HelloTemplates, Stats, and Point
  - depends on HelloTemplates.h to provide user-defined 
    HelloTemplates class
  - depends on Stats.h to provide user-defined Stats class
  - depends on PointsGen.h to provide user-defined point
    class
  - depends on Analysis.h for several display and analysis
    functions
  */
  /*-----------------------------------------------
  Note:
  Find all Bits code, including this in
  https://github.com/JimFawcett/Bits
  You can clone the repo from this link.
  -----------------------------------------------*/

  #include <iostream>       // std::cout
  #include <memory>         // std::unique_ptr
  #include <vector>         // vector<T> class
  #include <array>          // array<T> class
  #include <map>            // map<K,V> class
  #include <unordered_map>  // unordered_map<k,V> class
  #include <set>            // set<T> class
  #include <thread>         // this_thread
  #include "AnalysisGen.h"  // Analysis functions
  #include "HelloTemplates.h"        // Stats class declaration
  #include "Stats.h"
  #include "PointsGen.h"    // Point<T, N> class declaration

  using namespace Analysis;
  using namespace Points;


  /*-----------------------------------------------
  Overload operator<< for std::vector,
  required for demo_std_generic_types()
  and testformats()
  */
  template<typename T>
  std::ostream& operator<<(std::ostream& out, std::vector<T>& v) {
  out << format(v, "vector<T>", "", DisplayParams.left, DisplayParams.width);
  return out;
  }

  /*-----------------------------------------------
  demonstrate use of std generic types
  */
  void demo_std_generic_types() {
  /* code elided */
  }

  /*-----------------------------------------------
  demonstrate use of generic functions
  */
  void demo_generic_functions() {
  /* code elided */
  }

  int main() {

  showNote("Demonstrate C++ Generics", 30, nl);

  demo_std_generic_types();
  demo_custom_type_HelloTemplates();
  demo_custom_type_Stats();
  demo_custom_type_Point();
  demo_generic_functions();

  testtime();

  for(size_t i=0; i<4; ++i) {
  testtimer();
  std::this_thread::sleep_for(std::chrono::seconds(1));
  }

  print("\n  That's all Folks!\n\n");
  }

/*-------------------------------------------------------------------*/
void demo_std_generic_types() {

  showNote("Demo std generic types", nl);
  showOp("array<int,4>",nl);
  auto a = std::array<int, 4> { 1, 2, 3, 4 };
  showArray(a);     // works only for arrays
  showSeqColl(a);   // works for any sequential collection

  showOp("vector<double>", nl);
  std::vector<double> v = { 1.0, 1.5, 2.0, 2.5 };
  std::cout << v << "\n"; // uses operator<< overload for vectors, above
  showSeqColl(v);         // any sequential collection
  std::cout << formatColl(v, "v", "\n"); // any STL collection

  showOp("std::map<string,int>", nl);
  std::map<std::string, int> m {
    {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3}
  };
  std::cout << formatColl(m, "m", "\n"); // any STL collection
  showAssocColl(m);  // coll elements must be std::pair<K,V>

  showOp("std::unordered_map<string,int>", nl);
  std::unordered_map<std::string, int> um {
    {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3}
  };
  std::cout << formatColl(um, "um", "\n"); // any STL collection
  showAssocColl(um);  // coll elements must be std::pair<K,V>
}

/*-------------------------------------------------------------------
  HelloTemplates.h defines HelloTemplates<T> class
  - HelloTemplates<T> is a simple demonstration of a template
    type that does'nt do anything very useful except to explain
    syntax.
*/
/*-------------------------------------------------------------------
  simple user-defined type to demonstrate template syntax
*/
#include "AnalysisGen.h"
using namespace Analysis;

template<typename T>
class HelloTemplates {
public:
  HelloTemplates() = default;
  HelloTemplates(T& tin) : t(tin) {};
  HelloTemplates(const HelloTemplates<T>& t) = default;
  HelloTemplates<T>& operator=(const HelloTemplates<T>&t) = default;
  ~HelloTemplates() = default;
  T& value() { return t; }
  void show();
private:
  T t;
};

template<typename T>
void HelloTemplates<T>::show() {
  std::cout << "  HelloTemplates<T> {\n  ";
  std::cout << "  type T: "
            << truncate(DisplayParams.trunc,typeid(t).name());  // show type
  std::cout << ", size: " << sizeof(t);  // show size on stack
  std::cout << ", value: " << t;
  std::cout << "\n  }\n";
}
/* template method specialization */
template<>
void HelloTemplates<std::vector<int>>::show() {
  std::cout << "  HelloTemplates<T> {\n  ";
  std::cout << "  type T: "
            << truncate(DisplayParams.trunc,typeid(t).name());  // show type
  std::cout << ", size: " << sizeof(t) << "\n    value: [ ";
  for (auto item : t) {
    std::cout << item << " ";
  };
  std::cout << "]\n  }\n";
}
/* partial template specialization of HelloTemplates class */
template<template<typename> typename V, typename T>
class HelloTemplates<V<T>> {
  HelloTemplates<V<T>>& operator=(const HelloTemplates<V<T>>& v) = default;
  ~HelloTemplates() = default;
  V<T>& value() { return val; }
  void show() {
    std::cout << "  HelloTemplates<V<T>> {\n  ";
    std::cout << "  type V<T>: "
              << truncate(DisplayParams.trunc,typeid(val).name());  // show type
    std::cout << ", size: " << sizeof(val) << "\n    value: [ ";
    for (auto item : val) {
      std::cout << item << " ";
    };
    std::cout << "]\n  }\n";
  }
private:
  V<T> val;
};

/*-- demonstrate creation and use of HelloTemplates<T> --*/
void demo_custom_type_HelloTemplates() {

  println();
  showNote("Demo user-defined HelloTemplates<T>", 40);

  showOp("HelloTemplates<T>", nl);
  int arg = 42;
  HelloTemplates<int> demi(arg);
  demi.show();
  std::cout << std::endl;;

  double pi = 3.1415927;
  HelloTemplates<double> demd(pi);
  demd.show();

  /*-------------------------------------------------------
    specialization defined in HelloTemplates<T> class header
    HelloTemplates.h and used here
  */
  auto vs = std::vector<int> { 1, 2, 3 };
  HelloTemplates<std::vector<int>> demv(vs);
  demv.show();
}

/*-------------------------------------------------------------------
  Stats<T>
  - Stats<T> holds a std::vector<T> and provides methods for
    computing max, min, average of this collection
    of unspecified type T
  - Code builds as a template definition
  - Will fail to build instantiation if T is not a numeric type
*/
#include <iostream>
#include <vector>
#include <exception>
#include <concepts>
#include "AnalysisGen.h"
using namespace Analysis;

/*-------------------------------------------------------------------
  Stats<T> class provides several simple computational services on
  a vector of items who's type provides required arithmetic operations.
  - This class inhibits compiler generation of default constructor
    and assignment operator.
*/

template <typename T>
  concept Number = std::integral<T> || std::floating_point<T>;

template <typename T>
   requires Number<T>
class Stats {
public:
    Stats() = default;
    Stats(const std::vector<T>& v);
    Stats(const Stats<T>& s) = default;
    Stats<T>& operator=(Stats<T>& s) = default;
    size_t size();
    T max();
    T min();
    T sum();
    double avg();
    void show(const std::string& name="");
private:
    bool check();
    const std::vector<T>& items;
};
/*-------------------------------------------------------------------
  Constructor initialized with vector of values
*/
template<typename T>
   requires Number<T>
Stats<T>::Stats(const std::vector<T>& v) : items(v) {}

/*-------------------------------------------------------------------
  check that Stats instance contains at least one value
*/
template<typename T>
   requires Number<T>
bool Stats<T>::check() {
    return items.size() > 0;
}
/*-------------------------------------------------------------------
  returns number of data items
*/
template<typename T>
   requires Number<T>
size_t Stats<T>::size() {
    if(!check()) {
        throw "Stats is empty";
    }
    return items.size();
}
/*-------------------------------------------------------------------
  returns largest value (not necessarily largerst magnitude)
*/
template<typename T>
   requires Number<T>
T Stats<T>::max() {
    if(!check()) {
        throw "Stats is empty";
    }
    auto max = items[0];
    for( auto item : items) {
        if (item > max) {
            max = item;
        }
    }
    return max;
}
/*-------------------------------------------------------------------
  returns smallest value (not necessarily smallest magnitude)
*/
template<typename T>
   requires Number<T>
T Stats<T>::min() {
    if(!check()) {
        throw "Stats is empty";
    }
    auto min = items[0];
    for( auto item : items) {
        if (item < min) {
            min = item;
        }
    }
    return min;
}
/*-------------------------------------------------------------------
  returns sum of data values
*/
template<typename T>
   requires Number<T>
T Stats<T>::sum() {
    if(!check()) {
        throw "Stats is empty";
    }
    auto sum = T{0};
    for( auto item : items) {
        sum += item;
    }
    return sum;
}
/*-------------------------------------------------------------------
  returns average of data values
*/
template<typename T>
   requires Number<T>
double Stats<T>::avg() {
    if(!check()) {
        throw "Stats is empty";
    }
    auto sum = T{0};
    for( auto item : items) {
        sum += item;
    }
    return double(sum)/double(items.size());
}
/*-------------------------------------------------------------------
  displays current contents
*/
template<typename T>
   requires Number<T>
void Stats<T>::show(const std::string& name) {
    if(!check()) {
        throw "Stats is empty";
    }
    std::cout << "\n  " << name << " {\n    ";
    auto iter = items.begin();
    std::cout << *iter++;
    while(iter != items.end()) {
        std::cout << ", " << *iter++;
        std::cout.flush();
    }
    std::cout << "\n  }\n";
}
                  

/*-- demonstrate custom type Stats<T> --*/

void demo_custom_type_Stats() {

  println();
  showNote("Demo user-defined Stats<T>", 35);

  showOp("Stats<double> s(v)", nl);
  std::vector<double> v { 1.0, 2.5, -3.0, 4.5 };
  showSeqColl(v);
  Stats<double> s(v);
  std::cout << "  min: " << s.min();
  std::cout << ", max: " << s.max();
  std::cout << ", sum: " << s.sum();
  std::cout << ", avg: " << s.avg() << std::endl;

  showOp("Stats<double> s2 = s", nl);
  Stats<double> s2 = s;  // copy construction
  std::cout << "  min: " << s2.min();
  std::cout << ", max: " << s2.max();
  std::cout << ", sum: " << s2.sum();
  std::cout << ", avg: " << s2.avg() << std::endl;

  showOp("Stats<int> s3(u)", nl);
  std::vector<int> u { 1, 2, 3, 1 };
  showSeqColl(u);
  Stats<int> s3(u);
  std::cout << "  min: " << s3.min();
  std::cout << ", max: " << s3.max();
  std::cout << ", sum: " << s3.sum();
  std::cout << ", avg: " << s3.avg() << std::endl;

  /*--------------------------------------------------
  This works without the Number concept, with the
  exception of average. With concept the stats
  library fails to compile because strings are
  not ints or floats.
  */
  // showOp("Stats<std::string> ss", nl);
  // std::vector<std::string> vstr { "ab", "cd", "ef" };
  // Stats<std::string> ss(vstr);
  // std::cout << "  min: " << ss.min();
  // std::cout << ", max: " << ss.max();
  // std::cout << ", sum: " << ss.sum();
  //--------------------------------------------------
  // first compile phase:
  //   Stats<T>::avg() passess
  // second compile phase:
  //   Stats<std::string>::avg() fails to compile.
  //   No way to divide sum string by size integer in
  //   std::cout << ", avg: " << ss.avg() << std::endl;
  //   All the other methods compile successfully.

  println();
}

/*-------------------------------------------------------------------
  PointsGen.h defines point classe Point<T, N>
  - Point<T, N> represents points with N coordinates of
    unspecified type T and a Time t.
*/
#include <iostream>
#include <vector>
#include <string>
#include <initializer_list>
#include <concepts>
#include "AnalysisGen.h"
#include "Time.h"

namespace Points {

  //using namespace Analysis;

  /*-------------------------------------------------------------------
    Point<T, N> class represents a point in an N-Dimensional hyperspace.
    It uses a template parameter to support a variety of coordinate
    types, and uses a vector to hold any finite number of
    coordinates, specified by N.

    It also carries a Time t instance which conceptually is the time
    at which something was at that point in space. Time is a class
    defined for this demonstration in Time.h.

    All its special members, ctors, assignment, ... with the exception
    of constructor Point(), are declared default to indicate to a maintainer
    that compiler generated methods are correct and should not be provided.

    It does not provide an iterator nor begin() and end() members.
    Those will added in the iteration bit.
  */
  template<typename T, const size_t N>
  class Point {
  public:
    Point();                                      // default ctor
    Point(std::initializer_list<T> il);           // construct from list
    Point(const Point& pt) = default;             // copy ctor
    Point(Point&& pt) = default;                  // move ctor
    Point& operator=(const Point& pt) = default;  // copy assignment
    Point& operator=(Point&& pt) = default;       // move assignemnt
    ~Point() = default;                           // dtor

    void init(const std::vector<T>& v);

    std::string timeToString();
    void updateTime();
    Time& time();
    const size_t size() const;
    T& operator[](size_t index);                  // index oper
    const T operator[](size_t index) const;       // const index oper

    std::vector<T>& coords() { return coord; }    // accessor

    void show(const std::string& name);           // display contents
    size_t& left() { return _left; }              // display indent
    size_t& width() { return _width; }            // display width
  private:
    std::vector<T> coord;
    Time tm;
    size_t _left = 2;   // default display indent
    size_t _width = 7;  // default display row width
  };
  /*-----------------------------------------------
    Point<T, N> constructor with size Template
    parameter
  */
  template<typename T, size_t N>
  Point<T, N>::Point()
    : tm(Time()) {
    for(size_t i=0; i<N; i++) {
      coord.push_back(T{0});
    }
  }
  /*-----------------------------------------------
    Fill coor with elements from initializer list li
    - if li is smaller than N then fill remainder with
      default values of T
    - if li is larger use first N elements of li
  */
  template<typename T, size_t N>
  Point<T, N>::Point(std::initializer_list<T> il)
    : tm(Time()) {
    size_t sz = std::min(N, il.size());
    size_t i = 0;
    for(auto item : il) {
      coord.push_back(item);
      if(++i == sz) {
        break;
      }
    }
    for(size_t i = il.size(); i<N; i++) {
      coord.push_back(T{0});
    }
  }
  /*---------------------------------------------
    Always returns N
  */
  template<typename T, size_t N>
  const size_t Point<T, N>::size() const {
    return coord.size();
  }
  /*---------------------------------------------
    index returns mutable value
  */
  template<typename T, size_t N>
  T& Point<T, N>::operator[](size_t index) {
    if (index < 0 || coord.size() <= index) {
      throw "Point<T, N> indexing error";
    }
    return coord[index];
  }
  /*---------------------------------------------
    index returns immutable value
  */
  template<typename T, size_t N>
  const T Point<T, N>::operator[](size_t index) const {
    if (index < 0 || coord.len() <= index) {
      throw "Point<T, N> indexing error";
    }
    return coord[index];
  }
  /*-----------------------------------------------
    Fill coor with elements from vector v
    - if v is smaller fill remainder with default
      values of T
    - if v is larger use first N elements of v
  */
  template<typename T, size_t N>
  void Point<T, N>::init(const std::vector<T>& v) {
    size_t sz = std::min(N, v.size());
    for(size_t i=0; i<sz; i++) {
      coord[i] = v[i];
    }
    for(size_t i = v.size(); i<N; i++) {
      coord[i] = T{0};
    }
  }
  /*---------------------------------------------
    returns string datetime
  */
  template<typename T, size_t N>
  std::string Point<T, N>::timeToString() {
    std::string ts = tm.toString();
    return ts;
  }
  /*---------------------------------------------
    set time to current time
  */
  template<typename T, size_t N>
  void Point<T, N>::updateTime() {
    tm = std::time(0);
  }
  /*---------------------------------------------
    returns current number of seconds in clock's
    epoch
  */
  template<typename T, size_t N>
  Time& Point<T, N>::time() {
    return tm;
  }
  /*-----------------------------------------------
    PointtN<T> display function
  */
  template<typename T, size_t N>
  void Point<T, N>::show(const std::string& name) {
    std::cout << "\n" << indent(_left) << name << ": " << "Point<T, N>";
    std::cout << " {\n";
    std::cout << fold(coord, _left + 2, _width);
    std::cout << indent(_left) << "}";
    std::cout << "\n" << indent(_left) << tm.toString() << std::endl;
  }
  /*-----------------------------------------------
    Overload operator<< required for
    showType(Point<T, N> t, const std::string& nm)
  */
  template<typename T, size_t N>
  std::ostream& operator<<(std::ostream& out, Point<T, N>& t2) {
    out << "\n" << indent(t2.left()) << "Point<T, N>";
    out << " {\n";
    out << fold(t2.coords(), t2.left() + 2, t2.width());
    out << indent(t2.left()) << "}";
    return out;
  }
}

/*-- demonstrate use of Point type --*/

void demo_custom_type_Point() {
  using namespace Analysis;
  using namespace Points;

  println();
  showNote("Demo user-defined Point<T, N>", 40);

  /*-- demonstrate Point<double 3> initialization lists --*/
  showOp("Point<double, 3> p1 {1.0, 1.5, 2.0}");  // equal to N
  Point<double, 3> p1 {1.0, 1.5, 2.0};
  p1.show("p1");
  std::cout << "\n  p1[1] = " << p1[1];           // indexing
  std::cout << "\n  p1.time().day() = "
            << p1.time().day();
  std::cout << "\n  p1.time().seconds() = "
            << p1.time().seconds() << "\n";
  showOp("Point<double, 3> p2 {1.0, 1.5}");
  Point<double, 3> p2 {1.0, 1.5};                 // less than N
  p2.show("p2");
  showOp("Point<double, 3> p3 {1.0, 1.5, 2.0, 2.5}");
  Point<double, 3> p3 {1.0, 1.5, 2.0, 2.5};       // greater than N
  p3.show("p3");
  std::cout << "\n  p3.timeToString():\n    \""
            << p3.timeToString() << "\"\n";
  showOp("Point<int, 10> p3 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }");
  Point<int, 10> p4 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  p4.show("p4");
}

/*---------------------------------------------------------
  Generic Function Definitions
*/
/*---------------------------------------------------------
  showType(T t, ...)
    - Display calling name, static class, and size
    - requires DisplayParams
*/
template<typename T>
void showType(T t, const std::string &callname, const std::string& suffix) {
  std::cout << "\n  " << callname;          // show name at call site
  std::cout << " type: "
            << truncate(DisplayParams.trunc,typeid(t).name());  // show type
  std::cout << "\n  size:  " << sizeof(t);  // show size on stack
  std::cout << suffix;
}
/*-------------------------------------------------------
  show sequential collection
  - requires integer indexer and size() function
  - works for any sequential STL collection
*/
template<typename C>
void showSeqColl(const C& c) {
  std::cout << "  Collection<T> [";
  std::cout << c[0];
  for(size_t i=1; i<c.size(); ++i) {
    std::cout << ", " << c[i];
  }
  std::cout << "]" << std::endl;
}
/*-------------------------------------------------------
  show associative collection
  - requires iterator
  - elements must be std::pair<Key, Value>
  - works for any associative STL collection
*/
template<typename C>
void showAssocColl(const C& c) {
  std::cout << "  Collection<K,V> {\n    ";
  bool first = true;
  for(const auto& pair : c) {
    if(first) {
      std::cout << "{" << pair.first << ", " << pair.second << "}";
      first = false;
    }
    else {
      std::cout << ", {" << pair.first << ", " << pair.second << "}";
    }
  }
  std::cout << "\n  }\n";
}

/*-----------------------------------------------
  Helper function for formatting output
  - truncates line to N chars and adds ellipsis
*/
inline std::string truncate(size_t N, const char* pStr) {
  std::string temp(pStr);
  if(temp.length() > N) {
    temp.resize(N);
    return temp + "...";
  }
  return temp;
}
/*-----------------------------------------------
  Helper function for formatting output
  - generates string of n blanks to offset text
*/
inline std::string indent(size_t n) {
  return std::string(n, ' ');
}
/*-----------------------------------------------
  Helper function for formatting output
  - folds lines after width elements
  - used only in Point<T,N>::show()
*/
template<typename T>
std::string fold(std::vector<T>& v, size_t left, size_t width) {
  std::stringstream out("\n");
  out << indent(left);
  for(size_t i=0; i<v.size(); ++i) {
    if((i % width) == 0 && i != 0 && i != width - 1) {
      out << "\n" << indent(left);
    }
    if(i < v.size() - 1) {
      out << v[i] << ", ";
    }
    else {
      out << v[i] << "\n";
      break;
    }
  }
  return out.str();
}
/*-----------------------------------------------
  Helper function for formatColl
  - defines out << std::pair<K,V>
  - used in formatColl for associative containers
*/
template<typename K, typename V>
std::stringstream& operator<<(
  std::stringstream& out, const std::pair<K,V>& p
) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}
/*-----------------------------------------------
  Format output for Collection types
  - any type with iterator, begin(), and end()
    like all the STL containers.
  - elements need overload for operator<< as
    implemented above
  - folds into rows with width elements
    - will replace folding logic with fold(...)
      eventually
*/
template<typename Coll>
std::string formatColl(
  const Coll& c, const std::string& nm, const std::string& suffix,
  size_t left, size_t width
) {
  std::stringstream out;
  out << indent(left) << nm << ": {\n" << indent(left + 2);
  size_t i = 0;
  for(const Coll::value_type& elem : c) {
    if((i % width) == 0 && i != 0 && i != width - 1) {
      out << "\n" << indent(left + 2);
    }
    if(i < c.size() - 1) {
      out << elem << ", ";
    }
    else {
      out << elem << "\n" << indent(left) << "}" << suffix;
      break;
    }
    ++i;
  }
  return out.str();
}
/*-----------------------------------------------
  Format output for scalar types like primitives
*/
template<typename T>
std::string formatScalar(
  const T& t, const std::string& nm, const std::string& suffix,
  size_t left
) {
  std::stringstream out;
  out << "\n" << indent(left) << nm << ": " << t << suffix;
  return out.str();
}
/*-----------------------------------------------
  Format output for strings
  - indent and embed in quotation marks
*/
template<typename T>
std::string formatString(
  const T& t, const std::string& nm, const std::string& suffix,
  size_t left
) {
  std::stringstream out;
  out << "\n" << indent(left) << nm << ": \"" << t << "\"" << suffix;
  return out.str();
}
/*-----------------------------------------------
  Defines is_iterable trait
  - uses template metaprogramming, e.g., user code
    that evaluates during compilation
  - detects STL containers and user-defined types
    that provide iteration
https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
*/
template <typename T, typename = void>
struct is_iterable : std::false_type {};

// this gets used only when we can call
// std::begin() and std::end() on that type
template <typename T>
struct is_iterable<
  T,
  std::void_t
    <decltype(std::begin(std::declval<T>())),
    decltype(std::end(std::declval<T>()))>
> : std::true_type {};

template <typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;

/*-----------------------------------------------
  Displays almost everything.
  - strings work better with formatString(...)
  https://www.cppstories.com/2018/03/ifconstexpr/
  Iteration is discussed in Bit Cpp_iter
*/
template<typename T>
std::string format(
  const T& t, const std::string& nm, const std::string& suffix,
  size_t left, size_t width
) {
  if constexpr(is_iterable_v<T>) {  // decision at compile-time
    return formatColl(t, nm, suffix, left, width);
  }
  else {
    return formatScalar(t, nm, suffix, left);
  }
}

/*---------------------------------------------------------
  Demonstrate functions
*/
void demo_generic_functions() {

  showNote("demo generic functions", nl);

  showOp("showType for std::string");
  std::string s = "a string";
  showType(s, "s", nl);

  showOp("showType for std::vector");
  std::vector<int> v {1, 2, 3, 2, 1, 0, -1, -2};
  showType(v, "v", nl);

  /*-------------------------------------------------------
    showSeqColl works for any collection with
    iterator, integer indexing, and size() function
  */
  showOp("showSeqColl for std::string", nl);
  showSeqColl(s);

  showOp("showSeqColl for std::vector", nl);
  showSeqColl(v);

  /*-------------------------------------------------------
    showAssocColl works for any collection with
    interator and std::pair<key, Value> elements
  */
  showOp("showAssocColl for std::map", "\n");
  std::map<std::string, int> m {
    {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3},
    {"four", 4}, {"five", 5}
  };
  showAssocColl(m);

  showOp("showAssocColl for std::unordered_map", "\n");
  std::unordered_map<std::string, int> um1 {
    {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3},
    {"four", 4}, {"five", 5}
  };
  showAssocColl(um1);

  /*-------------------------------------------------------
    Analysis::format works for any collection with
    interator and std::pair<key, Value> elements
  */
  showOp("Analysis::format for int");
  int mol = 42;
  std::cout << Analysis::format(42, "mol", "\n");
  // need to distinguish Analysis::format from std::format

  showOp("Analysis::format for std::string");
  std::cout << Analysis::format(s, "s", "\n");

  showOp("Analysis::format for std::vector");
  std::cout << Analysis::format(v, "v", "\n", 2, 5);

  showOp("Analysis::format for std::map");
  std::cout << Analysis::format(m, "m", "\n", 2, 4);

  showOp("Analysis::format for std::unordered_map");
  std::unordered_map<std::string, int> um2 {
    {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 4},
    {"four", 4}, {"five", 5}
  };
  std::cout << Analysis::format(um2, "um", "\n", 2, 4);
}