Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "ParsedUnknowns", "(", "unknowns", "[", "]", "*", "ast", ".", "Term", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "parsedUnknowns", "=", "unknowns", "\n", "}", "\n", "}" ]

[ "ParsedUnknowns", "returns", "an", "argument", "that", "sets", "the", "values", "to", "treat", "as", "unknown", "during", "partial", "evaluation", "." ]

[ "func", "PartialNamespace", "(", "ns", "string", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "partialNamespace", "=", "ns", "\n", "}", "\n", "}" ]

[ "PartialNamespace", "returns", "an", "argument", "that", "sets", "the", "namespace", "to", "use", "for", "partial", "evaluation", "results", ".", "The", "namespace", "must", "be", "a", "valid", "package", "path", "component", "." ]

[ "func", "Module", "(", "filename", ",", "input", "string", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "modules", "=", "append", "(", "r", ".", "modules", ",", "rawModule", "{", "filename", ":", "filename", ",", "module", ":", "input", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "Module", "returns", "an", "argument", "that", "adds", "a", "Rego", "module", "." ]

[ "func", "Compiler", "(", "c", "*", "ast", ".", "Compiler", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "compiler", "=", "c", "\n", "}", "\n", "}" ]

[ "Compiler", "returns", "an", "argument", "that", "sets", "the", "Rego", "compiler", "." ]

[ "func", "Store", "(", "s", "storage", ".", "Store", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "store", "=", "s", "\n", "}", "\n", "}" ]

[ "Store", "returns", "an", "argument", "that", "sets", "the", "policy", "engine", "s", "data", "storage", "layer", "." ]

[ "func", "Transaction", "(", "txn", "storage", ".", "Transaction", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "txn", "=", "txn", "\n", "}", "\n", "}" ]

[ "Transaction", "returns", "an", "argument", "that", "sets", "the", "transaction", "to", "use", "for", "storage", "layer", "operations", "." ]

[ "func", "Metrics", "(", "m", "metrics", ".", "Metrics", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "metrics", "=", "m", "\n", "}", "\n", "}" ]

[ "Metrics", "returns", "an", "argument", "that", "sets", "the", "metrics", "collection", "." ]

[ "func", "Instrument", "(", "yes", "bool", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "instrument", "=", "yes", "\n", "}", "\n", "}" ]

[ "Instrument", "returns", "an", "argument", "that", "enables", "instrumentation", "for", "diagnosing", "performance", "issues", "." ]

[ "func", "Trace", "(", "yes", "bool", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "trace", "=", "yes", "\n", "}", "\n", "}" ]

[ "Trace", "returns", "an", "argument", "that", "enables", "tracing", "on", "r", "." ]

[ "func", "Tracer", "(", "t", "topdown", ".", "Tracer", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "if", "t", "!=", "nil", "{", "r", ".", "tracers", "=", "append", "(", "r", ".", "tracers", ",", "t", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Tracer", "returns", "an", "argument", "that", "adds", "a", "query", "tracer", "to", "r", "." ]

[ "func", "Runtime", "(", "term", "*", "ast", ".", "Term", ")", "func", "(", "r", "*", "Rego", ")", "{", "return", "func", "(", "r", "*", "Rego", ")", "{", "r", ".", "runtime", "=", "term", "\n", "}", "\n", "}" ]

[ "Runtime", "returns", "an", "argument", "that", "sets", "the", "runtime", "data", "to", "provide", "to", "the", "evaluation", "engine", "." ]

[ "func", "PrintTrace", "(", "w", "io", ".", "Writer", ",", "r", "*", "Rego", ")", "{", "if", "r", "==", "nil", "||", "r", ".", "tracebuf", "==", "nil", "{", "return", "\n", "}", "\n", "topdown", ".", "PrettyTrace", "(", "w", ",", "*", "r", ".", "tracebuf", ")", "\n", "}" ]

[ "PrintTrace", "is", "a", "helper", "function", "to", "write", "a", "human", "-", "readable", "version", "of", "the", "trace", "to", "the", "writer", "w", "." ]

[ "func", "New", "(", "options", "...", "func", "(", "r", "*", "Rego", ")", ")", "*", "Rego", "{", "r", ":=", "&", "Rego", "{", "capture", ":", "map", "[", "*", "ast", ".", "Expr", "]", "ast", ".", "Var", "{", "}", ",", "compiledQueries", ":", "map", "[", "queryType", "]", "compiledQuery", "{", "}", ",", "}", "\n\n", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "r", ")", "\n", "}", "\n\n", "if", "r", ".", "compiler", "==", "nil", "{", "r", ".", "compiler", "=", "ast", ".", "NewCompiler", "(", ")", "\n", "}", "\n\n", "if", "r", ".", "store", "==", "nil", "{", "r", ".", "store", "=", "inmem", ".", "New", "(", ")", "\n", "}", "\n\n", "if", "r", ".", "metrics", "==", "nil", "{", "r", ".", "metrics", "=", "metrics", ".", "New", "(", ")", "\n", "}", "\n\n", "if", "r", ".", "instrument", "{", "r", ".", "instrumentation", "=", "topdown", ".", "NewInstrumentation", "(", "r", ".", "metrics", ")", "\n", "}", "\n\n", "if", "r", ".", "trace", "{", "r", ".", "tracebuf", "=", "topdown", ".", "NewBufferTracer", "(", ")", "\n", "r", ".", "tracers", "=", "append", "(", "r", ".", "tracers", ",", "r", ".", "tracebuf", ")", "\n", "}", "\n\n", "if", "r", ".", "partialNamespace", "==", "\"", "\"", "{", "r", ".", "partialNamespace", "=", "defaultPartialNamespace", "\n", "}", "\n\n", "return", "r", "\n", "}" ]

[ "New", "returns", "a", "new", "Rego", "object", "." ]

[ "func", "(", "r", "*", "Rego", ")", "Eval", "(", "ctx", "context", ".", "Context", ")", "(", "ResultSet", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "r", ".", "txn", "==", "nil", "{", "r", ".", "txn", ",", "err", "=", "r", ".", "store", ".", "NewTransaction", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "r", ".", "store", ".", "Abort", "(", "ctx", ",", "r", ".", "txn", ")", "\n", "}", "\n\n", "pq", ",", "err", ":=", "r", ".", "PrepareForEval", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "pq", ".", "Eval", "(", "ctx", ")", "\n", "}" ]

[ "Eval", "evaluates", "this", "Rego", "object", "and", "returns", "a", "ResultSet", "." ]

[ "func", "(", "r", "*", "Rego", ")", "PartialEval", "(", "ctx", "context", ".", "Context", ")", "(", "PartialResult", ",", "error", ")", "{", "return", "r", ".", "PartialResult", "(", "ctx", ")", "\n", "}" ]

[ "PartialEval", "has", "been", "deprecated", "and", "renamed", "to", "PartialResult", "." ]

[ "func", "(", "r", "*", "Rego", ")", "PartialResult", "(", "ctx", "context", ".", "Context", ")", "(", "PartialResult", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "r", ".", "txn", "==", "nil", "{", "r", ".", "txn", ",", "err", "=", "r", ".", "store", ".", "NewTransaction", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PartialResult", "{", "}", ",", "err", "\n", "}", "\n", "defer", "r", ".", "store", ".", "Abort", "(", "ctx", ",", "r", ".", "txn", ")", "\n", "}", "\n\n", "pq", ",", "err", ":=", "r", ".", "PrepareForEval", "(", "ctx", ",", "WithPartialEval", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PartialResult", "{", "}", ",", "err", "\n", "}", "\n\n", "pr", ":=", "PartialResult", "{", "compiler", ":", "pq", ".", "r", ".", "compiler", ",", "store", ":", "pq", ".", "r", ".", "store", ",", "body", ":", "pq", ".", "r", ".", "parsedQuery", ",", "}", "\n\n", "return", "pr", ",", "nil", "\n", "}" ]

