Bits: Iter C#

/*-----------------------------------------------------
  Enumerate standard library types
*/
static void EnumStdTypes() {

  Display.ShowNote("  Enumerate standard types", "\n");

  Display.ShowOp("array - basic enumeration");
  int[] arri = { 0, 1, 2, 1, 0 };
  var enm = arri.GetEnumerator();
  enm.MoveNext();
  Console.Write("  {0}", enm.Current);
  while (enm.MoveNext()) {
    Console.Write(", {0}", enm.Current);
  }
  Console.WriteLine("\n");

  Display.ShowOp("enumerate list with foreach");
  List<double> ld = new List<double>{1.0, 1.5, 2.0, 2.5, 3.0 };
  bool first = true;
  foreach (var item in ld) {
    if (first) {
      Console.Write("  {0:0.0}", item);
      first = false;
    }
    else {
      Console.Write(", {0:0.0}", item);
    }
  }
  Console.WriteLine("\n");

  Display.ShowOp("enumerate dictionary with foreach");
  Dictionary<string, int> dsi =
    new Dictionary<string, int>{
      {"zero", 0}, {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4},
    };
  first = true;
  foreach (var item in dsi) {
    if (first) {
      Console.Write("  {0}", item);
      first = false;
    }
    else {
      Console.Write(", {0}", item);
    }
  }
  Console.WriteLine("\n");
}
  

/*-------------------------------------------------------------------
  Points.cs
  - provides definitions for user-defined class BasicPoint<T>
*/

using System.Collections;
using System.Collections.Generic;   // IEnumerable<T>, List<T>
using Analysis;

namespace Points {

  /*----------------------------------------------------------------------
    BasicPoint<T>
     - holds any finite number of generic coordinates
     - coordinates are held in a List<T>
     - implements IEnumerable<T> so it can be indexed and iterated
     - does not implement ICollection<T> or IList<T> to avoid making
       demonstration too complicated for learning example
     - it is a reference type because it is implemented with a class.
       its List<T> is also a reference type
  */
  public class BasicPoint<T> : IEnumerable<T>, Analysis.IShow {
    /*--------------------------------------------------------------------
      Constructs a BasicPoint with N coordinates each with default value
    */
    public BasicPoint(int N) {
      coor = new List<T>();
      for(int i = 0; i<N; ++i) {
        T? test = default(T);
        if(test != null) {
          coor.Add(test);
        }
      }
    }
    /*--------------------------------------------------------------------
      Supports building BasicPoint by Adding elements after construction
    */
    public BasicPoint() {
      coor = new List<T>();
    }
    /*-----------------------------------------------------
      Add element to back of coordinate list
      - supports using list initializer, e.g.
        var p = new BasicPoint<int> { 1, 2. 3 }
    */
    public void Add(T t) {
      coor.Add(t);
    }
    /* translates IShow::show() for needs of BasicPoint class */
    public void Show(string name) {
      PrintSelf(name);
    }
    /*
      Displays structure and state of N-dimensional BasicPoint.
      - state is a set of rows of coordinate data
      - property Width specifies number of elements in each row
      - property Left specifies offset of row from terminal Left edge
    */
    public void PrintSelf(string name) {
      Console.Write(Display.Indent(Left));
      Console.Write("{0} {{\n{1}", name, Display.Indent(Left + 2));
      for(int i=0; i<coor.Count; ++i) {
        Console.Write("{0}", coor[i]);
        if(i < coor.Count - 1) {
          Display.print(", ");
        }
        if((i+1) % Width == 0 && i != coor.Count - 1) {
          Console.Write("\n");
          Console.Write(Display.Indent(Left + Indent));
        }
      }
      Console.Write("\n" + Display.Indent(Left + Indent) + "{0}", dt);
      Console.Write("\n{0}", Display.Indent(Left));
      Console.WriteLine("}");
    }
    /* The functions below support indexing and iterating */
    public T this[int index] {
      get { return coor[index]; }
      set { coor.Insert(index, value); }
    }
    /*-- returns coor enumerator --*/
    public IEnumerator<T> GetEnumerator() {
      return coor.GetEnumerator();
    }
    /*-- returns BasicPoint<T> enumerator --*/
    IEnumerator IEnumerable.GetEnumerator() {
      return this.GetEnumerator();
    }
    /*-- returns BasicPoint<T> iterator --*/
    public IEnumerable<T> iter() {
      foreach (var item in coor) {
        yield return item;
      }
    }
    public List<T> coor { get; set; }
    public DateTime dt { get; set; } = DateTime.Now;
    public int Length { get { return coor.Count; } }
    public int Width { get; set; } = 5;   // default row size
    public int Left { get; set; } = 2;    // default offset
    public int Indent { get; set; } = 2;
    /* initializers */
    public BasicPoint<T> width(int w) {
      this.Width = w;
      return this;
    }
    public BasicPoint<T> left(int l) {
      this.Left = l;
      return this;
    }
    public BasicPoint<T> indent(int i) {
      this.Indent = i;
      return this;
    }
  }
  /*-------------------------------------------------------
    Point<T>
    - same as BasicPoint<T> with additions:
      - implements ICollection<T> and IList<T> interfaces
      - single inheritance of BasicPoint<T>'s implementation
      - Deriving from ICollecton<T> and IList<T> supports using
        generic functions for analysis and display.
  */
  public class Point<T> :
    BasicPoint<T>, ICollection<T>, IList<T>
  {
    public Point(int N) : base(N) { }
    public Point() : base() {}
    public void Clear() {
      base.coor.Clear();
    }
    public bool Contains(T item) {
      return base.coor.Contains(item);
    }
    public void CopyTo(T[] array, int i) {
      base.coor.CopyTo(array, i);
    }
    public bool Remove(T item) {
      return base.coor.Remove(item);
    }
    public int Count {
      get { return base.coor.Count; }
    }
    public bool IsReadOnly {
      get { return false; }
    }
    public int IndexOf(T item) {
      return base.coor.IndexOf(item);
    }
    public void Insert(int i, T item) {
      base.coor.Insert(i, item);
    }
    public void RemoveAt(int index) {
      base.coor.RemoveAt(index);
    }
  }
}

