using System;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

        /// Using the interface of BinaryTree (derived from ITree<TChild, TValue>) we can exract BinaryTree children

        BinaryTree<int> binaryTree = new BinaryTree<int>(15);

        ISet<BinaryTree<int>> binaryTreeChildren = binaryTree.ITreeDerivedChildren;

        /// Using ITree interface (derived from IRecursive<TChild>) we can extract ITree children

        ITree<int> iTree = binaryTree;

        ISet<ITree<int>> iTreeChildren = iTree.IRecursiveDerivedChildren;

        /// Using IRecursive interface we can extract iRecursive children

        IRecursive iRecursive = iTree;

        ISet<IRecursive> iRecursiveChildren = iRecursive.IRecursiveChildren;

    }

}

​

/// <summary> The (usable) IRecursive interface </summary>

public interface IRecursive {

    bool IsParent { get; }

    ISet<IRecursive>? IRecursiveChildren { get; }

}

​

/// <summary> This interface can't really be used as it requires an infinite recursive definition of TChild. It's sole purpose is for deriving from using other interfaces or classes. </summary>

public interface IRecursive<TChild> : IRecursive where TChild : IRecursive<TChild> {

    /// <summary> Classes and interfaces derived from IRecursive<TChild> inherit this property to return children of their own type

    /// It's basicly more obscure, but less duplication, than giving every derived class / interface it's own children property </summary>

    ISet<TChild>? IRecursiveDerivedChildren { get; }

}

​

/// <summary> The (usable) ITree interface </summary>

public interface ITree<TValue> : IRecursive<ITree<TValue>> {

    TValue Value { get; set; }

    bool Leaf { get; }

}

​

/// <summary> This interface can't really be used as it requires an infinite recursive definition of TChild. It's sole purpose is for deriving from using other interfaces or classes. </summary>

public interface ITree<TChild, TValue> : ITree<TValue> where TChild : ITree<TChild, TValue> {

    /// <summary> Similar to the IRecursiveDerivedChildren but now a more concrete version (ITree : IRecursive) </summary>

    ISet<TChild>? ITreeDerivedChildren { get; }

}

​

/// <summary> A binary tree which uses CRTP and Polymorphism to define general recursive and tree properties. </summary>

public class BinaryTree<TValue> : ITree<BinaryTree<TValue>, TValue> {

    public TValue Value { get; set; } 

    public bool Leaf { get; }

    public bool IsParent => !Leaf;

    public BinaryTree<TValue>? Left { get; }

    public BinaryTree<TValue>? Right { get; }

    public ISet<IRecursive>? IRecursiveChildren => Leaf ? null : new HashSet<IRecursive>(2) { Left, Right };

    public ISet<ITree<TValue>>? IRecursiveDerivedChildren => Leaf ? null : new HashSet<ITree<TValue>>(2) { Left, Right }; 

    public ISet<BinaryTree<TValue>>? ITreeDerivedChildren => Leaf ? null : new HashSet<BinaryTree<TValue>>(2) { Left, Right }; 

    public BinaryTree(TValue value) {

        Value = value;

        Leaf = true;

    }

}