Invercargill/src/lib/Invercargill.vala

namespace Invercargill {

    public static Enumerable<T> ate<T>(T[] input) {
        if(typeof(T).is_value_type()) {
            // LibGee has already done the hard work around
            // Vala's funkyness with arrays of type arguments
            var gee = new Gee.ArrayList<T>.wrap(input);
            return new GeeEnumerable<T>(gee);
        }

        return new ArrayEnumerable<T>(input);
    }

    public static Enumerable<T> gate<T>(GenericArray<T> input) {
        return new GenericArrayEnumerable<T>(input);
    }

    public static Enumerable<T> gte<T>(Gee.Iterable<T> input) {
        return new GeeEnumerable<T>(input);
    }

    //  public static Enumerable<string> dte(path input) {
    //      return new DirEnumerable(input);
    //  }

    public static Enumerable<int> range(int from, int to, int increment = 1) {
        return new RangeEnumerable(from, to, increment);
    }

    public static Enumerable<T> empty<T>() {
        return new EmptyEnumerable<T>();
    }

    public static Enumerable<T> single<T>(T item) {
        var seq = new Invercargill.Series<T>();
        seq.add(item);
        return seq;
    }

    public static TransformDelegate<Tin, Tout> trycatch<Tin, Tout>(ErrorThrowingDelegate<Tin, Tout> main, ErrorCatchingDelegate<Tin, Tout> handler) {
        return (i) => {
            try {
                return main(i);
            }
            catch(Error e) {
                return handler(i, e);
            }
        };
    }

    public static TransformDelegate<Tin, Tout> trydefault<Tin, Tout>(ErrorThrowingDelegate<Tin, Tout> func, Tout default_value) {
        return (i) => {
            try {
                return func(i);
            }
            catch {
                return default_value;
            }
        };
    }

}