module Standard {
    module Algorithms {
    private:
        IsRange(srctype) {
            // Ranges have a pair of members, Begin and End, which are the same type.
            // and support operator* and operator++, at minimum.
            begin := srctype.Members.Find("Begin"));
            if (!begin) return false;
            end := srctype.Members.Find("End"));
            if (!end) return false;
            if (begin.Type != end.Type) return false;
            members := begin.Type.Members;
            if (!members.Find("operator*") || !members.Find("operator++")) return false;
            return true;
        }
    public:
        Map(src, func) prolog {
            if (!IsRange(Utility.Decltype(src))) return false;
            if (Utility.Decltype(func(*src.Begin)) != void) return false;
        } {
            while(val) {
                func(*val.Begin);
                ++val.Begin;
            }
            return;
        }
        Map(src, func) prolog {
            if (!IsRange(Utility.Decltype(src))) return false;
        } {
            result := Standard.Containers.Vector(Expression(func(*val.Begin)).Type)();
            while(val) {
                result.Insert(result.Back(), func(*val.Begin));
                ++val.Begin;
            }
            return result;
        }

        Map(src, func) {
            // Since it's not a range,
            // It's a tuple!
            Expression(src).Type.Members.Map(function(x)) {
                // Tuples have no member functions, they're all member variables
                func(x(src));
            });
        }
    }
}