code: function UnaryTypeVariable(name) {
      return function($1) {
        var tuples = [['$1', K ([]), $1]];
        var test = typeVarPred (tuples.length);
        return _Type (VARIABLE, name, '', 1, null, [], test, tuples);
      };
    }
docs: # UnaryTypeVariable :: String -> Type -> Type . . Combines [`UnaryType`][] and [`TypeVariable`][]. . . To define a unary type variable `t a` one must provide: . .   - a name (conventionally matching `^[a-z]$`); and . .   - the type of `a`. . . Consider the type of a generalized `map`: . . ```haskell . map :: Functor f => (a -> b) -> f a -> f b . ``` . . `f` is a unary type variable. With two (nullary) type variables, one . unary type variable, and one [type class][] it's possible to define a . fully polymorphic `map` function: . . ```javascript . const $ = require ('sanctuary-def'); . const Z = require ('sanctuary-type-classes'); . . const a = $.TypeVariable ('a'); . const b = $.TypeVariable ('b'); . const f = $.UnaryTypeVariable ('f'); . . //    map :: Functor f => (a -> b) -> f a -> f b . const map = . def ('map') .     ({f: [Z.Functor]}) .     ([$.Function ([a, b]), f (a), f (b)]) .     (f => functor => Z.map (f, functor)); . ``` . . Whereas a regular type variable is fully resolved (`a` might become . `Array (Array String)`, for example), a unary type variable defers to . its type argument, which may itself be a type variable. The type argument . corresponds to the type argument of a unary type or the *second* type . argument of a binary type. The second type argument of `Map k v`, for . example, is `v`. One could replace `Functor => f` with `Map k` or with . `Map Integer`, but not with `Map`. . . This shallow inspection makes it possible to constrain a value's "outer" . and "inner" types independently.