The constructor of a (:$) node in the Term. Each of these constructors denotes a "normal/standard/basic" syntactic form (i.e., a generalized quantifier). In the literature, these syntactic forms are sometimes called "operators", but we avoid calling them that so as not to introduce confusion vs PrimOp etc. Instead we use the term "operator" to refer to any primitive function or constant; that is, non-binding syntactic forms. Also in the literature, the SCon type itself is usually called the "signature" of the term language. However, we avoid calling it that since our Term has constructors other than just (:$), so SCon does not give a complete signature for our terms.

The main reason for breaking this type out and using it in conjunction with (:$) and SArgs is so that we can easily pattern match on fully saturated nodes. For example, we want to be able to match MeasureOp_ Uniform :$ lo :* hi :* End without needing to deal with App_ nodes nor viewABT.

The arguments to a (:$) node in the Term; that is, a list of ASTs, where the whole list is indexed by a (type-level) list of the indices of each element.

The generating functor for Hakaru ASTs. This type is given in open-recursive form, where the first type argument gives the recursive form. The recursive form abt does not have exactly the same kind as Term abt because every Term represents a locally-closed term whereas the underlying abt may bind some variables.

Locally closed values (i.e., not binding forms) of a given type. TODO: come up with a better name

A newtype of abt '[], because sometimes we need this in order to give instances for things. In particular, this is often used to derive the obvious Foo1 (abt '[]) instance from an underlying Foo2 abt instance. The primary motivating example is to give the Datum_ branch of the Show1 (Term abt) instance.

Primitive associative n-ary functions. By flattening the trees for associative operators, we can more easily perform equivalence checking and pattern matching (e.g., to convert exp (a * log b) into b ** a, regardless of whether a is a product of things or not). Notably, because of this encoding, we encode things like subtraction and division by their unary operators (negation and reciprocal).

We do not make any assumptions about whether these semigroups are monoids, commutative, idempotent, or anything else. That has to be handled by transformations, rather than by the AST itself.

Simple primitive functions, and constants. N.B., nothing in here should produce or consume things of HMeasure or HArray type (except perhaps in a totally polymorphic way).

Primitive operators for consuming or transforming arrays.

TODO: we may want to replace the Sing arguments with something more specific in order to capture any restrictions on what can be stored in an array. Or, if we can get rid of them entirely while still implementing all the use sites of sing_ArrayOp, that'd be better still.

Primitive operators to produce, consume, or transform distributions/measures. This corresponds to the old Mochastic class, except that MBind and Superpose_ are handled elsewhere since they are not simple operators. (Also Dirac is handled elsewhere since it naturally fits with MBind, even though it is a siple operator.)

TODO: we may want to replace the Sing arguments with something more specific in order to capture any restrictions on what can be a measure space (e.g., to exclude functions). Or, if we can get rid of them entirely while still implementing all the use sites of sing_MeasureOp, that'd be better still.

Numeric literals for the primitive numeric types. In addition to being normal forms, these are also ground terms: that is, not only are they closed (i.e., no free variables), they also have no bound variables and thus no binding forms. Notably, we store literals using exact types so that none of our program transformations have to worry about issues like overflow or floating-point fuzz.