// stack implementation with little error handling.
using System;
using ResultMonad;

public interface Stack<T> {
   void push(T x);
   T pop();
   T peek();
   int size();
}

public class ArrayStack<T> : Stack<T>
{
  T[] A; // underlying array
  int tos;  // top of stack (first value at A[tos-1]), also keeps track of size

  public ArrayStack(int capacity) {
    if (capacity < 1) capacity = 16; // 16 is default capacity
    A = new T[capacity];
    tos = 0;
  }//constructor

  public int size() { return tos; }
  public int capacity() { return A.Length; }

  public void push(T x) {
     if (tos>=A.Length) throw new Exception("Stack overflow!");
     A[tos++] = x;
  }//push

  public T pop() {
    if (tos<1) throw new Exception("Stack underflow!");
    return A[--tos];
  }//pop

  public T peek() {
    if (tos<1) throw new Exception("Stack underflow!");
    else return A[tos-1];  
  }
}//ArrayStack

public interface SafeStack<T> {
   Result<int,string> push(T x);  // int is dummy type
   Result<T,string> pop();
   Result<T,string> peek();
   int size();
}

public class ArrStack<T> : SafeStack<T>
{
  // for convenience
  static Result<R,String> Ok<R>(R x) => Result<R,String>.Ok(x);
  static Result<R,String> Err<R>(String s) => Result<R,String>.Err(s);

  T[] A; // underlying array
  int tos;  // top of stack (first value at A[tos-1]), also keeps track of size

  public ArrStack(int capacity) {
    if (capacity < 1) capacity = 16; // 16 is default capacity
    A = new T[capacity];
    tos = 0;
  }//constructor

  public int size() { return tos; }
  public int capacity() { return A.Length; }

  public Result<int,string> push(T x) {
     if (tos>=A.Length) return Err<int>("Stack overflow");
     A[tos++] = x;
     return Ok(tos);
  }//push

  public Result<T,string> pop() {
    if (tos<1) return Err<T>("Stack underflow");
    else return Ok(A[tos-1]);
  }//pop

  public Result<T,string> peek() {
     if (tos<1) return Err<T>("Stack underflow");
       else return Ok(A[tos-1]);
  }
}//ArrayStack