public REAIfStatement(Stringe token, RantExpressionAction expr, RantExpressionAction body, RantExpressionAction elseBody = null)
			: base(token)
		{
			_expression = expr;
			_body = body;
            _elseBody = elseBody;
		}

 private static bool CapsInfer(Interpreter interpreter, Source source, Stringe tagname, TagArg[] args)
 {
     // TODO: Make capsinfer properly infer "first" capitalization given multiple sentences. Currently, it mistakes it for "word" mode.
     var words = Regex.Matches(args[0].GetString(), @"\w+").OfType<Match>().Select(m => m.Value).ToArray();
     int wCount = words.Length;
     int uCount = 0;
     int fwCount = 0;
     bool firstCharIsUpper = false;
     for (int i = 0; i < wCount; i++)
     {
         if (words[i].All(Char.IsUpper))
         {
             uCount++;
         }
         if (Char.IsUpper(words[i][0]))
         {
             fwCount++;
             if (i == 0) firstCharIsUpper = true;
         }
     }
     if (uCount == wCount)
     {
         interpreter.CurrentState.Output.SetCaps(Capitalization.Upper);
     }
     else if (wCount > 1 && fwCount == wCount)
     {
         interpreter.CurrentState.Output.SetCaps(Capitalization.Word);
     }
     else if (firstCharIsUpper)
     {
         interpreter.CurrentState.Output.SetCaps(Capitalization.First);
     }
     return false;
 }

		public RichGreaterThanOperator(Stringe origin, bool orEqual = false)
			: base(origin)
		{
			Type = ActionValueType.Boolean;
			_orEqual = orEqual;
            Precedence = 15;
        }

		public REAObjectPropertyAssignment(Stringe origin, RantExpressionAction nameExp, RantExpressionAction obj, RantExpressionAction value)
			: base(origin)
		{
			Name = nameExp;
			_value = value;
			_object = obj;
		}

        public TagBlueprint(Interpreter interpreter, Source source, Stringe name, IEnumerable<Token<TokenType>>[] args = null)
            : base(interpreter)
        {
            Source = source;
            Name = name;

            if (!Interpreter.TagFuncs.TryGetValue(Name.Value.ToLower().Trim(), out _tagDef))
            {
                throw new ManhoodException(Source, Name, "The tag '" + Name.Value + "' does not exist.");
            }

            _tagDef.ValidateArgCount(source, name, args != null ? args.Length : 0);

            if (args == null)
            {
                _args = Enumerable.Empty<TagArg>().ToArray();
            }
            else
            {
                // Insert token arguments into the array, set string args to null.
                _args = args.Select((a, i) => _tagDef.ArgTypes[i] == TagArgType.Tokens ? TagArg.FromTokens(a) : null).ToArray();

                // Queue string arguments on the stack.
                for (int i = 0; i < _tagDef.ArgTypes.Length; i++)
                {
                    if (_tagDef.ArgTypes[i] == TagArgType.Result)
                    {
                        interpreter.PushState(Interpreter.State.CreateDerivedDistinct(source, args[i], interpreter));
                    }
                }
            }
        }

		public RACallSubroutine(Stringe name, string moduleFunctionName = null)
			: base(name)
		{
			if (moduleFunctionName != null)
				_inModule = true;
			_moduleFunctionName = moduleFunctionName;
		}

		public RichList(Stringe origin, List<RichActionBase> items, bool concatSyntax = true)
			: base(origin)
		{
			_items = items;
			Type = ActionValueType.List;
			_concatSyntax = concatSyntax;
		}

 internal void SetToken(Stringe token)
 {
     _line = token.Line;
     _col = token.Column;
     _index = token.Offset;
     _length = token.Length;
 }

		public RichIfStatement(Stringe token, RichActionBase expr, RichActionBase body, RichActionBase elseBody = null)
			: base(token)
		{
			_expression = expr;
			_body = body;
            _elseBody = elseBody;
		}

		public RichObjectPropertyAssignment(Stringe origin, RichActionBase nameExp, RichActionBase obj, RichActionBase value)
			: base(origin)
		{
			Name = nameExp;
			_value = value;
			_object = obj;
		}

		public RAFunction(Stringe range, RantFunctionInfo funcInfo, List<RantAction> argActions)
			: base(range)
		{
			_funcInfo = funcInfo;
			_argActions = argActions;
			_argc = argActions.Count;
		}

 internal Chare(Stringe source, char c, int offset)
 {
     _src = source;
     _character = c;
     _offset = offset;
     _line = _column = 0;
 }

		public REAList(Stringe origin, List<RantExpressionAction> items, bool concatSyntax = true)
			: base(origin)
		{
			_items = items;
			Type = ActionValueType.List;
			_concatSyntax = concatSyntax;
		}

		public RichFunctionCall(Stringe token, RichActionBase function, RichGroup args, string _sourceName)
			: base(token)
		{
			_function = function;
			List<RichActionBase> argValues = new List<RichActionBase>();
			if (args.Actions.Count > 0)
			{
				RichActionBase lastArg = null;
				for (var i = 0; i < args.Actions.Count; i++)
				{
					var action = args.Actions[i];
                    if (action is RichArgumentSeperator)
                    {
                        if (lastArg == null)
                            throw new RantCompilerException(_sourceName, Range, "Blank argument in function call.");
                        argValues.Add(lastArg);
                    }
                    else
                        lastArg = action;
				}
				argValues.Add(lastArg);
			}
			_argValues = argValues.ToArray();

            Returnable = true;
		}

        public REAWhile(Stringe token, RantExpressionAction test, RantExpressionAction body)
            : base(token)
        {
            _test = test;
            _body = body;

            Breakable = true;
        }

        public RichWhile(Stringe token, RichActionBase test, RichActionBase body)
            : base(token)
        {
            _test = test;
            _body = body;

            Breakable = true;
        }

 internal RantTableLoadException(string origin, Stringe token, string message) 
     : base($"{origin}: (Ln {token.Line}, Col {token.Column}) {message}")
 {
     Line = token.Line;
     Column = token.Column;
     Offset = token.Offset;
     Origin = origin;
 }

		public RichObject(Stringe token, RichObjectKeyValue[] values)
			: base(token)
		{
			Type = ActionValueType.Object;
			Values = new Dictionary<string, RichActionBase>();
			foreach (RichObjectKeyValue val in values)
				Values[val.Name] = val.Value;
		}

        public RantFunctionInfo GetFunctionInfo(RantFunctionGroup group, int argc, Stringe from, Stringe to)
        {
            var func = group.GetFunction(argc);

            if (func == null)
                SyntaxError(Stringe.Between(from, to), $"No overload of function '{group.Name}' can take {argc} arguments");

            return func;
        }

 public static RantExpressionAction ConvertToAction(Stringe token, object value)
 {
     if (value is double)
         return new REANumber((double)value, token);
     if (value is string)
         return new REAString((string)value, token);
     if (value is bool)
         return new REABoolean(token, (bool)value);
     return value as RantExpressionAction;
 }