/*-----------------------------------------------------
  Enumerate Point<T>
  - all of the examples here work with either
    BasicPoint<T> or Point<T>
*/
static void EnumPoint() {

  Display.ShowNote("  Enumerate Point types", "\n");

  Display.ShowOp("BasicPoint - indexing");
  BasicPoint<int> bpi = new BasicPoint<int>() { 0, 1, 2, 3, 4 };
  Console.Write("  {0}", bpi[0]);
  for (int i = 1; i < bpi.Length; i++) {
    Console.Write(", {0}", bpi[i]);
  };
  Console.WriteLine("\n");

  Display.ShowOp("BasicPoint - basic enumeration");
  // BasicPoint<int> bpi = new BasicPoint<int>() { 0, 1, 2, 3, 4 };
  var enm = bpi.GetEnumerator();
  enm.MoveNext();
  Console.Write("  {0}", enm.Current);
  while (enm.MoveNext()) {
    Console.Write(", {0}", enm.Current);
  }
  Console.WriteLine("\n");

  Display.ShowOp("Point enumeration with foreach");
  Point<double> pd = new Point<double>() { 0.0, -1.5, 3.0, -4.5, 6.0 };
  bool first = true;
  foreach (var item in pd) {
    if (first) {
      Console.Write("  {0:0.0}", item);
      first = false;
    }
    else {
      Console.Write(", {0:0.0}", item);
    }
  }
  Console.WriteLine("\n");
}

/*-----------------------------------------------------
  void GenericIndexer<T>(List<T>)
  - Display list items with indexing
  - works for all sequential indexable containers
*/
static void GenericIndexer<C, T>(C coll)
    where C:ICollection<T>, IList<T>
{
  Console.Write("  {0}", coll[0]);
  for(int i=1; i < coll.Count(); ++i) {
    Console.Write(", {0}", coll[i]);
  }
  Display.Println("");
}
static void executeGenericIndexer() {
  Display.ShowNote("  GenericIndexer<C, T>(C coll)", nl);

  Display.ShowOp("index over int[]");
  int[] ai = new int[] {1, 2, 3, 4, 5};
  GenericIndexer<int[], int>(ai);
  Console.WriteLine();

  Display.ShowOp("index over List<int>");
  List<int> li = new List<int>{1, 2, 3, 2, 1};
  GenericIndexer<List<int>, int>(li);
  Console.WriteLine();
  /*
    This demo cannot use BasicPoint<T> because it does not
    implement ICollection<T> and IList<T>.

  */
  Display.ShowOp("index over Point<int>");
  Point<int> pi = new Point<int>{1, 2, 3, 2, 1};
  GenericIndexer<Point<int>, int>(pi);
  Console.WriteLine();
}

