Set based report | C# Online Compiler

Set based report by Dmitry Nogin

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; }
    }
}

​x
 
​
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; }
    }
}
​

Roslyn 2.0 Compiler; Environment version: 4.0.30319.42000

<root xmlns="https://stackoverflow.com/questions/55914228/how-do-i-declare-a-xdocument-namespace-globally-in-c" attr1="attribute one" attr2="attribute two">
  <title>this is the root</title>
  <xhtml>
    <div id="wrapper">
      <p style="first">
        <em>hello</em> world!</p>
    </div>
  </xhtml>
  <element />
  <anotherElement>
    <someNestedElement>Some text content</someNestedElement>
  </anotherElement>
</root>

Last Run:	7:05:04 am
Compile:	0.252s
Execute:	0.047s
Memory:	44.16kb
CPU:	0.125s

View IL Code