<programming> (Also known as a "schematic type variable"). Different occurrences of a generic type variable in a type expression may be instantiated to different types. Thus, in the expression let id x = x in (id True, id 1) id's type is (for all a: a -> a). The universal quantifier "for all a:" means that a is a generic type variable. For the two uses of id, a is instantiated to Bool and Int. Compare this with let id x = x in let f g = (g True, g 1) in f id This looks similar but f has no legal Hindley-Milner type. If we say f :: (a -> b) -> (b, b) this would permit g's type to be any instance of (a -> b) rather than requiring it to be at least as general as (a -> b). Furthermore, it constrains both instances of g to have the same result type whereas they do not. The type variables a and b in the above are implicitly quantified at the top level: f :: for all a: for all b: (a -> b) -> (b, b) so instantiating them (removing the quantifiers) can only be done once, at the top level. To correctly describe the type of f requires that they be locally quantified: f :: ((for all a: a) -> (for all b: b)) -> (c, d) which means that each time g is applied, a and b may be instantiated differently. f's actual argument must have a type at least as general as ((for all a: a) -> (for all b: b)), and may not be some less general instance of this type. Type variables c and d are still implicitly quantified at the top level and, now that g's result type is a generic type variable, any types chosen for c and d are guaranteed to be instances of it. This type for f does not express the fact that b only needs to be at least as general as the types c and d. For example, if c and d were both Bool then any function of type (for all a: a -> Bool) would be a suitable argument to f but it would not match the above type for f.

A generic drug is a pharmaceutical drug that contains the same chemical substance as a drug that was originally protected by chemical patents. Generic drugs are allowed for sale after the patents on the original drugs expire.

In computer programming, a variable is an abstract storage location paired with an associated symbolic name, which contains some known or unknown quantity of information referred to as a value; or in simpler terms, a variable is a named container for a particular set of bits or type of data (like integer, float, string etc...).

<programming, operating system> A variable that is bound in the current environment. When evaluating an expression in some environment, the evaluation of a variable consists of looking up its name in the environment and substituting its value. Most programming languages have some concept of an environment but in Unix shell scripts it has a specific meaning slightly different from other contexts. In shell scripts, environment variables are one kind of shell variable. They differ from local variables and command line arguments in that they are inheritted by a child process. Examples are the PATH variable that tells the shell the file system paths to search to find command executables and the TZ variable which contains the local time zone. The variable called "SHELL" specifies the type of shell being used. These variables are used by commands or shell scripts to discover things about the environment they are operating in. Environment variables can be changed or created by the user or a program. To see a list of environment variables type "setenv" at the csh or tcsh prompt or "set" at the sh, bash, jsh or ksh prompt. In other programming languages, e.g. functional programming languages, the environment is extended with new bindings when a function's parameters are bound to its {actual arguments} or when new variables are declared. In a block-structured procedural language, the environment usually consists of a linked list of activation records. (1999-01-26)

An environment variable is a dynamic-named value that can affect the way running processes will behave on a computer. They are part of the environment in which a process runs.

In computer programming, a variable-length array (VLA), also called variable-sized or runtime-sized, is an array data structure whose length is determined at run time (instead of at compile time).

<programming, operating system> One of the variables accessible to a Unix shell process, including {environment variables} (e.g. $HOME), command line arguments (e.g. $1) and local variables (e.g. $input_file). Other {operating systems} have similar variables. (1999-01-26)

Variable bitrate (VBR) is a term used in telecommunications and computing that relates to the bitrate used in sound or video encoding. As opposed to constant bitrate (CBR), VBR files vary the amount of output data per time segment.

A random variable (also called random quantity, aleatory variable, or stochastic variable) is a mathematical formalization of a quantity or object which depends on random events. It is a mapping or a function from possible outcomes in a sample space to a measurable space, often the real numbers.