dimitris-papadimitriou-chr

    public abstract class Either<TLeft, TRight>
    {
        public abstract void IfLeft(Action<TLeft> action);
        public abstract void IfRight(Action<TRight> action);
        public abstract Either<TLeft, T1Right> Select<T1Right>(Func<TRight, T1Right> mapping);
        public abstract TResult Match<TResult>(Func<TLeft, TResult> Left, Func<TRight, TResult> Right);
     

    }

dimitris-papadimitriou-chr

    public interface IFunctor<T>
    {
        IFunctor<T1> Map<T1>(Func<T, T1> map);
    }

    public class Id<T> : IFunctor<T>
    {
        private T source;
        public Id(T v) => source = v;

dimitris-papadimitriou-chr

    public abstract class Free<T>
    {
        public abstract Free<T1> Map<T1>(Func<T, T1> map);

    }

    public class Pure<T> : Free<T>
    {
        private T source;

dimitris-papadimitriou-chr

Func<int, ILazyComonad<int>> CofreeAna = null;

CofreeAna = n => new LazyCofree(n + 1, new Lazy(() => new IdentiyF(CofreeAna(n + 1))));

dimitris-papadimitriou-chr

      Func<int, ILazyComonad<int>> CofreeAna = null;

            CofreeAna = n => new LazyCofree(n + 1, new Lazy(() => new IdentiyF(CofreeAna(n + 1))));

            var stream = CofreeAna(0);

            var t = stream.Next().Map(x => x * 2).Next().Next().Map(x => x * 2);

dimitris-papadimitriou-chr

var node = (left, v, right) => ({
  left: left,
  v: v,
  right: right,
  map: f => node(left.map(f), f(v), right.map(f)), 
});

var leaf = v => ({  v: v,  map: f => leaf(f(v)), });

var tree = node(leaf(1),3, node(leaf(5), 7, leaf(13)));

dimitris-papadimitriou-chr

  Object.prototype.getIterator = function () {
    var self = this;
    return {
      *[Symbol.iterator]() {
        {
          var content = self.fold([],(acc,e)=>acc.concat( e ) ) 
          for (var element of content) yield element;
        }
      }
    }

dimitris-papadimitriou-chr

 
 
 //https://medium.com/@dimpapadim3
 
  var node = (left, value, right) => ({
    left: left,
    value: value,
    right: right,
    map: f => node(left.map(f), f(value), right.map(f)),
    fold: (mempty, mappend) => 

dimitris-papadimitriou-chr

 fetch("https://api.github.com/users")
    .map(response => response.json())
    .toEither()
    .map(users => users.map(u => u.login))
    .cata({
      ok: v => console.log(v),
      error: v => console.log("error" + v)
    });

dimitris-papadimitriou-chr

  var EitherAsync = function (actions, g) { 
    this.cata = function (alg) {
      actions(alg.ok , alg.error)
    }
  }
  
  Promise.prototype.toEither = function () {
    var promise = this;
    var either = new EitherCoyoAsync(function (resolve, reject) {
      promise.then(resolve).catch(reject)