[ "PartialResult", "partially", "evaluates", "this", "Rego", "object", "and", "returns", "a", "PartialResult", "." ]

[ "func", "(", "r", "*", "Rego", ")", "Partial", "(", "ctx", "context", ".", "Context", ")", "(", "*", "PartialQueries", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "r", ".", "txn", "==", "nil", "{", "r", ".", "txn", ",", "err", "=", "r", ".", "store", ".", "NewTransaction", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "r", ".", "store", ".", "Abort", "(", "ctx", ",", "r", ".", "txn", ")", "\n", "}", "\n\n", "pq", ",", "err", ":=", "r", ".", "PrepareForPartial", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "pq", ".", "Partial", "(", "ctx", ")", "\n", "}" ]

[ "Partial", "runs", "partial", "evaluation", "on", "r", "and", "returns", "the", "result", "." ]

[ "func", "(", "r", "*", "Rego", ")", "Compile", "(", "ctx", "context", ".", "Context", ")", "(", "*", "CompileResult", ",", "error", ")", "{", "pq", ",", "err", ":=", "r", ".", "Partial", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "pq", ".", "Support", ")", ">", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "policy", ",", "err", ":=", "planner", ".", "New", "(", ")", ".", "WithQueries", "(", "pq", ".", "Queries", ")", ".", "Plan", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "r", ".", "dump", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "r", ".", "dump", ",", "\"", "\"", ")", "\n", "fmt", ".", "Fprintln", "(", "r", ".", "dump", ",", "\"", "\"", ")", "\n", "ir", ".", "Pretty", "(", "r", ".", "dump", ",", "policy", ")", "\n", "fmt", ".", "Fprintln", "(", "r", ".", "dump", ")", "\n", "}", "\n\n", "m", ",", "err", ":=", "wasm", ".", "New", "(", ")", ".", "WithPolicy", "(", "policy", ")", ".", "Compile", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "out", "bytes", ".", "Buffer", "\n\n", "if", "err", ":=", "encoding", ".", "WriteModule", "(", "&", "out", ",", "m", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "result", ":=", "&", "CompileResult", "{", "Bytes", ":", "out", ".", "Bytes", "(", ")", ",", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Compile", "returns", "a", "compiled", "policy", "query", "." ]

[ "func", "(", "r", "*", "Rego", ")", "PrepareForEval", "(", "ctx", "context", ".", "Context", ",", "opts", "...", "PrepareOption", ")", "(", "PreparedEvalQuery", ",", "error", ")", "{", "if", "!", "r", ".", "hasQuery", "(", ")", "{", "return", "PreparedEvalQuery", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "pCfg", ":=", "&", "PrepareConfig", "{", "}", "\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "o", "(", "pCfg", ")", "\n", "}", "\n\n", "txn", ":=", "r", ".", "txn", "\n\n", "var", "err", "error", "\n", "if", "txn", "==", "nil", "{", "txn", ",", "err", "=", "r", ".", "store", ".", "NewTransaction", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PreparedEvalQuery", "{", "}", ",", "err", "\n", "}", "\n", "defer", "r", ".", "store", ".", "Abort", "(", "ctx", ",", "txn", ")", "\n", "}", "\n\n", "// If the caller wanted to do partial evaluation as part of preparation", "// do it now and use the new Rego object.", "if", "pCfg", ".", "doPartialEval", "{", "err", ":=", "r", ".", "prepare", "(", "ctx", ",", "txn", ",", "partialResultQueryType", ",", "[", "]", "extraStage", "{", "{", "after", ":", "\"", "\"", ",", "stage", ":", "r", ".", "rewriteQueryForPartialEval", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PreparedEvalQuery", "{", "}", ",", "err", "\n", "}", "\n\n", "ectx", ":=", "&", "EvalContext", "{", "parsedInput", ":", "r", ".", "parsedInput", ",", "metrics", ":", "r", ".", "metrics", ",", "txn", ":", "txn", ",", "partialNamespace", ":", "r", ".", "partialNamespace", ",", "tracers", ":", "r", ".", "tracers", ",", "compiledQuery", ":", "r", ".", "compiledQueries", "[", "partialResultQueryType", "]", ",", "}", "\n\n", "pr", ",", "err", ":=", "r", ".", "partialResult", "(", "ctx", ",", "ectx", ",", "ast", ".", "Wildcard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PreparedEvalQuery", "{", "}", ",", "err", "\n", "}", "\n", "// Prepare the new query", "return", "pr", ".", "Rego", "(", ")", ".", "PrepareForEval", "(", "ctx", ")", "\n", "}", "\n\n", "err", "=", "r", ".", "prepare", "(", "ctx", ",", "txn", ",", "evalQueryType", ",", "[", "]", "extraStage", "{", "{", "after", ":", "\"", "\"", ",", "stage", ":", "r", ".", "rewriteQueryToCaptureValue", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PreparedEvalQuery", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "PreparedEvalQuery", "{", "preparedQuery", "{", "r", ",", "pCfg", "}", "}", ",", "err", "\n", "}" ]

[ "PrepareForEval", "will", "parse", "inputs", "modules", "and", "query", "arguments", "in", "preparation", "of", "evaluating", "them", "." ]

[ "func", "(", "r", "*", "Rego", ")", "PrepareForPartial", "(", "ctx", "context", ".", "Context", ",", "opts", "...", "PrepareOption", ")", "(", "PreparedPartialQuery", ",", "error", ")", "{", "if", "!", "r", ".", "hasQuery", "(", ")", "{", "return", "PreparedPartialQuery", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "pCfg", ":=", "&", "PrepareConfig", "{", "}", "\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "o", "(", "pCfg", ")", "\n", "}", "\n\n", "txn", ":=", "r", ".", "txn", "\n\n", "var", "err", "error", "\n", "if", "txn", "==", "nil", "{", "txn", ",", "err", "=", "r", ".", "store", ".", "NewTransaction", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PreparedPartialQuery", "{", "}", ",", "err", "\n", "}", "\n", "defer", "r", ".", "store", ".", "Abort", "(", "ctx", ",", "txn", ")", "\n", "}", "\n\n", "err", "=", "r", ".", "prepare", "(", "ctx", ",", "txn", ",", "partialQueryType", ",", "[", "]", "extraStage", "{", "{", "after", ":", "\"", "\"", ",", "stage", ":", "r", ".", "rewriteEqualsForPartialQueryCompile", ",", "}", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "PreparedPartialQuery", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "PreparedPartialQuery", "{", "preparedQuery", "{", "r", ",", "pCfg", "}", "}", ",", "err", "\n", "}" ]

[ "PrepareForPartial", "will", "parse", "inputs", "modules", "and", "query", "arguments", "in", "preparation", "of", "partially", "evaluating", "them", "." ]

[ "func", "(", "r", "*", "Rego", ")", "rewriteEqualsForPartialQueryCompile", "(", "_", "ast", ".", "QueryCompiler", ",", "query", "ast", ".", "Body", ")", "(", "ast", ".", "Body", ",", "error", ")", "{", "doubleEq", ":=", "ast", ".", "Equal", ".", "Ref", "(", ")", "\n", "unifyOp", ":=", "ast", ".", "Equality", ".", "Ref", "(", ")", "\n", "ast", ".", "WalkExprs", "(", "query", ",", "func", "(", "x", "*", "ast", ".", "Expr", ")", "bool", "{", "if", "x", ".", "IsCall", "(", ")", "{", "operator", ":=", "x", ".", "Operator", "(", ")", "\n", "if", "operator", ".", "Equal", "(", "doubleEq", ")", "&&", "len", "(", "x", ".", "Operands", "(", ")", ")", "==", "2", "{", "x", ".", "SetOperator", "(", "ast", ".", "NewTerm", "(", "unifyOp", ")", ")", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "return", "query", ",", "nil", "\n", "}" ]

[ "rewriteEqualsForPartialQueryCompile", "will", "rewrite", "==", "to", "=", "in", "queries", ".", "Normally", "this", "wouldn", "t", "be", "done", "except", "for", "handling", "queries", "with", "the", "Partial", "API", "where", "rewriting", "them", "can", "substantially", "simplify", "the", "result", "and", "it", "is", "unlikely", "that", "the", "caller", "would", "need", "expression", "values", "." ]

[ "func", "(", "m", "*", "Manifest", ")", "Init", "(", ")", "{", "if", "m", ".", "Roots", "==", "nil", "{", "defaultRoots", ":=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "m", ".", "Roots", "=", "&", "defaultRoots", "\n", "}", "\n", "}" ]

