namespace SessionTypes {
    public class Eps { }
    public class Send<A, R> { }
    public class Recv<A, R> { }
    public class Choose<R, S> { }
    public class Follow<R, S> { }

    public class Dual<R, S> {
        private Dual() { }

        public static Dual<Eps, Eps> eps = new Dual<Eps, Eps>();

        public Dual<Send<A, R>, Recv<A, S>> send<A>() {
            return new Dual<Send<A, R>, Recv<A, S>>();
        }

        public Dual<Recv<A, R>, Send<A, S>> recv<A>() {
            return new Dual<Recv<A, R>, Send<A, S>>();
        }

        public Dual<Choose<R, R2>, Follow<S, S2>>
        choose<R2, S2>(Dual<R2, S2> right) {
            return new Dual<Choose<R, R2>, Follow<S, S2>>();
        }

        public Dual<Follow<R, R2>, Choose<S, S2>>
        follow<R2, S2>(Dual<R2, S2> right) {
            return new Dual<Follow<R, R2>, Choose<S, S2>>();
        }

        public Dual<S, R> flip() {
            return new Dual<S, R>();
        }

        public void confirm() { }
    }

    public class Session<S1,S2,A> {
        private delegate R Thunk<R>();
        private Thunk<A> action;

        private Session() { }

        private Session(Thunk<A> thunk) { action = thunk; }

        public delegate Y Func<X,Y>(X x);

        public Session(A a) {
            action = () => a;
        }

        public Session<S1,S3,B> bind<S3,B>(Func<A, Session<S2,S3,B>> next) {
            return new Session<S1,S3,B>(() => {
                return next(this.action()).action();
            });
        }

        public static C run<R,S,B,C>(Dual<R, S> witness,
                                     Session<R, Eps, B> r,
                                     Session<S, Eps, C> s) {
            witness.confirm();
            return s.action();
        }
    }
}