# Generators

Generators are a low-level construct in Basic Storm that allows dynamic generation of functions, types, or other things. A generator is a function that is called whenever Storm attempts to look up a name that does not yet exist. The generator then has the opportunity to generate a matching entity dynamically. It is thus possible to implement C++-style templates with generators.

A generator is associated with a name. However, unlike other entities in the name tree, a generator does not have a set of parameters associated with it. Instead, the generator gets access to the parameters that the system is looking for, and it has the chance to generate a suitable entity.

Note: The generators are implemented in the package: `lang:bs:macro`.

A simple generator that generates a function that adds two numbers in Basic Storm looks as follows:

    use lang:bs:macro;

    genAdd : generate(params) {
        if (params.count != 2)
            return null;

        if (params[0] != params[1])
            return null;

        Value t = params[0];

        BSTreeFn fn(t, SStr("genAdd"), params, ["a", "b"], null);

        Scope scope = rootScope.child(t.getType());

        FnBody body(fn, scope);
        fn.body(body);

        Actual actual;
        actual.add(namedExpr(body, SStr("a"), Actual()));
        actual.add(namedExpr(body, SStr("b"), Actual()));

        body.add(namedExpr(body, SStr("+"), actual));

        return fn;
    }

As can be seen from the example, a generator is a function that receives a single parameter (named `params` above). This parameter has the type `Array<Value>` and represents the params of the name part sought after. The function then validates that exactly two parameters were passed, and that they are the same. If not, `null` is returned to indicate that the parameter list was not applicable. Otherwise, a `Named` is generated (a function in this case) and returned.