[ "Init", "initializes", "the", "manifest", ".", "If", "you", "instantiate", "a", "manifest", "manually", "call", "Init", "to", "ensure", "that", "the", "roots", "are", "set", "properly", "." ]

[ "func", "(", "r", "*", "Reader", ")", "IncludeManifestInData", "(", "includeManifestInData", "bool", ")", "*", "Reader", "{", "r", ".", "includeManifestInData", "=", "includeManifestInData", "\n", "return", "r", "\n", "}" ]

[ "IncludeManifestInData", "sets", "whether", "the", "manifest", "metadata", "should", "be", "included", "in", "the", "bundle", "s", "data", "." ]

[ "func", "Write", "(", "w", "io", ".", "Writer", ",", "bundle", "Bundle", ")", "error", "{", "gw", ":=", "gzip", ".", "NewWriter", "(", "w", ")", "\n", "tw", ":=", "tar", ".", "NewWriter", "(", "gw", ")", "\n\n", "var", "buf", "bytes", ".", "Buffer", "\n\n", "if", "err", ":=", "json", ".", "NewEncoder", "(", "&", "buf", ")", ".", "Encode", "(", "bundle", ".", "Data", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "writeFile", "(", "tw", ",", "\"", "\"", ",", "buf", ".", "Bytes", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "module", ":=", "range", "bundle", ".", "Modules", "{", "if", "err", ":=", "writeFile", "(", "tw", ",", "module", ".", "Path", ",", "module", ".", "Raw", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "writeManifest", "(", "tw", ",", "bundle", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "tw", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "gw", ".", "Close", "(", ")", "\n", "}" ]

[ "Write", "serializes", "the", "Bundle", "and", "writes", "it", "to", "w", "." ]

