C#

double a = new Func<double>(delegate() { 2 + 2; });

DTBase<double> a = new DTFunc<double>(delegate() { 2 + 2; });
Console.WriteLine(a.Call); // Output 4
a = (DTVar<double>)5; // Conversion needed because DTBase<double> is an abstract class.
Console.WriteLine(a.Call); // Output 5
// Equivalent of "1 + 1 = X", where DTEquation calculates "x".
DTBase<double> a = new DTEquation((DTVar<double>)1, new DTOperand[] { new DTOperand(MathOp.Add, (DTVar<double>)1) });
Console.WriteLine(a.Call); // output 2

DTFunc<double, string> f = new DTFunc<double, string>(
                a =>
                {
                    string r = "";
                    while (a.Count > 0)
                    {
                        r += a.Call + ", ";
                    }
                    return r.Length > 0 ? r.Substring(0, r.Length - 2) : r;
                }
            );

            for (int i = 0; i <= 10; ++i)
                f.Args.Add = i;

            Console.WriteLine(f.Call);

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