match

type Bindings map[string]interface{}

type Matcher struct {
	// AllowPropertyVariables enables the experimental support for
	// a single property variable in a map pattern that has no
	// other properties.
	AllowPropertyVariables bool

	// CheckForBadPropertyVariables runs a test to verify that a
	// pattern does not contain a property variable along with
	// other properties.
	//
	// This check might not be necessary because the other code
	// will report an error if a bad property variable is actually
	// enountered during matching.  The interesting twist is that
	// if a match fails before encountering the bad property
	// variable, then that code will not report the problem.  In
	// order to report the problem consistently, turn on this
	// switch.  Performance will suffer, but any bad property
	// variable will be caught.
	CheckForBadPropertyVariables bool

	// Inequalities is a switch to turn on experimental binding
	// inequality support.
	//
	// With this feature, pattern matching supports numeric
	// inequalities in addition to the standard equality
	// predicate.  The input bindings should include a binding for
	// a variable with a name that contains either "<", ">", "<=",
	// ">=", or "!=" immediately after the leading "?".  The input
	// pattern can then use that variable.  When matching, a value
	// X will match that variable only if the binding Y for that
	// variable satisfies the inequality with X and Y (in that
	// order). In this case, the output bindings will include a
	// new binding for a variable with the same name as the
	// inequality variable but without the actual inequality.
	//
	// For example, given input bindings {"?<n":10}, pattern
	// {"n":"?<n"}, and message {"n":3}, the match will succeed
	// with bindings {"?<n":10,"?n":3}.
	//
	// See match_test.json for several examples. (Search for
	// "inequality".)
	//
	// For now at least, the inequalities only work for numeric
	// values.  We might support strings later.
	//
	// Yes, such a feature makes us stare down a slippery slope.
	// However, we are brave, and we do not shy away from even
	// grave danger.
	//
	//   "[In Sheens] we live exactly as we please, and yet are
	//   just as ready to encounter every legitimate danger."
	//
	//   --Pericles
	//
	// The immediate motivation for this feature was to support
	// timer fallbacks.  For example, using the Goja interpreter,
	// an action could establish a binding with a value that's a
	// number representing a future time in UNIX milliseconds.
	// Then a branch pattern can check for a message containing
	// the current time which is greater than that number.  When a
	// machine is loaded, a system could send the machine a
	// "current time" message, which could advance the machine
	// according to such a branch.  Using this technique, a
	// machine that creates a timer that somehow gets lots could
	// regain at least some sense of what's going on.  Similarly,
	// a system that doesn't have asynchronous, timer-driven
	// messaging support could simply send messages every second
	// (or at whatever internal) to provide timer-like
	// functionality (albeit with inefficiencies and without the
	// message-oriented timer protocol that's been offered
	// elsewhere).
	Inequalities bool
}

type UnknownPatternType struct {
	Pattern interface{}
}