[ "func", "(", "b", "Bundle", ")", "Equal", "(", "other", "Bundle", ")", "bool", "{", "if", "!", "reflect", ".", "DeepEqual", "(", "b", ".", "Data", ",", "other", ".", "Data", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "b", ".", "Modules", ")", "!=", "len", "(", "other", ".", "Modules", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ":=", "range", "b", ".", "Modules", "{", "if", "b", ".", "Modules", "[", "i", "]", ".", "Path", "!=", "other", ".", "Modules", "[", "i", "]", ".", "Path", "{", "return", "false", "\n", "}", "\n", "if", "!", "b", ".", "Modules", "[", "i", "]", ".", "Parsed", ".", "Equal", "(", "other", ".", "Modules", "[", "i", "]", ".", "Parsed", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "bytes", ".", "Equal", "(", "b", ".", "Modules", "[", "i", "]", ".", "Raw", ",", "other", ".", "Modules", "[", "i", "]", ".", "Raw", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Equal", "returns", "true", "if", "this", "bundle", "s", "contents", "equal", "the", "other", "bundle", "s", "contents", "." ]

[ "func", "TransformRefs", "(", "x", "interface", "{", "}", ",", "f", "func", "(", "Ref", ")", "(", "Value", ",", "error", ")", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "t", ":=", "&", "GenericTransformer", "{", "func", "(", "x", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "r", ",", "ok", ":=", "x", ".", "(", "Ref", ")", ";", "ok", "{", "return", "f", "(", "r", ")", "\n", "}", "\n", "return", "x", ",", "nil", "\n", "}", "}", "\n", "return", "Transform", "(", "t", ",", "x", ")", "\n", "}" ]

[ "TransformRefs", "calls", "the", "function", "f", "on", "all", "references", "under", "x", "." ]

[ "func", "TransformVars", "(", "x", "interface", "{", "}", ",", "f", "func", "(", "Var", ")", "(", "Value", ",", "error", ")", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "t", ":=", "&", "GenericTransformer", "{", "func", "(", "x", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "v", ",", "ok", ":=", "x", ".", "(", "Var", ")", ";", "ok", "{", "return", "f", "(", "v", ")", "\n", "}", "\n", "return", "x", ",", "nil", "\n", "}", "}", "\n", "return", "Transform", "(", "t", ",", "x", ")", "\n", "}" ]

[ "TransformVars", "calls", "the", "function", "f", "on", "all", "vars", "under", "x", "." ]

[ "func", "TransformComprehensions", "(", "x", "interface", "{", "}", ",", "f", "func", "(", "interface", "{", "}", ")", "(", "Value", ",", "error", ")", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "t", ":=", "&", "GenericTransformer", "{", "func", "(", "x", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "switch", "x", ":=", "x", ".", "(", "type", ")", "{", "case", "*", "ArrayComprehension", ":", "return", "f", "(", "x", ")", "\n", "case", "*", "SetComprehension", ":", "return", "f", "(", "x", ")", "\n", "case", "*", "ObjectComprehension", ":", "return", "f", "(", "x", ")", "\n", "}", "\n", "return", "x", ",", "nil", "\n", "}", "}", "\n", "return", "Transform", "(", "t", ",", "x", ")", "\n", "}" ]

[ "TransformComprehensions", "calls", "the", "functio", "nf", "on", "all", "comprehensions", "under", "x", "." ]

[ "func", "Unify", "(", "safe", "VarSet", ",", "a", "*", "Term", ",", "b", "*", "Term", ")", "VarSet", "{", "u", ":=", "&", "unifier", "{", "safe", ":", "safe", ",", "unified", ":", "VarSet", "{", "}", ",", "unknown", ":", "map", "[", "Var", "]", "VarSet", "{", "}", ",", "}", "\n", "u", ".", "unify", "(", "a", ",", "b", ")", "\n", "return", "u", ".", "unified", "\n", "}" ]

[ "Unify", "returns", "a", "set", "of", "variables", "that", "will", "be", "unified", "when", "the", "equality", "expression", "defined", "by", "terms", "a", "and", "b", "is", "evaluated", ".", "The", "unifier", "assumes", "that", "variables", "in", "the", "VarSet", "safe", "are", "already", "unified", "." ]

[ "func", "RegisterPlugin", "(", "name", "string", ",", "factory", "plugins", ".", "Factory", ")", "{", "registeredPluginsMux", ".", "Lock", "(", ")", "\n", "defer", "registeredPluginsMux", ".", "Unlock", "(", ")", "\n", "registeredPlugins", "[", "name", "]", "=", "factory", "\n", "}" ]

[ "RegisterPlugin", "registers", "a", "plugin", "factory", "with", "the", "runtime", "package", ".", "When", "the", "runtime", "is", "created", "the", "factories", "are", "used", "to", "parse", "plugin", "configuration", "and", "instantiate", "plugins", ".", "If", "no", "configuration", "is", "provided", "plugins", "are", "not", "instantiated", ".", "This", "function", "is", "idempotent", "." ]

[ "func", "NewRuntime", "(", "ctx", "context", ".", "Context", ",", "params", "Params", ")", "(", "*", "Runtime", ",", "error", ")", "{", "if", "params", ".", "ID", "==", "\"", "\"", "{", "var", "err", "error", "\n", "params", ".", "ID", ",", "err", "=", "generateInstanceID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "loaded", ",", "err", ":=", "loader", ".", "Filtered", "(", "params", ".", "Paths", ",", "params", ".", "Filter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "store", ":=", "inmem", ".", "New", "(", ")", "\n\n", "txn", ",", "err", ":=", "store", ".", "NewTransaction", "(", "ctx", ",", "storage", ".", "WriteParams", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "store", ".", "Write", "(", "ctx", ",", "txn", ",", "storage", ".", "AddOp", ",", "storage", ".", "Path", "{", "}", ",", "loaded", ".", "Documents", ")", ";", "err", "!=", "nil", "{", "store", ".", "Abort", "(", "ctx", ",", "txn", ")", "\n", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "storedversion", ".", "Write", "(", "ctx", ",", "store", ",", "txn", ")", ";", "err", "!=", "nil", "{", "store", ".", "Abort", "(", "ctx", ",", "txn", ")", "\n", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "compileAndStoreInputs", "(", "ctx", ",", "store", ",", "txn", ",", "loaded", ".", "Modules", ",", "params", ".", "ErrorLimit", ")", ";", "err", "!=", "nil", "{", "store", ".", "Abort", "(", "ctx", ",", "txn", ")", "\n", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "store", ".", "Commit", "(", "ctx", ",", "txn", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "bs", ",", "err", ":=", "loadConfig", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "info", ",", "err", ":=", "runtime", ".", "Term", "(", "runtime", ".", "Params", "{", "Config", ":", "bs", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "manager", ",", "err", ":=", "plugins", ".", "New", "(", "bs", ",", "params", ".", "ID", ",", "store", ",", "plugins", ".", "Info", "(", "info", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "disco", ",", "err", ":=", "discovery", ".", "New", "(", "manager", ",", "discovery", ".", "Factories", "(", "registeredPlugins", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "manager", ".", "Register", "(", "\"", "\"", ",", "disco", ")", "\n\n", "rt", ":=", "&", "Runtime", "{", "Store", ":", "store", ",", "Params", ":", "params", ",", "Manager", ":", "manager", ",", "info", ":", "info", ",", "}", "\n\n", "return", "rt", ",", "nil", "\n", "}" ]

[ "NewRuntime", "returns", "a", "new", "Runtime", "object", "initialized", "with", "params", "." ]

[ "func", "(", "rt", "*", "Runtime", ")", "StartREPL", "(", "ctx", "context", ".", "Context", ")", "{", "if", "err", ":=", "rt", ".", "Manager", ".", "Start", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "rt", ".", "Params", ".", "Output", ",", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n\n", "defer", "rt", ".", "Manager", ".", "Stop", "(", "ctx", ")", "\n\n", "banner", ":=", "rt", ".", "getBanner", "(", ")", "\n", "repl", ":=", "repl", ".", "New", "(", "rt", ".", "Store", ",", "rt", ".", "Params", ".", "HistoryPath", ",", "rt", ".", "Params", ".", "Output", ",", "rt", ".", "Params", ".", "OutputFormat", ",", "rt", ".", "Params", ".", "ErrorLimit", ",", "banner", ")", ".", "WithRuntime", "(", "rt", ".", "info", ")", "\n\n", "if", "rt", ".", "Params", ".", "Watch", "{", "if", "err", ":=", "rt", ".", "startWatcher", "(", "ctx", ",", "rt", ".", "Params", ".", "Paths", ",", "onReloadPrinter", "(", "rt", ".", "Params", ".", "Output", ")", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "rt", ".", "Params", ".", "Output", ",", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "}", "\n\n", "repl", ".", "Loop", "(", "ctx", ")", "\n", "}" ]

[ "StartREPL", "starts", "the", "runtime", "in", "REPL", "mode", ".", "This", "function", "will", "block", "the", "calling", "goroutine", "." ]

[ "func", "New", "(", ")", "*", "Compiler", "{", "c", ":=", "&", "Compiler", "{", "code", ":", "&", "module", ".", "CodeEntry", "{", "}", ",", "stringOffset", ":", "2048", ",", "localMax", ":", "2", ",", "// assume that locals start at 0..2 then increment monotonically", "}", "\n", "c", ".", "stages", "=", "[", "]", "func", "(", ")", "error", "{", "c", ".", "initModule", ",", "c", ".", "compileStrings", ",", "c", ".", "emitEntry", ",", "c", ".", "compilePlan", ",", "c", ".", "emitLocals", ",", "c", ".", "emitFunctionSection", ",", "c", ".", "emitExportSection", ",", "c", ".", "emitCodeSection", ",", "c", ".", "emitDataSection", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "New", "returns", "a", "new", "compiler", "object", "." ]

[ "func", "(", "c", "*", "Compiler", ")", "WithPolicy", "(", "p", "*", "ir", ".", "Policy", ")", "*", "Compiler", "{", "c", ".", "policy", "=", "p", "\n", "return", "c", "\n", "}" ]

[ "WithPolicy", "sets", "the", "policy", "to", "compile", "." ]

[ "func", "(", "c", "*", "Compiler", ")", "Compile", "(", ")", "(", "*", "module", ".", "Module", ",", "error", ")", "{", "for", "_", ",", "stage", ":=", "range", "c", ".", "stages", "{", "if", "err", ":=", "stage", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "c", ".", "module", ",", "nil", "\n", "}" ]

[ "Compile", "returns", "a", "compiled", "WASM", "module", "." ]

[ "func", "Factories", "(", "fs", "map", "[", "string", "]", "plugins", ".", "Factory", ")", "func", "(", "*", "Discovery", ")", "{", "return", "func", "(", "d", "*", "Discovery", ")", "{", "d", ".", "factories", "=", "fs", "\n", "}", "\n", "}" ]

[ "Factories", "provides", "a", "set", "of", "factory", "functions", "to", "use", "for", "instantiating", "custom", "plugins", "." ]

[ "func", "New", "(", "manager", "*", "plugins", ".", "Manager", ",", "opts", "...", "func", "(", "*", "Discovery", ")", ")", "(", "*", "Discovery", ",", "error", ")", "{", "result", ":=", "&", "Discovery", "{", "manager", ":", "manager", ",", "}", "\n\n", "for", "_", ",", "f", ":=", "range", "opts", "{", "f", "(", "result", ")", "\n", "}", "\n\n", "config", ",", "err", ":=", "ParseConfig", "(", "manager", ".", "Config", ".", "Discovery", ",", "manager", ".", "Services", "(", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "config", "==", "nil", "{", "if", "_", ",", "err", ":=", "getPluginSet", "(", "result", ".", "factories", ",", "manager", ",", "manager", ".", "Config", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}", "\n\n", "if", "manager", ".", "Config", ".", "PluginsEnabled", "(", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "result", ".", "config", "=", "config", "\n", "result", ".", "downloader", "=", "download", ".", "New", "(", "config", ".", "Config", ",", "manager", ".", "Client", "(", "config", ".", "service", ")", ",", "config", ".", "path", ")", ".", "WithCallback", "(", "result", ".", "oneShot", ")", "\n", "result", ".", "status", "=", "&", "bundle", ".", "Status", "{", "Name", ":", "*", "config", ".", "Name", ",", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "discovery", "plugin", "." ]

[ "func", "(", "c", "*", "Discovery", ")", "Start", "(", "ctx", "context", ".", "Context", ")", "error", "{", "if", "c", ".", "downloader", "!=", "nil", "{", "c", ".", "downloader", ".", "Start", "(", "ctx", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Start", "starts", "the", "dynamic", "discovery", "process", "if", "configured", "." ]

[ "func", "(", "c", "*", "Discovery", ")", "Stop", "(", "ctx", "context", ".", "Context", ")", "{", "if", "c", ".", "downloader", "!=", "nil", "{", "c", ".", "downloader", ".", "Stop", "(", "ctx", ")", "\n", "}", "\n", "}" ]

[ "Stop", "stops", "the", "dynamic", "discovery", "process", "if", "configured", "." ]

[ "func", "Identity", "(", "r", "*", "http", ".", "Request", ")", "(", "string", ",", "bool", ")", "{", "ctx", ":=", "r", ".", "Context", "(", ")", "\n", "v", ",", "ok", ":=", "ctx", ".", "Value", "(", "identity", ")", ".", "(", "string", ")", "\n", "if", "ok", "{", "return", "v", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "Identity", "returns", "the", "identity", "of", "the", "caller", "associated", "with", "ctx", "." ]

[ "func", "SetIdentity", "(", "r", "*", "http", ".", "Request", ",", "v", "string", ")", "*", "http", ".", "Request", "{", "return", "r", ".", "WithContext", "(", "context", ".", "WithValue", "(", "r", ".", "Context", "(", ")", ",", "identity", ",", "v", ")", ")", "\n", "}" ]

[ "SetIdentity", "returns", "a", "new", "http", ".", "Request", "with", "the", "identity", "set", "to", "v", "." ]

[ "func", "IsKeyword", "(", "s", "string", ")", "bool", "{", "for", "_", ",", "x", ":=", "range", "Keywords", "{", "if", "x", "==", "s", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsKeyword", "returns", "true", "if", "s", "is", "a", "language", "keyword", "." ]

[ "func", "(", "mod", "*", "Module", ")", "Compare", "(", "other", "*", "Module", ")", "int", "{", "if", "mod", "==", "nil", "{", "if", "other", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "-", "1", "\n", "}", "else", "if", "other", "==", "nil", "{", "return", "1", "\n", "}", "\n", "if", "cmp", ":=", "mod", ".", "Package", ".", "Compare", "(", "other", ".", "Package", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "if", "cmp", ":=", "importsCompare", "(", "mod", ".", "Imports", ",", "other", ".", "Imports", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "return", "rulesCompare", "(", "mod", ".", "Rules", ",", "other", ".", "Rules", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "mod", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "mod", "*", "Module", ")", "Copy", "(", ")", "*", "Module", "{", "cpy", ":=", "*", "mod", "\n", "cpy", ".", "Rules", "=", "make", "(", "[", "]", "*", "Rule", ",", "len", "(", "mod", ".", "Rules", ")", ")", "\n", "for", "i", ":=", "range", "mod", ".", "Rules", "{", "cpy", ".", "Rules", "[", "i", "]", "=", "mod", ".", "Rules", "[", "i", "]", ".", "Copy", "(", ")", "\n", "}", "\n", "cpy", ".", "Imports", "=", "make", "(", "[", "]", "*", "Import", ",", "len", "(", "mod", ".", "Imports", ")", ")", "\n", "for", "i", ":=", "range", "mod", ".", "Imports", "{", "cpy", ".", "Imports", "[", "i", "]", "=", "mod", ".", "Imports", "[", "i", "]", ".", "Copy", "(", ")", "\n", "}", "\n", "cpy", ".", "Package", "=", "mod", ".", "Package", ".", "Copy", "(", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "mod", "." ]

[ "func", "(", "mod", "*", "Module", ")", "RuleSet", "(", "name", "Var", ")", "RuleSet", "{", "rs", ":=", "NewRuleSet", "(", ")", "\n", "for", "_", ",", "rule", ":=", "range", "mod", ".", "Rules", "{", "if", "rule", ".", "Head", ".", "Name", ".", "Equal", "(", "name", ")", "{", "rs", ".", "Add", "(", "rule", ")", "\n", "}", "\n", "}", "\n", "return", "rs", "\n", "}" ]

[ "RuleSet", "returns", "a", "RuleSet", "containing", "named", "rules", "in", "the", "mod", "." ]

[ "func", "(", "c", "*", "Comment", ")", "Equal", "(", "other", "*", "Comment", ")", "bool", "{", "return", "c", ".", "Location", ".", "Equal", "(", "other", ".", "Location", ")", "&&", "bytes", ".", "Equal", "(", "c", ".", "Text", ",", "other", ".", "Text", ")", "\n", "}" ]

[ "Equal", "returns", "true", "if", "this", "comment", "equals", "the", "other", "comment", ".", "Unlike", "other", "equality", "checks", "on", "AST", "nodes", "comment", "equality", "depends", "on", "location", "." ]

[ "func", "(", "pkg", "*", "Package", ")", "Compare", "(", "other", "*", "Package", ")", "int", "{", "return", "Compare", "(", "pkg", ".", "Path", ",", "other", ".", "Path", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "pkg", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "pkg", "*", "Package", ")", "Copy", "(", ")", "*", "Package", "{", "cpy", ":=", "*", "pkg", "\n", "cpy", ".", "Path", "=", "pkg", ".", "Path", ".", "Copy", "(", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "pkg", "." ]

[ "func", "IsValidImportPath", "(", "v", "Value", ")", "(", "err", "error", ")", "{", "switch", "v", ":=", "v", ".", "(", "type", ")", "{", "case", "Var", ":", "if", "!", "v", ".", "Equal", "(", "DefaultRootDocument", ".", "Value", ")", "&&", "!", "v", ".", "Equal", "(", "InputRootDocument", ".", "Value", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "case", "Ref", ":", "if", "err", ":=", "IsValidImportPath", "(", "v", "[", "0", "]", ".", "Value", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "v", "[", "1", ":", "]", "{", "if", "_", ",", "ok", ":=", "e", ".", "Value", ".", "(", "String", ")", ";", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "}", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "IsValidImportPath", "returns", "an", "error", "indicating", "if", "the", "import", "path", "is", "invalid", ".", "If", "the", "import", "path", "is", "invalid", "err", "is", "nil", "." ]

[ "func", "(", "imp", "*", "Import", ")", "Compare", "(", "other", "*", "Import", ")", "int", "{", "if", "imp", "==", "nil", "{", "if", "other", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "-", "1", "\n", "}", "else", "if", "other", "==", "nil", "{", "return", "1", "\n", "}", "\n", "if", "cmp", ":=", "Compare", "(", "imp", ".", "Path", ",", "other", ".", "Path", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "return", "Compare", "(", "imp", ".", "Alias", ",", "other", ".", "Alias", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "imp", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "imp", "*", "Import", ")", "Copy", "(", ")", "*", "Import", "{", "cpy", ":=", "*", "imp", "\n", "cpy", ".", "Path", "=", "imp", ".", "Path", ".", "Copy", "(", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "imp", "." ]

[ "func", "(", "imp", "*", "Import", ")", "Name", "(", ")", "Var", "{", "if", "len", "(", "imp", ".", "Alias", ")", "!=", "0", "{", "return", "imp", ".", "Alias", "\n", "}", "\n", "switch", "v", ":=", "imp", ".", "Path", ".", "Value", ".", "(", "type", ")", "{", "case", "Var", ":", "return", "v", "\n", "case", "Ref", ":", "if", "len", "(", "v", ")", "==", "1", "{", "return", "v", "[", "0", "]", ".", "Value", ".", "(", "Var", ")", "\n", "}", "\n", "return", "Var", "(", "v", "[", "len", "(", "v", ")", "-", "1", "]", ".", "Value", ".", "(", "String", ")", ")", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "Name", "returns", "the", "variable", "that", "is", "used", "to", "refer", "to", "the", "imported", "virtual", "document", ".", "This", "is", "the", "alias", "if", "defined", "otherwise", "the", "last", "element", "in", "the", "path", "." ]

[ "func", "(", "rule", "*", "Rule", ")", "Compare", "(", "other", "*", "Rule", ")", "int", "{", "if", "rule", "==", "nil", "{", "if", "other", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "-", "1", "\n", "}", "else", "if", "other", "==", "nil", "{", "return", "1", "\n", "}", "\n", "if", "cmp", ":=", "rule", ".", "Head", ".", "Compare", "(", "other", ".", "Head", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "if", "cmp", ":=", "util", ".", "Compare", "(", "rule", ".", "Default", ",", "other", ".", "Default", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "if", "cmp", ":=", "rule", ".", "Body", ".", "Compare", "(", "other", ".", "Body", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "return", "rule", ".", "Else", ".", "Compare", "(", "other", ".", "Else", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "rule", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "rule", "*", "Rule", ")", "Copy", "(", ")", "*", "Rule", "{", "cpy", ":=", "*", "rule", "\n", "cpy", ".", "Head", "=", "rule", ".", "Head", ".", "Copy", "(", ")", "\n", "cpy", ".", "Body", "=", "rule", ".", "Body", ".", "Copy", "(", ")", "\n", "if", "cpy", ".", "Else", "!=", "nil", "{", "cpy", ".", "Else", "=", "rule", ".", "Else", ".", "Copy", "(", ")", "\n", "}", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "rule", "." ]

[ "func", "(", "rule", "*", "Rule", ")", "Path", "(", ")", "Ref", "{", "if", "rule", ".", "Module", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "rule", ".", "Module", ".", "Package", ".", "Path", ".", "Append", "(", "StringTerm", "(", "string", "(", "rule", ".", "Head", ".", "Name", ")", ")", ")", "\n", "}" ]

[ "Path", "returns", "a", "ref", "referring", "to", "the", "document", "produced", "by", "this", "rule", ".", "If", "rule", "is", "not", "contained", "in", "a", "module", "this", "function", "panics", "." ]

[ "func", "NewHead", "(", "name", "Var", ",", "args", "...", "*", "Term", ")", "*", "Head", "{", "head", ":=", "&", "Head", "{", "Name", ":", "name", ",", "}", "\n", "if", "len", "(", "args", ")", "==", "0", "{", "return", "head", "\n", "}", "\n", "head", ".", "Key", "=", "args", "[", "0", "]", "\n", "if", "len", "(", "args", ")", "==", "1", "{", "return", "head", "\n", "}", "\n", "head", ".", "Value", "=", "args", "[", "1", "]", "\n", "return", "head", "\n", "}" ]

[ "NewHead", "returns", "a", "new", "Head", "object", ".", "If", "args", "are", "provided", "the", "first", "will", "be", "used", "for", "the", "key", "and", "the", "second", "will", "be", "used", "for", "the", "value", "." ]

[ "func", "(", "head", "*", "Head", ")", "DocKind", "(", ")", "DocKind", "{", "if", "head", ".", "Key", "!=", "nil", "{", "if", "head", ".", "Value", "!=", "nil", "{", "return", "PartialObjectDoc", "\n", "}", "\n", "return", "PartialSetDoc", "\n", "}", "\n", "return", "CompleteDoc", "\n", "}" ]

[ "DocKind", "returns", "the", "type", "of", "document", "produced", "by", "this", "rule", "." ]

[ "func", "(", "head", "*", "Head", ")", "Compare", "(", "other", "*", "Head", ")", "int", "{", "if", "head", "==", "nil", "{", "if", "other", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "-", "1", "\n", "}", "else", "if", "other", "==", "nil", "{", "return", "1", "\n", "}", "\n", "if", "cmp", ":=", "Compare", "(", "head", ".", "Args", ",", "other", ".", "Args", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "if", "cmp", ":=", "Compare", "(", "head", ".", "Name", ",", "other", ".", "Name", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "if", "cmp", ":=", "Compare", "(", "head", ".", "Key", ",", "other", ".", "Key", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "return", "Compare", "(", "head", ".", "Value", ",", "other", ".", "Value", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "head", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "head", "*", "Head", ")", "Copy", "(", ")", "*", "Head", "{", "cpy", ":=", "*", "head", "\n", "cpy", ".", "Args", "=", "head", ".", "Args", ".", "Copy", "(", ")", "\n", "cpy", ".", "Key", "=", "head", ".", "Key", ".", "Copy", "(", ")", "\n", "cpy", ".", "Value", "=", "head", ".", "Value", ".", "Copy", "(", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "head", "." ]

[ "func", "(", "head", "*", "Head", ")", "Vars", "(", ")", "VarSet", "{", "vis", ":=", "&", "VarVisitor", "{", "vars", ":", "VarSet", "{", "}", "}", "\n", "// TODO: improve test coverage for this.", "if", "head", ".", "Args", "!=", "nil", "{", "Walk", "(", "vis", ",", "head", ".", "Args", ")", "\n", "}", "\n", "if", "head", ".", "Key", "!=", "nil", "{", "Walk", "(", "vis", ",", "head", ".", "Key", ")", "\n", "}", "\n", "if", "head", ".", "Value", "!=", "nil", "{", "Walk", "(", "vis", ",", "head", ".", "Value", ")", "\n", "}", "\n", "return", "vis", ".", "vars", "\n", "}" ]

[ "Vars", "returns", "a", "set", "of", "vars", "found", "in", "the", "head", "." ]

[ "func", "(", "a", "Args", ")", "Copy", "(", ")", "Args", "{", "cpy", ":=", "Args", "{", "}", "\n", "for", "_", ",", "t", ":=", "range", "a", "{", "cpy", "=", "append", "(", "cpy", ",", "t", ".", "Copy", "(", ")", ")", "\n", "}", "\n", "return", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "a", "." ]

[ "func", "(", "a", "Args", ")", "SetLoc", "(", "loc", "*", "Location", ")", "{", "if", "len", "(", "a", ")", "!=", "0", "{", "a", "[", "0", "]", ".", "SetLocation", "(", "loc", ")", "\n", "}", "\n", "}" ]

[ "SetLoc", "sets", "the", "location", "on", "a", "." ]

[ "func", "(", "a", "Args", ")", "Vars", "(", ")", "VarSet", "{", "vis", ":=", "&", "VarVisitor", "{", "vars", ":", "VarSet", "{", "}", "}", "\n", "Walk", "(", "vis", ",", "a", ")", "\n", "return", "vis", ".", "vars", "\n", "}" ]

[ "Vars", "returns", "a", "set", "of", "vars", "that", "appear", "in", "a", "." ]

[ "func", "NewBody", "(", "exprs", "...", "*", "Expr", ")", "Body", "{", "for", "i", ",", "expr", ":=", "range", "exprs", "{", "expr", ".", "Index", "=", "i", "\n", "}", "\n", "return", "Body", "(", "exprs", ")", "\n", "}" ]

[ "NewBody", "returns", "a", "new", "Body", "containing", "the", "given", "expressions", ".", "The", "indices", "of", "the", "immediate", "expressions", "will", "be", "reset", "." ]

[ "func", "(", "body", "Body", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Serialize empty Body to empty array. This handles both the empty case and the", "// nil case (whereas by default the result would be null if body was nil.)", "if", "len", "(", "body", ")", "==", "0", "{", "return", "[", "]", "byte", "(", "`[]`", ")", ",", "nil", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "[", "]", "*", "Expr", "(", "body", ")", ")", "\n", "}" ]

[ "MarshalJSON", "returns", "JSON", "encoded", "bytes", "representing", "body", "." ]

[ "func", "(", "body", "*", "Body", ")", "Append", "(", "expr", "*", "Expr", ")", "{", "n", ":=", "len", "(", "*", "body", ")", "\n", "expr", ".", "Index", "=", "n", "\n", "*", "body", "=", "append", "(", "*", "body", ",", "expr", ")", "\n", "}" ]

[ "Append", "adds", "the", "expr", "to", "the", "body", "and", "updates", "the", "expr", "s", "index", "accordingly", "." ]

[ "func", "(", "body", "Body", ")", "Set", "(", "expr", "*", "Expr", ",", "pos", "int", ")", "{", "body", "[", "pos", "]", "=", "expr", "\n", "expr", ".", "Index", "=", "pos", "\n", "}" ]

[ "Set", "sets", "the", "expr", "in", "the", "body", "at", "the", "specified", "position", "and", "updates", "the", "expr", "s", "index", "accordingly", "." ]

[ "func", "(", "body", "Body", ")", "Copy", "(", ")", "Body", "{", "cpy", ":=", "make", "(", "Body", ",", "len", "(", "body", ")", ")", "\n", "for", "i", ":=", "range", "body", "{", "cpy", "[", "i", "]", "=", "body", "[", "i", "]", ".", "Copy", "(", ")", "\n", "}", "\n", "return", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "body", "." ]

[ "func", "(", "body", "Body", ")", "Contains", "(", "x", "*", "Expr", ")", "bool", "{", "for", "_", ",", "e", ":=", "range", "body", "{", "if", "e", ".", "Equal", "(", "x", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Contains", "returns", "true", "if", "this", "body", "contains", "the", "given", "expression", "." ]

[ "func", "(", "body", "Body", ")", "Hash", "(", ")", "int", "{", "s", ":=", "0", "\n", "for", "_", ",", "e", ":=", "range", "body", "{", "s", "+=", "e", ".", "Hash", "(", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "Hash", "returns", "the", "hash", "code", "for", "the", "Body", "." ]

[ "func", "(", "body", "Body", ")", "IsGround", "(", ")", "bool", "{", "for", "_", ",", "e", ":=", "range", "body", "{", "if", "!", "e", ".", "IsGround", "(", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsGround", "returns", "true", "if", "all", "of", "the", "expressions", "in", "the", "Body", "are", "ground", "." ]

[ "func", "(", "body", "Body", ")", "SetLoc", "(", "loc", "*", "Location", ")", "{", "if", "len", "(", "body", ")", "!=", "0", "{", "body", "[", "0", "]", ".", "SetLocation", "(", "loc", ")", "\n", "}", "\n", "}" ]

[ "SetLoc", "sets", "the", "location", "on", "body", "." ]

[ "func", "(", "body", "Body", ")", "Vars", "(", "params", "VarVisitorParams", ")", "VarSet", "{", "vis", ":=", "NewVarVisitor", "(", ")", ".", "WithParams", "(", "params", ")", "\n", "Walk", "(", "vis", ",", "body", ")", "\n", "return", "vis", ".", "Vars", "(", ")", "\n", "}" ]

[ "Vars", "returns", "a", "VarSet", "containing", "variables", "in", "body", ".", "The", "params", "can", "be", "set", "to", "control", "which", "vars", "are", "included", "." ]

[ "func", "NewExpr", "(", "terms", "interface", "{", "}", ")", "*", "Expr", "{", "return", "&", "Expr", "{", "Negated", ":", "false", ",", "Terms", ":", "terms", ",", "Index", ":", "0", ",", "With", ":", "nil", ",", "}", "\n", "}" ]

[ "NewExpr", "returns", "a", "new", "Expr", "object", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Complement", "(", ")", "*", "Expr", "{", "cpy", ":=", "*", "expr", "\n", "cpy", ".", "Negated", "=", "!", "cpy", ".", "Negated", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Complement", "returns", "a", "copy", "of", "this", "expression", "with", "the", "negation", "flag", "flipped", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Copy", "(", ")", "*", "Expr", "{", "cpy", ":=", "*", "expr", "\n\n", "switch", "ts", ":=", "expr", ".", "Terms", ".", "(", "type", ")", "{", "case", "[", "]", "*", "Term", ":", "cpyTs", ":=", "make", "(", "[", "]", "*", "Term", ",", "len", "(", "ts", ")", ")", "\n", "for", "i", ":=", "range", "ts", "{", "cpyTs", "[", "i", "]", "=", "ts", "[", "i", "]", ".", "Copy", "(", ")", "\n", "}", "\n", "cpy", ".", "Terms", "=", "cpyTs", "\n", "case", "*", "Term", ":", "cpy", ".", "Terms", "=", "ts", ".", "Copy", "(", ")", "\n", "}", "\n\n", "cpy", ".", "With", "=", "make", "(", "[", "]", "*", "With", ",", "len", "(", "expr", ".", "With", ")", ")", "\n", "for", "i", ":=", "range", "expr", ".", "With", "{", "cpy", ".", "With", "[", "i", "]", "=", "expr", ".", "With", "[", "i", "]", ".", "Copy", "(", ")", "\n", "}", "\n\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "expr", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Hash", "(", ")", "int", "{", "s", ":=", "expr", ".", "Index", "\n", "switch", "ts", ":=", "expr", ".", "Terms", ".", "(", "type", ")", "{", "case", "[", "]", "*", "Term", ":", "for", "_", ",", "t", ":=", "range", "ts", "{", "s", "+=", "t", ".", "Value", ".", "Hash", "(", ")", "\n", "}", "\n", "case", "*", "Term", ":", "s", "+=", "ts", ".", "Value", ".", "Hash", "(", ")", "\n", "}", "\n", "if", "expr", ".", "Negated", "{", "s", "++", "\n", "}", "\n", "for", "_", ",", "w", ":=", "range", "expr", ".", "With", "{", "s", "+=", "w", ".", "Hash", "(", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "Hash", "returns", "the", "hash", "code", "of", "the", "Expr", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "IncludeWith", "(", "target", "*", "Term", ",", "value", "*", "Term", ")", "*", "Expr", "{", "cpy", ":=", "*", "expr", "\n", "cpy", ".", "With", "=", "append", "(", "cpy", ".", "With", ",", "&", "With", "{", "Target", ":", "target", ",", "Value", ":", "value", "}", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "IncludeWith", "returns", "a", "copy", "of", "expr", "with", "the", "with", "modifier", "appended", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "IsEquality", "(", ")", "bool", "{", "terms", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n", "return", "terms", "[", "0", "]", ".", "Value", ".", "Compare", "(", "Equality", ".", "Ref", "(", ")", ")", "==", "0", "\n", "}" ]

[ "IsEquality", "returns", "true", "if", "this", "is", "an", "equality", "expression", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "IsAssignment", "(", ")", "bool", "{", "terms", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n", "return", "terms", "[", "0", "]", ".", "Value", ".", "Compare", "(", "Assign", ".", "Ref", "(", ")", ")", "==", "0", "\n", "}" ]

[ "IsAssignment", "returns", "true", "if", "this", "an", "assignment", "expression", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "IsCall", "(", ")", "bool", "{", "_", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "return", "ok", "\n", "}" ]

[ "IsCall", "returns", "true", "if", "this", "expression", "calls", "a", "function", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Operator", "(", ")", "Ref", "{", "terms", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "if", "!", "ok", "||", "len", "(", "terms", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "terms", "[", "0", "]", ".", "Value", ".", "(", "Ref", ")", "\n", "}" ]

[ "Operator", "returns", "the", "name", "of", "the", "function", "or", "built", "-", "in", "this", "expression", "refers", "to", ".", "If", "this", "expression", "is", "not", "a", "function", "call", "returns", "nil", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Operand", "(", "pos", "int", ")", "*", "Term", "{", "terms", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "idx", ":=", "pos", "+", "1", "\n", "if", "idx", "<", "len", "(", "terms", ")", "{", "return", "terms", "[", "idx", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Operand", "returns", "the", "term", "at", "the", "zero", "-", "based", "pos", ".", "If", "the", "expr", "does", "not", "include", "at", "least", "pos", "+", "1", "terms", "this", "function", "returns", "nil", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Operands", "(", ")", "[", "]", "*", "Term", "{", "terms", ",", "ok", ":=", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "return", "terms", "[", "1", ":", "]", "\n", "}" ]

[ "Operands", "returns", "the", "built", "-", "in", "function", "operands", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "IsGround", "(", ")", "bool", "{", "switch", "ts", ":=", "expr", ".", "Terms", ".", "(", "type", ")", "{", "case", "[", "]", "*", "Term", ":", "for", "_", ",", "t", ":=", "range", "ts", "[", "1", ":", "]", "{", "if", "!", "t", ".", "IsGround", "(", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "case", "*", "Term", ":", "return", "ts", ".", "IsGround", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsGround", "returns", "true", "if", "all", "of", "the", "expression", "terms", "are", "ground", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "SetOperator", "(", "term", "*", "Term", ")", "*", "Expr", "{", "expr", ".", "Terms", ".", "(", "[", "]", "*", "Term", ")", "[", "0", "]", "=", "term", "\n", "return", "expr", "\n", "}" ]

[ "SetOperator", "sets", "the", "expr", "s", "operator", "and", "returns", "the", "expr", "itself", ".", "If", "expr", "is", "not", "a", "call", "expr", "this", "function", "will", "panic", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "SetLocation", "(", "loc", "*", "Location", ")", "*", "Expr", "{", "expr", ".", "Location", "=", "loc", "\n", "return", "expr", "\n", "}" ]

[ "SetLocation", "sets", "the", "expr", "s", "location", "and", "returns", "the", "expr", "itself", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "UnmarshalJSON", "(", "bs", "[", "]", "byte", ")", "error", "{", "v", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "if", "err", ":=", "util", ".", "UnmarshalJSON", "(", "bs", ",", "&", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "unmarshalExpr", "(", "expr", ",", "v", ")", "\n", "}" ]

[ "UnmarshalJSON", "parses", "the", "byte", "array", "and", "stores", "the", "result", "in", "expr", "." ]

[ "func", "(", "expr", "*", "Expr", ")", "Vars", "(", "params", "VarVisitorParams", ")", "VarSet", "{", "vis", ":=", "NewVarVisitor", "(", ")", ".", "WithParams", "(", "params", ")", "\n", "Walk", "(", "vis", ",", "expr", ")", "\n", "return", "vis", ".", "Vars", "(", ")", "\n", "}" ]

[ "Vars", "returns", "a", "VarSet", "containing", "variables", "in", "expr", ".", "The", "params", "can", "be", "set", "to", "control", "which", "vars", "are", "included", "." ]

[ "func", "(", "w", "*", "With", ")", "Compare", "(", "other", "*", "With", ")", "int", "{", "if", "w", "==", "nil", "{", "if", "other", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "-", "1", "\n", "}", "else", "if", "other", "==", "nil", "{", "return", "1", "\n", "}", "\n", "if", "cmp", ":=", "Compare", "(", "w", ".", "Target", ",", "other", ".", "Target", ")", ";", "cmp", "!=", "0", "{", "return", "cmp", "\n", "}", "\n", "return", "Compare", "(", "w", ".", "Value", ",", "other", ".", "Value", ")", "\n", "}" ]

[ "Compare", "returns", "an", "integer", "indicating", "whether", "w", "is", "less", "than", "equal", "to", "or", "greater", "than", "other", "." ]

[ "func", "(", "w", "*", "With", ")", "Copy", "(", ")", "*", "With", "{", "cpy", ":=", "*", "w", "\n", "cpy", ".", "Value", "=", "w", ".", "Value", ".", "Copy", "(", ")", "\n", "cpy", ".", "Target", "=", "w", ".", "Target", ".", "Copy", "(", ")", "\n", "return", "&", "cpy", "\n", "}" ]

[ "Copy", "returns", "a", "deep", "copy", "of", "w", "." ]

[ "func", "(", "w", "With", ")", "Hash", "(", ")", "int", "{", "return", "w", ".", "Target", ".", "Hash", "(", ")", "+", "w", ".", "Value", ".", "Hash", "(", ")", "\n", "}" ]

[ "Hash", "returns", "the", "hash", "code", "of", "the", "With", "." ]

[ "func", "(", "w", "*", "With", ")", "SetLocation", "(", "loc", "*", "Location", ")", "*", "With", "{", "w", ".", "Location", "=", "loc", "\n", "return", "w", "\n", "}" ]

[ "SetLocation", "sets", "the", "location", "on", "w", "." ]

[ "func", "NewRuleSet", "(", "rules", "...", "*", "Rule", ")", "RuleSet", "{", "rs", ":=", "make", "(", "RuleSet", ",", "0", ",", "len", "(", "rules", ")", ")", "\n", "for", "_", ",", "rule", ":=", "range", "rules", "{", "rs", ".", "Add", "(", "rule", ")", "\n", "}", "\n", "return", "rs", "\n", "}" ]

[ "NewRuleSet", "returns", "a", "new", "RuleSet", "containing", "the", "given", "rules", "." ]

[ "func", "(", "rs", "*", "RuleSet", ")", "Add", "(", "rule", "*", "Rule", ")", "{", "for", "_", ",", "exist", ":=", "range", "*", "rs", "{", "if", "exist", ".", "Equal", "(", "rule", ")", "{", "return", "\n", "}", "\n", "}", "\n", "*", "rs", "=", "append", "(", "*", "rs", ",", "rule", ")", "\n", "}" ]

[ "Add", "inserts", "the", "rule", "into", "rs", "." ]

[ "func", "(", "rs", "RuleSet", ")", "Contains", "(", "rule", "*", "Rule", ")", "bool", "{", "for", "i", ":=", "range", "rs", "{", "if", "rs", "[", "i", "]", ".", "Equal", "(", "rule", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Contains", "returns", "true", "if", "rs", "contains", "rule", "." ]

[ "func", "(", "rs", "RuleSet", ")", "Diff", "(", "other", "RuleSet", ")", "RuleSet", "{", "result", ":=", "NewRuleSet", "(", ")", "\n", "for", "i", ":=", "range", "rs", "{", "if", "!", "other", ".", "Contains", "(", "rs", "[", "i", "]", ")", "{", "result", ".", "Add", "(", "rs", "[", "i", "]", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Diff", "returns", "a", "new", "RuleSet", "containing", "rules", "in", "rs", "that", "are", "not", "in", "other", "." ]

[ "func", "(", "rs", "RuleSet", ")", "Equal", "(", "other", "RuleSet", ")", "bool", "{", "return", "len", "(", "rs", ".", "Diff", "(", "other", ")", ")", "==", "0", "&&", "len", "(", "other", ".", "Diff", "(", "rs", ")", ")", "==", "0", "\n", "}" ]

[ "Equal", "returns", "true", "if", "rs", "equals", "other", "." ]

[ "func", "(", "rs", "RuleSet", ")", "Merge", "(", "other", "RuleSet", ")", "RuleSet", "{", "result", ":=", "NewRuleSet", "(", ")", "\n", "for", "i", ":=", "range", "rs", "{", "result", ".", "Add", "(", "rs", "[", "i", "]", ")", "\n", "}", "\n", "for", "i", ":=", "range", "other", "{", "result", ".", "Add", "(", "other", "[", "i", "]", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Merge", "returns", "a", "ruleset", "containing", "the", "union", "of", "rules", "from", "rs", "an", "other", "." ]

[ "func", "Runtime", "(", "term", "*", "ast", ".", "Term", ")", "func", "(", "*", "Basic", ")", "{", "return", "func", "(", "b", "*", "Basic", ")", "{", "b", ".", "runtime", "=", "term", "\n", "}", "\n", "}" ]

[ "Runtime", "returns", "an", "argument", "that", "sets", "the", "runtime", "on", "the", "authorizer", "." ]