/// <summary>
        /// Parses through all the text and then handles any setting.
        /// </summary>
        /// <param name="input"></param>
        /// <param name="setter"></param>
        /// <returns></returns>
        protected ISettingParserResult Parse(ParseArgs input, Func <T, string, IResult> setter)
        {
            var unusedParts = new List <IResult>();
            var successes   = new List <IResult>();
            var errors      = new List <IResult>();
            var help        = new List <HelpResult>();

            bool tryParser(string s, out T result)
            => TryGetSetting(s, PrefixState.Required, out result);

            var argMap = input.CreateArgMap <T>(tryParser);

            foreach (var(Setting, Args) in argMap)
            {
                if (Setting == null)
                {
                    unusedParts.Add(Result.FromError(Args));
                    continue;
                }

                var args     = Setting.IsFlag && Args == null ? bool.TrueString : Args;
                var response = setter(Setting, args);
                if (response.IsSuccess && response is HelpResult helpResult)
                {
                    help.Add(helpResult);
                }
                else if (response.IsSuccess)
                {
                    successes.Add(response);
                }
                else
                {
                    errors.Add(response);
                }
            }
            return(new SettingParserResult(unusedParts, successes, errors, help));
        }
 ISettingParserResult ISettingParser.Parse(object source, ParseArgs input)
 => Parse(source, input);
 /// <summary>
 /// Abstract and protected to handle implementation from an instance and static context.
 /// </summary>
 /// <param name="source"></param>
 /// <param name="input"></param>
 /// <returns></returns>
 protected abstract ISettingParserResult Parse(object source, ParseArgs input);