​

namespace ConsoleApplication22

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Collections;

    using static System.Console;

    using static System.String;

    using static Selection;

​

    public class Program

    {

        static Set<double> Less(double max) =>

            new Set<double>(v => v < max);

​

        static Set<double> Bigger(double min) =>

            new Set<double>(v => v > min);

​

        static Set<double> Range(double min, double max) =>

            Bigger(min) & Less(max);

​

        static void Report(string title, IEnumerable<object> args) =>

            WriteLine($"{title}: {Join(",", args)}");

​

        public static void Main()

        {

            var soundings = Sounding.Fakes();

​

            // business layer – not happy; definitely need some lambda 

            // language for composition

            Set<double> negative = Less(0);

​

            Set<Point> shallow = negative & Bigger(-20) & Select((Point p) => p.Depth);

            Set<Point> squeezed = Bigger(100) & Select((Point p) => p.Pressure);

            Set<Point> outliers = negative & SelectMany((Point p) => p.Channels);

​

            Set<Sounding> deep = shallow & SelectMany((Sounding s) => s.Points);

            Set<Sounding> failed = (squeezed & shallow | outliers) & SelectMany((Sounding s) => s.Points);

​

            // reporting looks just good; and it is important as 

            // it is usually very volatile

            Report("Job well done", soundings & !failed);

            Report("To do", soundings & failed);

            Report("Big upcoming expenses", soundings & failed & deep);

​

        }

    }

    // demo data 

​

    class Sounding

    {

        public static Sounding[] Fakes() => new[]

        {

            new Sounding {

                Name ="Squeezed",

                Points = new[]

                {

                    new Point { Depth = -10, Pressure = 10, Channels = new[] { 1d, 2d, 3d } },

                    new Point { Depth = -15, Pressure = 1000, Channels = new[] { 1d, 2d, 3d } }

                }

            },

            new Sounding {

                Name ="Deep and OK",

                Points = new[]

                {

                    new Point { Depth = -10, Pressure = 10, Channels = new[] { 1d, 2d, 3d } },

                    new Point { Depth = -50, Pressure = 1000, Channels = new[] { 1d, 2d, 3d } }

                }

            },

            new Sounding {

                Name ="Deep with bad data",

                Points = new[]

                {

                    new Point { Depth = -25, Pressure = 10, Channels = new[] { 1d, 2d, 3d } },

                    new Point { Depth = -50, Pressure = 1000, Channels = new[] { -1d, -2d, 3d } }

                }

            }

        };

​

        public string Name { get; set; }

        public Point[] Points { get; set; }

        public override string ToString() => Name;

    }

​

    class Point

    {

        public double Depth { get; set; }

        public double Pressure { get; set; }

        public double[] Channels { get; set; }

    }

​

    // library code

    static class Selection

    {

        public static Selection<T, TResult> Select<T, TResult>(Func<T, TResult> selector) =>

            new Selection<T, TResult>(selector);

​

        public static Selection<T, TResult> SelectMany<T, TResult>(Func<T, IEnumerable<TResult>> selector) =>

            new Selection<T, TResult>(selector);

    }

​

    class Selection<T, TResult>

    {

        public static Set<T> operator &(Set<TResult> left, Selection<T, TResult> right) =>

            new Set<T>(r => left & right.Selector(r));

​

        public static Set<T> operator &(Selection<T, TResult> left, Set<TResult> right) =>

            new Set<T>(r => right & left.Selector(r));

        public Selection(Func<T, TResult> selector)

        {

            Selector = (T i) => new[] { selector(i) };

        }

​

        public Selection(Func<T, IEnumerable<TResult>> selector)

        {

            Selector = selector;

        }

​

        Func<T, IEnumerable<TResult>> Selector { get; }

    }

​

    class Set<T>

    {

        public Set(Predicate<T> predicate)

        {

            Predicate = predicate;

        }        

        public static Enumerable<T> operator &(Set<T> left, T right) =>

            left.Predicate(right) ? new Enumerable<T>(right) : Enumerable<T>.Empty;

​

        public static Enumerable<T> operator &(T left, Set<T> right) =>

            right.Predicate(left) ? new Enumerable<T>(left) : Enumerable<T>.Empty;

​

        public static Set<T> operator &(Set<T> left, Set<T> right) =>

            new Set<T>(i => left.Predicate(i) && right.Predicate(i));

​

        public static Enumerable<T> operator &(Set<T> left, IEnumerable<T> right) =>

            new Enumerable<T>(right.Where(i => left.Predicate(i)));

​

        public static Enumerable<T> operator &(IEnumerable<T> left, Set<T> right) =>

            new Enumerable<T>(left.Where(i => right.Predicate(i)));

​

        public static Set<T> operator |(Set<T> left, T right) =>

            new Set<T>(i => left.Predicate(i) || right.Equals(i));

​

        public static Set<T> operator |(T left, Set<T> right) =>

            new Set<T>(i => left.Equals(i) || right.Predicate(i));

​

        public static Set<T> operator |(Set<T> left, Set<T> right) =>

            new Set<T>(i => left.Predicate(i) || right.Predicate(i));

​

        public static Set<T> operator |(Set<T> left, IEnumerable<T> right) =>

            new Set<T>(i => left.Predicate(i) || right.Contains(i));

​

        public static Set<T> operator |(IEnumerable<T> left, Set<T> right) =>

            new Set<T>(i => left.Contains(i) || right.Predicate(i));

        public static Set<T> operator -(Set<T> left, T right) =>

            new Set<T>(i => left.Predicate(i) && !right.Equals(i));

​

        public static Set<T> operator -(T left, Set<T> right) =>

            new Set<T>(i => left.Equals(i) && !right.Predicate(i));

​

        public static Set<T> operator -(Set<T> left, Set<T> right) =>

            new Set<T>(i => left.Predicate(i) && !right.Predicate(i));

​

        public static Set<T> operator -(Set<T> left, IEnumerable<T> right) =>

            new Set<T>(i => left.Predicate(i) && !right.Contains(i));

​

        public static Enumerable<T> operator -(IEnumerable<T> left, Set<T> right) =>

            new Enumerable<T>(left.Where(i => !right.Predicate(i)));

​

        public static Set<T> operator !(Set<T> set) =>

            new Set<T>(i => !set.Predicate(i));

​

        Predicate <T> Predicate { get; }

    }

​

    class Enumerable<T> : IEnumerable<T>

    {

        public static readonly Enumerable<T> Empty = new Enumerable<T>();

        public static implicit operator bool(Enumerable<T> intersection) => intersection.Any();

​

        public Enumerable(params T[] items)

        {

            Items = items;

        }

​

        public Enumerable(IEnumerable<T> items)

        {

            Items = items;

        }

​

        public IEnumerator<T> GetEnumerator() => Items.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        IEnumerable<T> Items { get; }

    }

}

​