/*-----------------------------------------------------
  void GenericEnumerator<T>(IEnumerable<T> enm)
  - Display list items with enumerator
*/
static void GenericEnumerator<T>(IEnumerable<T> enm) {
  var lenum = enm.GetEnumerator();
  lenum.MoveNext();
  Console.Write("  {0}", lenum.Current);
  while(lenum.MoveNext()) {
    var item = lenum.Current;
    Console.Write(", {0}", item);
  }
  Display.Println("");
}
static void executeGenericEnumerator() {
  Display.ShowNote(
    "  GenericEnumerator<T>(IEnumerable<T> enm)"
  );
  Console.WriteLine();

  Display.ShowOp("enumerate over int[]");
  int[] ai = new int[] {1, 2, 3, 4, 5};
  GenericEnumerator<int>(ai);
  Console.WriteLine();

  Display.ShowOp("enumerate over String");
  String s = "a string";
  GenericEnumerator<char>(s);
  Console.WriteLine();

  Display.ShowOp("enumerate over List<double>");
  List<double> ld = new List<double>{1.0, 2.25, 3.5, 2.75, 1.0};
  GenericEnumerator<double>(ld);
  Console.WriteLine();

  Display.ShowOp("enumerate over Dictionary<String, int>");
  Dictionary<String, int> d = new Dictionary<String, int> {
    {"zero", 0}, {"one", 1}, {"two", 2}
  };
  GenericEnumerator<KeyValuePair<String,int>>(d);
  Console.WriteLine();

  Display.ShowOp("enumerate over BasicPoint<int>");
  BasicPoint<int> pb = new BasicPoint<int>{ 1, 2, 3, 2, 1 };
  GenericEnumerator<int>(pb);
  Console.WriteLine();

  Display.ShowOp("enumerate over Point<int>");
  Point<int> p = new Point<int>{ 1, 2, 3, 2, 1 };
  GenericEnumerator<int>(p);
  Console.WriteLine();
}

/*-----------------------------------------------------
  void GenericForEach<T>(IEnumerable<T> enm)
  - Display list items with foreach
*/
static void GenericForEach<T>(
  IEnumerable<T> enm, Action<T> lambda
) {
  foreach (T item in enm) {
    lambda(item);
  }
}
static void ExecuteGenericForEach() {

  Display.ShowNote(
    "  GenericForEach<T>(

        IEnumerable<T> enm, Action<T> lambda
    )"
  );
  Console.WriteLine();

  Display.ShowOp("Add 1.0 to items of List<double>");
  List<double> ld = 
        new List<double>{1.0, 2.25, 3.5, 2.25, 1.0};
  Console.Write("  ");
  /*
    delegates pass their arguments by value, e.g., make a copy,
    so plus_one will not modify the original enumerable element.
    The next demo shows how to do that.
  */
  Action<double> plus_one = x => Console.Write("{0} ",x += 1.0);
  /* Action<T> is delegate with no return and input T */
  GenericForEach<double>(ld, plus_one);
  Console.WriteLine("\n");
  /*
    verify that the list was not modified by uncommenting
    the lines below
  */
  // GenericEnumerator<double>(ld);
  // Console.WriteLine("\n");
  /*
    Lambdas can capture local variables, and those can be
    modified, as shown below.
  */
  List<double> modLd = new List<double>();
  /* using captured variable modLd */
  Action<double> add_one = item => { modLd.Add(item + 1.0); };
  /*
    using ld defined earlier, add_one adds ld item + 1 to modLd
    with function call below
  */
  GenericForEach<double>(ld, add_one);
  /* modLd now modified */
  Display.ShowOp("original list");
  GenericEnumerator<double>(ld);
  Console.WriteLine();
  Display.ShowOp("modified list using lambda capture");
  GenericEnumerator<double>(modLd);
  Console.WriteLine();

  /* repeat same demonstration with BasicPoint */
  Display.ShowOp("original BasicPoint");
  var pb = new BasicPoint<double>{ 1.0, 2.5, 4.0 };
  GenericEnumerator<double>(pb);
  Console.WriteLine();
  /*
    we need a new lambda because we are capturing a BasicPoint,
    not a List
  */
  var mpb = new BasicPoint<double>();
  Action<double> add_one_point = item => { mpb.Add(item + 1.0); };
  GenericForEach<double>(pb, add_one_point);
  Display.ShowOp("modified BasicPoint using lambda capture");
  GenericEnumerator<double>(mpb);
  Console.WriteLine();
  Display.ShowOp("modified BasicPoint Show(name)");
  mpb.Show("mpb");
}

