C#

// So, create a new function taking DTArgs<double> as input,
// which is in short a queue of doubles (or anything else we want)
// The first type, in this case "double", is the type used by
// the function's internal DTArgs<T>.
DTFunc<double, string> f = new DTFunc<double, string>(
    a =>
    {
        // The function body.
        string r = "";
        // While our DTArgs<double> 'a' has values,
        while (a.Count > 0)
        {
            // Add the next argument to the string, followed by a comma.
            // a.Call dequeues and returns the next argument.
            r += a.Call + ", ";
        }
        // Chop off the last comma.
        return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
    }
);

// The function needs arguments,
for (int i = 0; i <= 10; ++i)
    // So add them. Granted, setting a property is not standard.
    // But, this code is in my "StrangeTest" project.
    // .Args is a property accessor to the functions' DTArgs.
    f.Args.Add = i;

// Call the function and write the output to the console.
Console.WriteLine(f.Call);

var a = 5.5;

a = new func<double>(delegate() { return 5.5; });

DTBase<double> a = (DTVar<double>)5.5;
a = new DTFunc<double>(delegate() { return 5.5; });

// A simple "Guess my number" program.

            // The length of the number to guess.
            DTVar<int> length = 7;
            // A starting phrase.
            Console.WriteLine("Guess my Number, a {0}-digit number.", length);
            // True if or when the player guesses entirely correctly.
            DTVar<bool> allCorrect = false;
            // A function that matches the output of two DTArgs<char> arguments,
            // and returns a string with X's in all locations where they don't match.
            DTFunc<char, char, string> matchingF = new DTFunc<char, char, string>(
                (a, b) =>
                {
                    // Our return string.
                    string r = "";
                    // If our first DTArgs<char> has values remaining,
                    while (a.Count > 0)
                    {
                        // We can call a DTArgs to return the next argument,
                        // or we can convert it.
                        // As DTBase<T> works on the principle that
                        // the thing is what it returns when called,
                        // the conversion can be implicit.
                        // A DTArgs is an argument queue, essentially.
                        char a1 = a;
                        char b1 = b.Call;

                        // If the two characters match, add that character to the string.
                        // if they don't match, add 'X' to the string.
                        r += (a1 == b1 ? a1 : 'X');
                    }
                    return r;
                }
            );
            // A function to generate a new "phone number".
            DTBase<string> numberF = new DTFunc<string>(
                delegate()
                {
                    // Stores "length" number of random integers from 0 to 9 in a string.
                    string r = "";
                    // "length" may be a DTVar<int>, but because the use is unambiguous,
                    // it can use implicit conversion.
                    for (int t = 0; t < length; ++t) r += Rand.Next(10);
                    // Returns the string "phone number".
                    return r;
                }
            );
            // A function to read a new guess from the console.
            DTBase<string> guessF = new DTFunc<string>(delegate() { return Console.ReadLine(); });
            // A function to checks if the first string argument is correct by
            // checking to see if it contains a 'X'.
            // Only one argument should be entered at a time.
            DTFunc<string, bool> correctF = new DTFunc<string, bool>(a => { return !a.Call.Contains('X'); });


            // Get our number to guess.
            DTVar<string> number = numberF.Call;
            // The maximum number of guesses allowed.
            int count = 20;
            do
            {
                // We call the guess function to get the player's next guess.
                DTVar<string> guess = guessF.Call;

                // We can either call or convert the number and the guess,
                // either works.
                // DTArgs<T>.AddRange can be given an IEnumerable to add
                // everything in the enumerable to the arguments.
                // In this case, DTArgs<T> is DTArgs<char> and the
                // IEnumerable is a string.
                matchingF.Args1.AddRange = number.Call;
                // We could just call "guessF" here, but that might be
                // too ambiguous for the reader.
                matchingF.Args2.AddRange = (string)guess;

                // Likewise, we can convert-call the matching function,
                // now that it has proper arguments.
                DTVar<string> result = (string)matchingF;

                // Add the result string to the arguments of the function
                // that checks if the result string is entirely correct,
                // then store that value in "allCorrect".
                // As "allCorrect" is a DTVar<bool>, we can use implicit
                // conversion.
                // Again, we could directly store "matchingF" in the args,
                // (that is, its call).
                correctF.Args.Add = result;
                allCorrect = correctF.Call;
                
                // Write the result to the console.
                Console.WriteLine(result.Call);
            } while (!allCorrect && --count >= 0);

            // Win/lose output.
            Console.WriteLine("You {0}", (allCorrect ? "Win! :)" : "Loose. :("));

var a = 5.5;

a = new func<double>(delegate() { return 5.5; });

DTBase<double> a = (DTVar<double>)5.5;
a = new DTFunc<double>(delegate() { return 5.5; });

Dictionary<string, DTBase<double>> formulasForGame; // Functions, equations, single variables and file reads. 

List<DTBase<string>> urlRetrieval; // Retrieves urls from various places and sources. Optionally, a list of DTArgs<string>. 

List<DTFunc<string, string>> chatRelays; // A set of functions that relay text strings for chat according to the specific sending needs of each specific receiver and sender. 

a = new func<double>(delegate() { return 5.5; });

public implicit operator T(DTBase<T> val) { return val.Value; }
public implicit operator DTBase<T>(T val) { return new DTVar<T>(val); }

AbstractBase firstDerived = new FirstDerived();
firstDerived.DoSomething();

Mark Nischalke wrote:

However, I disagree that it is odd

Mark Nischalke wrote:

It's not an error

Mark Nischalke wrote:

Don't you think this would have been a better response to the OP than "this structure is quite odd and you should adjust your design"? How would they have know what odd meant or how it should be redesigned in your opinion?

Mark Nischalke wrote:

You mean this line?

FirstDerived firstDerived = new FirstDerived();

Well, yes, of course it is different. It is being called in class SecondDerived. I don't see anything odd about that.

class Base
{
  protected abstract void DoSomething();
}

class Derived : Base
{
  protected override void DoSomething() {...}
  
  private void SomethingElse()
  {
    CompletelyDifferent otherObject = new CompletelyDifferent();
    otherObject.SomeFunction(); // Error! It's protected
  }
}

class CompletelyDifferent
{
  protected void SomeFunction() {...}
}

Mark Nischalke wrote:

It's not an error. It is someone trying to learn, giving an example and asking for an explaination.