/*-----------------------------------------------------
  IEnumerable<T> 
  GenericModifier<T>(IEnumerable<T> enm, Func<T,T> lambda)
  - return modified IEnumerable<T> transformed by 
    lambda Func<T,T>
  - uses Linq Select
*/
static IEnumerable<T> GenericModifier<T>(
    IEnumerable<T> enm, Func<T,T> lambda) 
{
  /*
    lambda makes copies of input enumerable's elements,
    so lambda's modifications don't affect input.
    Instead we make new modified collection using
    Linq Select method.
  */
  return enm.Select(lambda);
}
static void ExecuteGenericModifier() {

  Display.ShowNote(
    "  IEnumerable<T> 
       GenericModifier<T>(\n    Ienumerable<T> enm, Func<T,T> lambda\n  )"
  );
  Console.WriteLine();

  Display.ShowOp("GenericModifier for List<int> with plus_one");
  /*-- original --*/
  List<int> li = new List<int>{1, 2, 3, 4, 3, 2};
  Console.WriteLine("Original:");
  GenericEnumerator<int>(li);
  /*-- modified --*/
  Func<int, int> plus_one = x => x+1;
  /* Func<U,V> is a delegate with input U and output V */
  var coll = GenericModifier<int>(li, plus_one);  // modify
  Console.WriteLine("Modified:");
  GenericEnumerator<int>(coll);                   // display
  Console.WriteLine();

  Display.ShowOp("GenericModifier for array<double> with square");
  /*-- original --*/
  double[] da = new double[]{ 1.0, 2.5, 3.0, 4.5 };
  Console.WriteLine("Original:");
  GenericEnumerator<double>(da);
  /*-- modified --*/
  Func<double,double> square = x => x*x;
  var coll2 = GenericModifier<double>(da, square);  // modify
  Console.WriteLine("Modified:");
  GenericEnumerator<double>(coll2);                 // display
  Console.WriteLine();

  Display.ShowOp("GenericModifier for BasicPoint<double> with square");
  /*-- original --*/
  var pm = new BasicPoint<double> { 1.0, 2.5, -5.0, 7.5 };
  Console.WriteLine("Original:");
  GenericEnumerator<double>(pm);
  /*-- modified --*/
  Console.WriteLine("Modified:");
  var pm2 = GenericModifier<double>(pm, square);  // modify
  GenericEnumerator<double>(pm2);                 // display
  Console.WriteLine();
}

/*-------------------------------------------------------------------
  Cs_Iter::Program.cs
  - Demonstrates IEnumerable interface and iteration
*/
using System;
using System.Collections;
using System.Collections.Generic;   // IEnumerable<T>, List<T>
using System.Linq;                  // IEnumerable<T>.ToArray, select
using System.Text;                  // StringBuilder
using Points;                       // defined in Points.cs
using Analysis;                     // defined in Analysis.cs

/*-----------------------------------------------
  Note:
  Find all Bits code, including this in
  https://github.com/JimFawcett/Bits
  You can clone the repo from this link.
-----------------------------------------------*/
/*
  This demo uses Indexing and Enumerator to iterate
  through std collections:
  - String, List<T>, Dictionary<K,V>
  and through user-defined type:
  - BasicPoint<T>
*/
namespace CSharpIter
{
  using Analysis;

  class Program
  {
    /*-----------------------------------------------------
      Enumerate standard library types
    */
    static void EnumStdTypes() {
      /* code elided */
    }
    /*-----------------------------------------------------
      Enumerate Point<T>
      - all of the examples here work with either
        BasicPoint<T> or Point<T>
    */
    static void EnumPoint() {
      /* code elided */
    }
    /*-----------------------------------------------------
      void GenericIndexer<T>(List<T>)
      - Display list items with indexing
      - works for all sequential indexable containers
    */
    static void GenericIndexer<C, T>(C coll)
       where C:IEnumerable, ICollection<T>, IList<T>
    {
      /* code elided */
    }
    static void executeGenericIndexer() {
      /* code elided */
    }
    /*-----------------------------------------------------
      void GenericEnumerator<T>(IEnumerable<T> enm)
      - Display list items with enumerator
    */
    static void GenericEnumerator<T>(IEnumerable<T> enm) {
      /* code elided */
    }
    static void executeGenericEnumerator() {
      /* code elided */
    }
    /*-----------------------------------------------------
      void GenericForEach<T>(IEnumerable<T> enm)
      - Display list items with foreach
    */
    static void GenericForEach<T>(IEnumerable<T> enm, Action<T> lambda) {
      /* code elided */
    }
    static void ExecuteGenericForEach() {
      /* code elided */
    }
    /*-----------------------------------------------------
      IEnumerable<T> GenericModifier<T>(IEnumerable<T> enm, Func<T,T> lambda)
      - return modified IEnumerable<T> transformed by lambda Func<T,T>
      - uses Linq Select
    */
    static IEnumerable<T> GenericModifier<T>(IEnumerable<T> enm, Func<T,T> lambda) {
      /* code elided */
    }
    static void ExecuteGenericModifier() {
      /* code elided */
    }
    /*-----------------------------------------------------
      Begin demonstration
    */
    static void Main(string[] args)
    {
      Display.ShowLabel(" Demonstrate C# iteration");

      EnumStdTypes();
      EnumPoint();
      executeListIndexer();
      executeGenericIndexer();
      executeGenericEnumerator();
      ExecuteGenericForEach();
      ExecuteGenericModifier();

      Console.WriteLine("\nThat's all Folks!\n");
    }
  }
}