Versions in this module Expand all Collapse all v0 v0.2.1 Feb 9, 2024 Changes in this version + const ANY_HTTPS_HOST_PATTERN + const AN_INCLUDED_CHUNK_SHOULD_ONLY_CONTAIN_DEFINITIONS + const ASSERTION_BUFF_WRITER_SIZE + const A_BOOL_LIT_IS_EXPECTED + const A_STRUCT_TYPE_IS_EXPECTED_AFTER_THE_STAR + const A_STRUCT_TYPE_NAME_IS_EXPECTED + const BOOL_ADDRESS_LESS_TYPE_ID + const BYTE_COUNT_UNIT + const BYTE_STREAM_BUFF_GROWTH_FACTOR + const BYTE_STREAM_MINIMUM_MICRO_WAIT_DURATION + const ByteRateLimit + const CANNOT_CHECK_MANIFEST_WITHOUT_PARENT + const CANNOT_CHECK_OBJECT_METAPROP_WITHOUT_PARENT + const CANNOT_CHECK_OBJECT_PROP_WITHOUT_PARENT + const CANNOT_CHECK_STRUCT_METHOD_DEF_WITHOUT_PARENT + const CHECK_ERR_PREFIX + const CHUNK_IMPORT_MOD_REL + const CHUNK_INCLUDE_REL + const CMD_PERM_RISK_SCORE + const CONSTRAINTS_KEY + const CTX_DONE_MICROTASK_CALLS_TIMEOUT + const DATABASES_SECTION_NOT_AVAILABLE_IN_EMBEDDED_MODULE_MANIFESTS + const DATABASES_SECTION_SHOULD_BE_AN_OBJECT_OR_ABS_PATH + const DATABASES__DB_ASSERT_SCHEMA_SHOULD_BE_PATT_IDENT_OR_OBJ_PATT + const DATABASES__DB_CONFIG_SHOULD_BE_AN_OBJECT + const DATABASES__DB_EXPECTED_SCHEMA_UPDATE_SHOULD_BE_BOOL_LIT + const DATABASES__DB_RESOLUTION_DATA_ONLY_NIL_AND_PATHS_SUPPORTED + const DATABASES__DB_RESOURCE_SHOULD_BE_HOST_OR_URL + const DATE_FORMAT_PATTERN_NAMESPACE + const DEFAULT_EDGE_TO_CHILD_TEXT + const DEFAULT_EDGE_TO_WATCHED_CHILD_TEXT + const DEFAULT_FETCH_TIMEOUT + const DEFAULT_IMPORT_TIMEOUT + const DEFAULT_IWD + const DEFAULT_LIST_PATTERN_MAX_ELEM_COUNT + const DEFAULT_MAX_HISTORY_LEN + const DEFAULT_MAX_MOD_GRAPH_PATH_LEN + const DEFAULT_MAX_OCCURRENCE + const DEFAULT_MAX_RAND_LEN + const DEFAULT_MAX_READ_FILE_SIZE + const DEFAULT_MAX_STREAM_CHUNK_SIZE + const DEFAULT_MAX_TESTED_STRING_BYTE_LENGTH + const DEFAULT_MICROTASK_ARRAY_SIZE + const DEFAULT_MIN_STREAM_CHUNK_SIZE + const DEFAULT_TRANSACTION_TIMEOUT + const DEFAULT_XML_ATTR_VALUE + const ELEMENTS_NOT_ALLOWED_IF_EMPTY_PROP_NAME + const ELEMENTS_NOT_ALLOWED_IN_MANIFEST + const ELEMENTS_NOT_ALLOWED_IN_PERMS_SECTION + const EMPTY_PROP_NAME_NOT_ALLOWED_IF_ELEMENTS + const ENV_SECTION_NOT_AVAILABLE_IN_EMBEDDED_MODULE_MANIFESTS + const ENV_SECTION_SHOULD_BE_AN_OBJECT_PATTERN + const ERR + const EXECUTION_CPU_TIME_LIMIT_NAME + const EXECUTION_TOTAL_LIMIT_NAME + const FIRST_VALID_CALLBACK_HANDLE + const FLOAT_ADDRESS_LESS_TYPE_ID + const FORBIDDEN_NODE_TYPE_IN_INCLUDABLE_CHUNK_IMPORTED_BY_PREINIT + const FREQ_LIMIT_SCALE + const FS_READ_PERM_RISK_SCORE + const FS_WRITE_PERM_RISK_SCORE + const FUNCTION_FRAME_PREFIX + const False + const FrequencyLimit + const GLOBAL_SCOPE + const HARD_MINIMUM_LAST_EVENT_AGE + const HIGH_RISK_SCORE_LEVEL + const HOST_ADDRESS_LESS_TYPE_ID + const HOST_DEFS_SECTION_SHOULD_BE_A_DICT + const HOST_PATTERN_RISK_MULTIPLIER + const HOST_RISK_MULTIPLIER + const HOST_SCHEME_NOT_SUPPORTED + const HTTP_PROVIDE_PERM_RISK_SCORE + const HTTP_READ_PERM_RISK_SCORE + const HTTP_WRITE_PERM_RISK_SCORE + const IDLE_EVENT_SOURCE_HANDLING_TICK_INTERVAL + const IMPORT_CONFIG__ALLOW_PROPNAME + const IMPORT_CONFIG__ARGUMENTS_PROPNAME + const IMPORT_CONFIG__VALIDATION_PROPNAME + const INCLUDED_FILE_PATH_SHOULD_NOT_CONTAIN_X + const INFINITE_STRING_PATTERN_NESTING_DEPTH + const INITIAL_BREAKPOINT_ID + const INITIAL_MODULE_HEAP_CAPACITY + const INITIAL_WORKING_DIR_PREFIX_VARNAME + const INITIAL_WORKING_DIR_VARNAME + const INOX_INCLUDED_CHUNK_RES_KIND + const INOX_MIMETYPE + const INOX_MODULE_RES_KIND + const INT_ADDRESS_LESS_TYPE_ID + const INVALID_ASSIGNMENT_ANONYMOUS_VAR_CANNOT_BE_ASSIGNED + const INVALID_ASSIGNMENT_EQUAL_ONLY_SUPPORTED_ASSIGNMENT_OPERATOR_FOR_SLICE_EXPRS + const INVALID_BREAK_OR_CONTINUE_STMT_SHOULD_BE_IN_A_FOR_OR_WALK_STMT + const INVALID_COMMANDS_PREFIX + const INVALID_FN_DECL_SHOULD_BE_TOP_LEVEL_STMT + const INVALID_KIND_SECTION_EMBEDDED_MOD_KINDS_NOT_ALLOWED + const INVALID_MAPPING_ENTRY_KEY_ONLY_SIMPL_LITS_AND_PATT_IDENTS + const INVALID_MEM_HOST_ONLY_VALID_VALUE + const INVALID_PRUNE_STMT_SHOULD_BE_IN_WALK_STMT + const INVALID_QUANTITY + const INVALID_RATE + const INVALID_SPAWN_EXPR_EXPR_SHOULD_BE_ONE_OF + const INVALID_SPAWN_GLOBALS_SHOULD_BE + const INVALID_SPAWN_ONLY_OBJECT_LITERALS_WITH_NO_SPREAD_ELEMENTS_SUPPORTED + const INVALID_VISIBILITY_DESC_KEY + const INVALID_VISIB_DESC_SHOULDNT_HAVE_ELEMENTS + const INVALID_VISIB_DESC_SHOULDNT_HAVE_METAPROPS + const INVALID_VISIB_INIT_BLOCK_SHOULD_CONT_OBJ + const INVOCATION_SECTION_NOT_AVAILABLE_IN_EMBEDDED_MODULE_MANIFESTS + const INVOCATION_SECTION_SHOULD_BE_AN_OBJECT + const IncomingMessageReceivedEventType + const JOB_SCHEDULING_TICK_INTERVAL + const JSON_UNTYPED_VALUE_SUFFIX + const JS_MAX_SAFE_INTEGER + const JS_MIN_SAFE_INTEGER + const KIND_SECTION_SHOULD_BE_A_STRING_LITERAL + const LAST_RESERVED_COLOR_ID + const LDB_MAIN_HOST + const LDB_SCHEME + const LIMITS_SECTION_SHOULD_BE_AN_OBJECT + const LINE_COUNT_UNIT + const LIST_SHRINK_DIVIDER + const LOCAL_PROC_HOST + const LOCAL_SCOPE + const LOWER_BOUND_OF_FLOAT_RANGE_LIT_SHOULD_BE_SMALLER_THAN_UPPER_BOUND + const LOWER_BOUND_OF_INT_RANGE_LIT_SHOULD_BE_SMALLER_THAN_UPPER_BOUND + const LTHREAD_PERM_RISK_SCORE + const LThreadSpawnedEventType + const MANIFEST_DATABASES_SECTION_NAME + const MANIFEST_DATABASE__ASSERT_SCHEMA_UPDATE_PROP_NAME + const MANIFEST_DATABASE__EXPECTED_SCHEMA_UPDATE_PROP_NAME + const MANIFEST_DATABASE__RESOLUTION_DATA_PROP_NAME + const MANIFEST_DATABASE__RESOURCE_PROP_NAME + const MANIFEST_ENV_SECTION_NAME + const MANIFEST_HOST_DEFINITIONS_SECTION_NAME + const MANIFEST_INVOCATION_SECTION_NAME + const MANIFEST_INVOCATION__ASYNC_PROP_NAME + const MANIFEST_INVOCATION__ON_ADDED_ELEM_PROP_NAME + const MANIFEST_KIND_SECTION_NAME + const MANIFEST_LIMITS_SECTION_NAME + const MANIFEST_NON_POSITIONAL_PARAM__CHAR_NAME_PROPNAME + const MANIFEST_NON_POSITIONAL_PARAM__DEFAULT_PROPNAME + const MANIFEST_NON_POSITIONAL_PARAM__NAME_PROPNAME + const MANIFEST_PARAMS_SECTION_NAME + const MANIFEST_PARAM__DESCRIPTION_PROPNAME + const MANIFEST_PARAM__PATTERN_PROPNAME + const MANIFEST_PERMS_SECTION_NAME + const MANIFEST_POSITIONAL_PARAM__REST_PROPNAME + const MANIFEST_PREINIT_FILES_SECTION_NAME + const MANIFEST_PREINIT_FILE__PATH_PROP_NAME + const MANIFEST_PREINIT_FILE__PATTERN_PROP_NAME + const MAXIMUM_RISK_SCORE + const MAX_CLONING_DEPTH + const MAX_COMPARISON_DEPTH + const MAX_DURATION + const MAX_FRAMES + const MAX_JOB_IDLE_DURATION + const MAX_JSON_REPR_WRITING_DEPTH + const MAX_LIMIT_VALUE + const MAX_MINIMUM_LAST_EVENT_AGE + const MAX_NAME_BYTE_LEN + const MAX_PREINIT_FILE_SIZE + const MAX_SMALL_STRING_SIZE_IN_LAZY_STR_CONCATENATION + const MAX_SUBSEQUENT_WAIT_WRITE_TX_COUNT + const MAX_TESTED_HOST_PATTERN_BYTE_LENGTH + const MAX_TESTED_PATH_BYTE_LENGTH + const MAX_TESTED_URL_BYTE_LENGTH + const MAX_UNION_PATTERN_FLATTENING_DEPTH + const MAX_UNWRAPPING_DEPTH + const MAX_VALUE_PRINT_DEPTH + const MAX_WAIT_CHAN_COUNT + const MAYBE_YOU_MEANT_TO_WRITE_A_PATH_LITERAL + const MAYBE_YOU_MEANT_TO_WRITE_A_PATH_PATTERN_LITERAL + const MAYBE_YOU_MEANT_TO_WRITE_A_URL_LITERAL + const MAYBE_YOU_MEANT_TO_WRITE_A_URL_PATTERN_LITERAL + const MEDIUM_RISK_SCORE_LEVEL + const MEM_HOSTNAME + const MIME_METADATA_KEY + const MINIMAL_STATE_ID + const MINIMUM_MOD_PRIORITY + const MIN_LAZY_STR_CONCATENATION_SIZE + const MIN_SHRINKABLE_LIST_LENGTH + const MISPLACED_COMPUTE_EXPR_SHOULD_BE_IN_DYNAMIC_MAPPING_EXPR_ENTRY + const MISPLACED_EXTEND_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_HOST_ALIAS_DEF_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_INCLUSION_IMPORT_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_MOD_IMPORT_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_PATTERN_DEF_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_PATTERN_NS_DEF_STATEMENT_TOP_LEVEL_STMT + const MISPLACED_POINTER_TYPE + const MISPLACED_READONLY_PATTERN_EXPRESSION + const MISPLACED_RECEPTION_HANDLER_EXPRESSION + const MISPLACED_RUNTIME_TYPECHECK_EXPRESSION + const MISPLACED_SENDVAL_EXPR + const MISPLACED_STRUCT_DEF_TOP_LEVEL_STMT + const MISPLACED_STRUCT_TYPE_NAME + const MISPLACE_YIELD_STATEMENT_ONLY_ALLOWED_IN_EMBEDDED_MODULES + const MISSING_LIFETIMEJOB_SUBJECT_PATTERN_NOT_AN_IMPLICIT_OBJ_PROP + const MODULE_IMPORTS_NOT_ALLOWED_IN_INCLUDED_CHUNK + const MOD_ARGS_VARNAME + const MOD_IMPORT_FETCH_TIMEOUT + const MOD_PREP_LOG_SRC + const NOT_STARTED_CONFLUENCE_STREAM + const NO_PERM_DESCRIBED_BY_STRINGS + const NO_PERM_DESCRIBED_BY_THIS_TYPE_OF_VALUE + const NO_SCHEME_SCHEME + const NO_SCHEME_SCHEME_NAME + const NO_SPREAD_IN_MANIFEST + const Nil + const OBJECT_CONSTRAINTS_VERIFICATION_TIMEOUT + const OBJ_REC_LIT_CANNOT_HAVE_METAPROP_KEYS + const ODB_SCHEME + const ONE_HOUR + const ONE_MILLISECOND + const ONE_MINUTE + const ONE_SECOND + const ONLY_GLOBALS_ARE_ACCESSIBLE_FROM_RIGHT_SIDE_OF_MAPPING_ENTRIES + const ONLY_URL_LITS_ARE_SUPPORTED_FOR_NOW + const OPTIONAL_DYN_MEMB_EXPR_NOT_SUPPORTED_YET + const PARAMS_SECTION_NOT_AVAILABLE_IN_EMBEDDED_MODULE_MANIFESTS + const PARAMS_SECTION_SHOULD_BE_AN_OBJECT + const PERMS_SECTION_SHOULD_BE_AN_OBJECT + const PREFIX_PATH_PATTERN_SUFFIX + const PREINIT_FILES_SECTION_NOT_AVAILABLE_IN_EMBEDDED_MODULE_MANIFESTS + const PREINIT_FILES_SECTION_SHOULD_BE_AN_OBJECT + const PREINIT_FILES__FILE_CONFIG_PATH_SHOULD_BE_ABS_PATH + const PREINIT_FILES__FILE_CONFIG_SHOULD_BE_AN_OBJECT + const QUOTED_SOURCE_LOG_FIELD_NAME + const READ_TX_PRIORITY + const READ_WRITE_TX_PRIORITY + const ROOT_PREFIX_PATH_PATTERN + const ROUTINE_POST_YIELD_PAUSE + const RUNE_COUNT_UNIT + const SCHEME_NOT_DB_SCHEME_OR_IS_NOT_SUPPORTED + const SECONDARY_EVENT_CHAN_CAP + const SELF_ACCESSIBILITY_EXPLANATION + const SERIALIZED_EVENT_PATTERN_VAL_PATTERN_KEY + const SERIALIZED_FLOAT_RANGE_PATTERN_MULT_OF + const SERIALIZED_FLOAT_RANGE_PATTERN_RANGE_KEY + const SERIALIZED_FLOAT_RANGE_START_END_KEY + const SERIALIZED_FLOAT_RANGE_START_EXCL_END_KEY + const SERIALIZED_FLOAT_RANGE_START_KEY + const SERIALIZED_FLOAT_RANGE_STRING_PATTERN_RANGE_KEY + const SERIALIZED_INT_RANGE_PATTERN_MULT_OF + const SERIALIZED_INT_RANGE_PATTERN_RANGE_KEY + const SERIALIZED_INT_RANGE_START_END_KEY + const SERIALIZED_INT_RANGE_START_KEY + const SERIALIZED_INT_RANGE_STRING_PATTERN_RANGE_KEY + const SERIALIZED_LIST_PATTERN_ELEMENTS_KEY + const SERIALIZED_LIST_PATTERN_ELEMENT_KEY + const SERIALIZED_LIST_PATTERN_MAX_COUNT_KEY + const SERIALIZED_LIST_PATTERN_MIN_COUNT_KEY + const SERIALIZED_OBJECT_PATTERN_ENTRIES_KEY + const SERIALIZED_OBJECT_PATTERN_ENTRY_IS_OPTIONAL_KEY + const SERIALIZED_OBJECT_PATTERN_ENTRY_PATTERN_KEY + const SERIALIZED_OBJECT_PATTERN_ENTRY_REQ_KEYS_KEY + const SERIALIZED_OBJECT_PATTERN_ENTRY_REQ_PATTERN_KEY + const SERIALIZED_OBJECT_PATTERN_INEXACT_KEY + const SERIALIZED_RECORD_PATTERN_ENTRIES_KEY + const SERIALIZED_RECORD_PATTERN_ENTRY_IS_OPTIONAL_KEY + const SERIALIZED_RECORD_PATTERN_ENTRY_PATTERN_KEY + const SERIALIZED_RECORD_PATTERN_INEXACT_KEY + const SERIALIZED_SECRET_PATTERN_VAL_PATTERN_KEY + const SERIALIZED_SECRET_PATTERN_VAL_PEM_ENCODED_KEY + const SERIALIZED_TUPLE_PATTERN_ELEMENTS_KEY + const SERIALIZED_TUPLE_PATTERN_ELEMENT_KEY + const SIMPLE_RATE_PER_SECOND_SUFFIX + const SMART_LOCK_HOLD_TIMEOUT + const SOURCE_LOG_FIELD_NAME + const STARTED_CONFLUENCE_STREAM + const STOPPED_CONFLUENCE_STREAM + const STREAM_ITERATION_WAIT_TIMEOUT + const STRUCT_TYPES_NOT_ALLOWED_AS_PARAMETER_TYPES + const STRUCT_TYPES_NOT_ALLOWED_AS_RETURN_TYPES + const STR_ADDRESS_LESS_TYPE_ID + const SYNC_CHAN_SIZE + const S_INVALID_URL_ENCODED_PATH + const S_INVALID_URL_ENCODED_STRING + const S_PATH_EXPR_PATH_LIMITATION + const S_PATH_INTERP_RESULT_LIMITATION + const S_PATH_SLICE_VALUE_LIMITATION + const S_QUERY_PARAM_VALUE_LIMITATION + const S_URL_EXPR_PATH_LIMITATION + const S_URL_EXPR_PATH_START_LIMITATION + const S_URL_EXPR_UNEXPECTED_HOST_IN_PARSED_URL_AFTER_EVAL + const S_URL_PATH_INTERP_RESULT_LIMITATION + const TEST_CASES_NOT_ALLOWED_IF_SUBSUITES_ARE_PRESENT + const TEST_CASE_STMTS_NOT_ALLOWED_OUTSIDE_OF_TEST_SUITES + const TEST_FULL_NAME_PART_SEP + const TEST_SUITE_STMTS_NOT_ALLOWED_INSIDE_TEST_CASE_STMTS + const TEST__MAX_FS_STORAGE_HINT + const THE_DATABASES_SECTION_SHOULD_BE_PRESENT + const THREADS_SIMULTANEOUS_INSTANCES_LIMIT_NAME + const TOKEN_BUCKET_CAPACITY_SCALE + const TOKEN_BUCKET_MANAGEMENT_TICK_INTERVAL + const TX_TIMEOUT_OPTION_NAME + const TotalLimit + const True + const UNEXPECTED_OTHER_PROPS_EXPR_OTHERPROPS_NO_IS_PRESENT + const UNKNOWN_PERM_RISK_SCORE + const UNKNOW_FILE_PATTERN_SENSITIVITY_MUTLIPLIER + const UNKNOW_FILE_SENSITIVITY_MULTIPLIER + const UNSIGNED_DECIMAL_FLOAT_REGEX + const UNSIGNED_ZERO_FLOAT_REGEX + const URL_ADDRESS_LESS_TYPE_ID + const URL_METADATA_KEY + const URL_PATTERN_RISK_MULTIPLIER + const URL_RISK_MULTIPLIER + const VAL_SHOULD_BE_DICT_LIT + const VAL_SHOULD_BE_KEYLIST_LIT + const VARS_CANNOT_BE_USED_IN_STRUCT_FIELD_DEFS + const VARS_NOT_ALLOWED_IN_PATTERN_AND_EXTENSION_OBJECT_PROPERTIES + const VAR_CONST_NOT_DECLARED_IF_YOU_MEANT_TO_DECLARE_CONSTANTS_GLOBAL_CONST_DECLS_ONLY_SUPPORTED_AT_THE_START_OF_THE_MODULE + const VISIBILITY_KEY + const VM_STACK_SIZE + const WAIT_FOR_READ_TXS_TIMEOUT + const WS_PROVIDE_PERM_RISK_SCORE + const WS_READ_PERM_RISK_SCORE + const WS_WRITE_PERM_RISK_SCORE + var ALL_VISIBLE_REPR_CONFIG = &ReprConfig + var ANSI_RESET_SEQUENCE = []byte(termenv.CSI + termenv.ResetSeq + "m") + var ANSI_RESET_SEQUENCE_STRING = string(ANSI_RESET_SEQUENCE) + var ANYVAL_PATTERN = &TypePattern + var ANY_ELEM_LIST_PATTERN = NewListPatternOf(SERIALIZABLE_PATTERN) + var ANY_ELEM_TUPLE_PATTERN = NewTuplePatternOf(SERIALIZABLE_PATTERN) + var ANY_PATH_STRING_PATTERN = NewStringPathPattern("") + var ASTNODE_PATTERN = &TypePattern + var BOOL_COMPTIME_TYPE = &BuiltinType + var BOOL_PATTERN = &TypePattern + var BOOL_TYPE = reflect.TypeOf(Bool(true)) + var BYTECOUNT_PATTERN = &TypePattern + var BYTECOUNT_TYPE = reflect.TypeOf(ByteCount(1)) + var BYTERATE_PATTERN = &TypePattern + var BYTERATE_TYPE = reflect.TypeOf(ByteRate(1)) + var BYTESLICE_PATTERN = &TypePattern + var BYTESTREAM_CHUNK_DATA_TYPE = BYTESLICE_PATTERN + var BYTE_PATTERN = &TypePattern + var BYTE_SLICE_TYPE = reflect.TypeOf((*ByteSlice)(nil)) + var BYTE_TYPE = reflect.TypeOf(Byte('a')) + var CHECKED_STR_TYPE = reflect.TypeOf(CheckedString{}) + var CHUNK_PROPNAMES = []string + var CLOSING_BRACKET_CLOSING_PAREN = []byte + var CLOSING_CURLY_BRACKET_CLOSING_PAREN = []byte + var CMD_PERM_TYPE = reflect.TypeOf(CommandPermission{}) + var COLON_SPACE = []byte + var COMMA = []byte + var COMMA_SPACE = []byte + var CTX_PTR_TYPE = reflect.TypeOf((*Context)(nil)) + var CryptoRandSource = &RandomnessSource + var DASH_DASH = []byte + var DATABASE_PROPNAMES = []string + var DATETIME_PATTERN = &TypePattern + var DATETIME_TYPE = reflect.TypeOf(DateTime{}) + var DATE_PATTERN = &TypePattern + var DATE_TYPE = reflect.TypeOf(Date{}) + var DEFAULT_DARKMODE_DISCRETE_COLOR = pprint.DEFAULT_DARKMODE_PRINT_COLORS.DiscreteColor + var DEFAULT_LIGHMODE_DISCRETE_COLOR = pprint.DEFAULT_LIGHTMODE_PRINT_COLORS.DiscreteColor + var DEFAULT_LOG_LEVELS = NewLogLevels(LogLevelsInitialization{ ... }) + var DEFAULT_NAMED_PATTERNS = map[string]Pattern + var DEFAULT_PATTERN_NAMESPACES = map[string]*PatternNamespace + var DEFAULT_PERM_RISK_SCORES = map[reflect.Type][]BasePermissionRiskScore + var DICTIONARY_PATTERN = &TypePattern + var DICT_TYPE = reflect.TypeOf((*Dictionary)(nil)) + var DIV_CLOSING_TAG = []byte + var DIV_OPENING_TAG = []byte + var DOT_DOT = []byte + var DOT_OPENING_CURLY_BRACKET = []byte + var DURATION_PATTERN = &TypePattern + var DURATION_TYPE = reflect.TypeOf(Duration(1)) + var DefaultRandSource = CryptoRandSource + var ELEMENTS_STREAM_CHUNK_DATA_TYPE = &ListPattern + var EMAIL_ADDR_PATTERN = &TypePattern + var EMAIL_ADDR_TYPE = reflect.TypeOf(EmailAddress("")) + var EMPTY_INEXACT_OBJECT_PATTERN = NewInexactObjectPattern(nil) + var EMPTY_INEXACT_RECORD_PATTERN = NewInexactRecordPattern(nil) + var EMPTY_INTERFACE_TYPE = reflect.TypeOf((*interface{})(nil)).Elem() + var EMPTY_MODULE_ARGS_PATTERN = NewModuleParamsPattern(nil, nil) + var ERROR_INTERFACE_TYPE = reflect.TypeOf((*error)(nil)).Elem() + var ERROR_PATTERN = &TypePattern + var ERROR_TYPE = reflect.TypeOf(Error{}) + var ERR_PROPNAMES = []string + var EVENT_PATTERN = &TypePattern + var EVENT_PATTERN_PATTERN = &TypePattern + var EVENT_PATTERN_TYPE = reflect.TypeOf((*EventPattern)(nil)) + var EVENT_SOURCE_INTERFACE_TYPE = reflect.TypeOf((*EventSource)(nil)).Elem() + var EVENT_TYPE = reflect.TypeOf((*Event)(nil)) + var EXACT_STRING_PATTERN_PATTERN = &TypePattern + var EXACT_STRING_PATTERN_TYPE = reflect.TypeOf((*ExactStringPattern)(nil)) + var EXACT_VALUE_PATTERN_PATTERN = &TypePattern + var EXACT_VALUE_PATTERN_TYPE = reflect.TypeOf((*ExactValuePattern)(nil)) + var EXECUTED_STEP_PROPNAMES = []string + var ElementKeyEncoding = base32.StdEncoding.WithPadding(base32.NoPadding) + var ErrAbsoluteModuleSourcePathUsedInURLImportedModule = errors.New("absolute module source path used in module imported from URL") + var ErrAlreadyAssociatedState = errors.New("context already has an associated state") + var ErrAlreadyBeingSnapshoted = errors.New("the filesystem is already being snapshoted") + var ErrAlreadySetTransactionEndCallback = errors.New("transaction end callback is already set") + var ErrArgsProvidedToModule = errors.New("cannot provide arguments when running module") + var ErrAttemptToCreateMutableSpecificTypeByteSlice = errors.New("attempt to create a mutable byte slice with specific content type") + var ErrAttemptToMutateFrozenValue = errors.New("attempt to mutate a frozen value") + var ErrAttemptToMutateReadonlyByteSlice = errors.New("attempt to write a readonly byte slice") + var ErrAttemptToSetCaptureGlobal = errors.New("attempt to set a captured global") + var ErrBothCtxFilesystemArgsProvided = errors.New("invalid arguments: both .CreateFilesystem & .Filesystem provided") + var ErrBothParentCtxArgsProvided = errors.New("invalid arguments: both .ParentContext & .ParentStdLibContext provided") + var ErrCannotAddIrreversibleEffect = errors.New("cannot add irreversible effect to transaction") + var ErrCannotAddNonSharableToSharedContainer = errors.New("cannot add a non sharable element to a shared container") + var ErrCannotApplyIncompleteMutation = errors.New("cannot apply an incomplete mutation") + var ErrCannotCreateDynamicMapInvocationValueInDynValNotIterable = errors.New(...) + var ErrCannotCreateDynamicMemberFromSharedValue = errors.New("cannot create dynamic member from shared value") + var ErrCannotCreateDynamicMemberMissingProperty = errors.New("cannot create dynamic member: property is missing") + var ErrCannotCreateIfCondNotBoolean = errors.New("cannot create dynamic if: condition value is not a boolean") + var ErrCannotDequeueFromEmptyList = errors.New("cannot dequeue from an empty list") + var ErrCannotEvaluateCompiledFunctionInTreeWalkEval = errors.New("cannot evaluate compiled function in a tree walk evaluation") + var ErrCannotFindDatabaseHost = errors.New("cannot find corresponding host of database") + var ErrCannotLockUnsharableValue = errors.New("cannot lock unsharable value") + var ErrCannotParse = errors.New("cannot parse") + var ErrCannotPopFromEmptyList = errors.New("cannot pop from an empty list") + var ErrCannotProvideLimitTokensForChildContext = errors.New("limit tokens cannot be set in new context's config if it is a child") + var ErrCannotReadWithNoCopy = errors.New("cannot read with no copy") + var ErrCannotReleaseUnregisteredResource = errors.New("cannot release unregistered resource") + var ErrCannotResolveDatabase = errors.New("cannot resolve database") + var ErrCannotSetProp = errors.New("cannot set property") + var ErrCannotSetValOfIndexKeyProp = errors.New("cannot set value of index key property") + var ErrCollectionElemNotFound = errors.New("collection element not found") + var ErrConstraintViolation = errors.New("constraint violation") + var ErrContentTypeParserNotFound = errors.New("parser not found for content type") + var ErrContextInUse = errors.New(...) + var ErrCtxAlreadyHasTransaction = errors.New("context already has a transaction") + var ErrCurrentSchemaNotEqualToExpectedSchema = errors.New("current schema not equal to expected schema") + var ErrDatabaseAlreadyOpen = errors.New("database is already open") + var ErrDatabaseClosed = errors.New("database is closed") + var ErrDatabaseOpenFunctionNotFound = errors.New("function to open database not found") + var ErrDatabaseSchemaAlreadyUpdatedOrNotAllowed = errors.New("database schema already updated or no longer allowed") + var ErrDatabaseSchemaOnlyUpdatableByOwnerState = errors.New("database schema can only be updated by owner state") + var ErrDebuggerAlreadyAttached = errors.New("debugger already attached") + var ErrDeepWatchingNotSupported = errors.New("deep watching is not supported by the watchable") + var ErrDefDriedUpSource = errors.New("definitively dried up source") + var ErrDestroyedTokenBucket = errors.New("token bucket is destroyed") + var ErrDirPathShouldEndInSlash = errors.New("directory's path should end with '/'") + var ErrDiscardedChunk = errors.New("chunk is discarded") + var ErrDoublePoolItemRelease = errors.New("pool item is already released") + var ErrDoubleUserDataDefinition = errors.New("cannot define a user data entry more than once") + var ErrDynCallNonFunctionCalee = errors.New("callee in dynamic call value is not a function") + var ErrEffectAlreadyApplied = errors.New("effect is already applied") + var ErrEffectsNotAllowedInReadonlyTransaction = errors.New("effects are not allowed in a readonly transaction") + var ErrEmptyHost = errors.New("empty host") + var ErrEmptyLongValuePath = errors.New("empty long value-path") + var ErrEmptyPath = errors.New("empty path") + var ErrEmptyPropertyName = errors.New("empty property name") + var ErrEmptyRingBuffer = errors.New("ring buffer is empty") + var ErrEmptyScheme = errors.New("empty scheme") + var ErrEmptyURL = errors.New("empty URL") + var ErrEndOfStream = errors.New("end of stream") + var ErrFailedStringPatternResolution = errors.New("failed to resolve string pattern") + var ErrFailedToAcquireResurce = errors.New("failed to acquire resource") + var ErrFailedToConvertValueToMatchingString = errors.New("failed to convert value to matching string") + var ErrFailedToLoadNonExistingValue = errors.New("failed to load non-existing value") + var ErrFailedToSnapshot = errors.New("failed to snapshot value") + var ErrFilePathShouldNotEndInSlash = errors.New("regular file's path should not end with '/'") + var ErrFileSizeExceedSpecifiedLimit = errors.New("file's size exceeds the specified limit") + var ErrFileToIncludeDoesNotExist = errors.New("file to include does not exist") + var ErrFileToIncludeIsAFolder = errors.New("file to include is a folder") + var ErrFileWatchingNotSupported = errors.New("file watching is not supported") + var ErrFinishedTransaction = errors.New("transaction is finished") + var ErrFinishingTransaction = errors.New("transaction is finishing") + var ErrFloatNotInPatternRange = errors.New("float is not in the pattern's range") + var ErrFloatOverflow = errors.New("float overflow") + var ErrFloatUnderflow = errors.New("float underflow") + var ErrForbiddenNodeinPreinit = errors.New("forbidden node type in preinit block") + var ErrFullPool = errors.New("pool is full") + var ErrFullRingBuffer = errors.New("ring buffer is full") + var ErrHandlerAlreadyAdded = errors.New("handler already added to event source") + var ErrHeldLockWithoutHolder = errors.New("held lock without holder") + var ErrImportCycleDetected = errors.New("import cycle detected") + var ErrImpossibleToDeterminateInitialWorkingDir = errors.New("impossible to determinate initial working directory") + var ErrImpossibleToVerifyPermissionForUrlHolderMutation = errors.New("impossible to verify permission for mutation of URL holder") + var ErrInconsistentObjectPattern = errors.New("inconsistent object pattern") + var ErrIndexOutOfRange = errors.New("index out of range") + var ErrInfFrequency = errors.New("infinite frequency") + var ErrInitialWorkingDirProvidedWithoutFS = errors.New(...) + var ErrInsertionIndexOutOfRange = errors.New("insertion index out of range") + var ErrIntDivisionByZero = errors.New("integer division by zero") + var ErrIntNotInPatternRange = errors.New("integer is not in the pattern's range") + var ErrIntOverflow = errors.New("integer overflow") + var ErrIntUnderflow = errors.New("integer underflow") + var ErrIntermediateDepthWatchingNotSupported = errors.New("intermediate (and deeper) watching is not supported by the watchable") + var ErrInvalidAccessSchemaNotUpdatedYet = errors.New("access to database is not allowed because schema is not updated yet") + var ErrInvalidDBValuePropRetrieval = errors.New(...) + var ErrInvalidDatabaseDirpath = errors.New("invalid database dir path") + var ErrInvalidDatabaseHost = errors.New("host of database is invalid") + var ErrInvalidDate = errors.New("invalid date") + var ErrInvalidDirPath = errors.New("invalid dir path") + var ErrInvalidEmailAdddres = errors.New("invalid email address per RFC 5322") + var ErrInvalidFormattingArgument = errors.New("invalid formatting argument") + var ErrInvalidHost = errors.New("invalid host") + var ErrInvalidInitialHeapCapacity = errors.New("invalid initial heap capacity") + var ErrInvalidInitialValue = errors.New("invalid initial value") + var ErrInvalidInputString = errors.New("invalid input string") + var ErrInvalidMigrationPseudoPath = errors.New("invalid migration pseudo path") + var ErrInvalidModuleKind = errors.New("invalid module kind") + var ErrInvalidModuleSourceURL = errors.New("invalid module source URL") + var ErrInvalidMutationPrefixSymbol = errors.New("invalid mutation prefix symbol") + var ErrInvalidNonDirPath = errors.New("invalid non-dir path") + var ErrInvalidOrUnsupportedJsonSchema = errors.New("invalid or unsupported JSON Schema") + var ErrInvalidOrderIdentifier = errors.New("invalid order identifier") + var ErrInvalidPoolConfig = errors.New("provided pool configuration is invalid") + var ErrInvalidProvidedArgCount = errors.New("number of provided arguments is invalid") + var ErrInvalidQuantity = errors.New("invalid quantity") + var ErrInvalidRenderingConfig = errors.New("invalid rendering configuration") + var ErrInvalidResourceContent = errors.New("invalid resource's content") + var ErrInvalidRuneRepresentation = errors.New("invalid rune representation") + var ErrInvalidStreamChunkData = errors.New("invalid stream chunk data") + var ErrInvalidStreamElement = errors.New("invalid stream element") + var ErrInvalidURL = errors.New("invalid URL") + var ErrInvalidURLPattern = errors.New("invalid URL pattern") + var ErrInvalidYear = errors.New("invalid year") + var ErrIrreversible = errors.New("effect is irreversible") + var ErrJSONImpossibleToDetermineType = errors.New("impossible to determine type") + var ErrJSONSchemaMixingIntFloatNotSupported = errors.New("JSON schemas mixing integers and floats are not supported") + var ErrJsonNotMatchingSchema = errors.New("JSON is not matching schema") + var ErrLThreadIsDone = errors.New("lthread is done") + var ErrLifetimeJobMetaValueShouldBeImmutable = errors.New("meta value of lifetime job should be immutable") + var ErrLimitNotPresentInContext = errors.New("limit not present in context") + var ErrLoadingRequireTransaction = errors.New("loading a value requires a transaction") + var ErrLockReEntry = errors.New("lock re-entry") + var ErrManagedWatchersNotSupported = errors.New("managed watchers are not supported") + var ErrMaxModuleImportDepthExceeded = fmt.Errorf("the module import depth has exceeded the maximum (%d)", ...) + var ErrMaximumCloningDepthReached = errors.New("maximum cloning depth reached, there is probably a cycle") + var ErrMaximumJSONReprWritingDepthReached = errors.New("maximum JSON representation writing depth reached") + var ErrMissingHostHostNameInHost = errors.New("missing hostname in host") + var ErrMissingManifest = errors.New("missing manifest") + var ErrMissingURLHostName = errors.New("missing hostname in URL") + var ErrMissingURLSpecificFeature = errors.New("missing URL-specific feature in URL (path, query or fragment)") + var ErrMissinggRuntimeTypecheckSymbData = errors.New("impossible to perform runtime typecheck because symbolic data is missing") + var ErrModifyImmutable = errors.New("cannot modify an immutable value") + var ErrMutableMessageData = errors.New("impossible to create a Message with mutable data") + var ErrMutablePublicationData = errors.New("impossible to create a publication with mutable data") + var ErrNaNinfinityOperand = errors.New("NaN or (+|-)infinity operand in floating point operation") + var ErrNaNinfinityResult = errors.New("result of floating point operation is NaN or (+|-)infinity") + var ErrNameCollisionWithInitialDatabasePropertyName = errors.New("name collision with initial database property name") + var ErrNegByteRate = errors.New("negative byte rate") + var ErrNegDuration = errors.New("negative duration") + var ErrNegFrequency = errors.New("negative frequency") + var ErrNegQuantityNotSupported = errors.New("negative quantities are not supported") + var ErrNegationWithOverflow = errors.New("integer negation with overflow") + var ErrNegativeLowerIndex = errors.New("negative lower index") + var ErrNewSchemaNotEqualToExpectedSchema = errors.New("new schema not equal to expected schema") + var ErrNoAssociatedState = errors.New("context has no associated state") + var ErrNoDatabaseSchemaUpdateExpected = errors.New("no database schema update is expected") + var ErrNoDefaultValue = errors.New("no default value") + var ErrNoFilesystemProvided = errors.New("no filesystem provided") + var ErrNoLoadFreeEntityFnRegistered = errors.New("no loading function registered for given type") + var ErrNoRepresentation = errors.New("no representation") + var ErrNonExistingNamedPattern = errors.New("non existing named pattern") + var ErrNonMatchingCachedModulePath = errors.New(...) + var ErrNonSupportedMetaProperty = errors.New("non-supported meta property") + var ErrNonUniqueDbOpenFnRegistration = errors.New("non unique open DB function registration") + var ErrNonUniqueEventSourceFactoryRegistration = errors.New("non unique event source factory registration") + var ErrNonUniqueGetSymbolicInitialFactoryRegistration = errors.New("non unique symbolic initial value factory registration") + var ErrNonUniqueLoadFreeEntityFnRegistration = errors.New("non unique loading function registration") + var ErrNotClonable = errors.New("not clonable") + var ErrNotComparable = errors.New("not comparable") + var ErrNotEnoughCliArgs = errors.New("not enough CLI arguments") + var ErrNotImplemented = errors.New("not implemented and won't be implemented in the near future") + var ErrNotImplementedYet = errors.New("not implemented yet") + var ErrNotInDebugMode = errors.New("not in debug mode") + var ErrNotMatchingSchemaFloatFound = errors.New("float was found but it does not match the schema") + var ErrNotMatchingSchemaIntFound = errors.New("integer was found but it does not match the schema") + var ErrNotOwnedPoolItem = errors.New("passed pool item is not owned by current pool") + var ErrNotRenderable = errors.New("value is not renderable") + var ErrNotRenderableUseCustomRenderer = fmt.Errorf("%w: use a custom renderer", ErrNotRenderable) + var ErrNotResourceName = errors.New("not a resource name") + var ErrNotSharableNorClonableUserDataValue = errors.New(...) + var ErrNotSortableByNestedValue = errors.New("not sortable by nested value") + var ErrNotSupportedSpecificMutation = errors.New("not supported specific mutation") + var ErrNotUniqueAliasDefinition = errors.New("cannot register a host alias more than once") + var ErrNotUniqueHostDefinitionDefinition = errors.New("cannot set host definition data more than once") + var ErrNotUniquePatternDefinition = errors.New("cannot register a pattern more than once") + var ErrNotUniquePatternNamespaceDefinition = errors.New("cannot register a pattern namespace more than once") + var ErrNotUniqueProtocolClient = errors.New("client already defined") + var ErrNotVisible = errors.New("not visible by context") + var ErrOnDoneMicrotasksNotAllowed = errors.New("'on done' microtasks are not allowed") + var ErrOutAndLoggerAlreadySet = errors.New(".Out & .Logger are already definitely set") + var ErrOwnerStateAlreadySet = errors.New("owner state already set") + var ErrOwnerStateNotSet = errors.New("owner state not set") + var ErrParsingErrorInManifestOrPreinit = errors.New("parsing error in manifest or preinit") + var ErrPathWithInvalidStart = errors.New("path with invalid start") + var ErrPatternDoesNotMatchValueToSerialize = errors.New("pattern does not match value to serialize") + var ErrPatternNotCallable = errors.New("pattern is not callable") + var ErrPatternRequiredToSerialize = errors.New("pattern required to serialize") + var ErrPrecisionLoss = errors.New("precision loss") + var ErrPublisherNotUniquelyIdentifiable = errors.New("publisher not uniquely identifiable") + var ErrQuantityLooLarge = errors.New("quantity is too large") + var ErrQuantityOverflow = errors.New("quantity overflow") + var ErrQuantityUnderflow = errors.New("quantity underflow") + var ErrRecursiveJSONSchemaNotSupported = errors.New("recursive JSON schema are not supported") + var ErrReprOfMutableValueCanChange = errors.New("the representation of a mutable value can change") + var ErrResourceHasHardcodedUrlMetaProperty = errors.New("resource has hardcoded _url_ metaproperty") + var ErrRingBufferTooMuchDataToWrite = errors.New("too much data to write to ring buffer") + var ErrRunningTransactionExpected = errors.New("running transaction expected") + var ErrSchemaCannotBeUpdatedInDevMode = errors.New("schema cannot be updated in dev mode") + var ErrSchemeWithInvalidStart = errors.New("scheme with invalid start") + var ErrSecretIsNotPEMEncoded = errors.New("secret is not PEM encoded") + var ErrSelfNotDefined = errors.New("self not defined") + var ErrSingleSegmentLongValuePath = errors.New("single-segment value-path") + var ErrSnapshotEntryNotAFile = errors.New("filesystem entry is not a file") + var ErrSnapshotEntryPathMustBeAbsolute = errors.New("snapshot file path must be absolute") + var ErrStackOverflow = errors.New("stack overflow") + var ErrStateIdNotSet = errors.New("state id not set") + var ErrStepNonPausedProgram = errors.New("impossible to step in the execution of a non-paused program") + var ErrStoppedWatcher = errors.New("stopped watcher") + var ErrStoppedWritableStream = errors.New("writable stream is stopped") + var ErrStrGroupMatchingOnlySupportedForPatternWithRegex = errors.New("group matching is only supported by string patterns with a regex for now") + var ErrStreamChunkWaitTimeout = errors.New("stream chunk wait timeout") + var ErrStreamElemWaitTimeout = errors.New("stream element wait timeout") + var ErrSubscriberNotUniquelyIdentifiable = errors.New("subscriber not uniquely identifiable") + var ErrTempDriedUpSource = errors.New("temporarily dried up source") + var ErrTestedHostPatternTooLarge = errors.New("tested host pattern is too large") + var ErrTestedPathTooLarge = errors.New("tested path is too large") + var ErrTestedStringTooLarge = errors.New("tested string is too large") + var ErrTestedURLTooLarge = errors.New("tested URL is too large") + var ErrTokenDepletionAlreadyPaused = errors.New("token depletion already paused") + var ErrTokenDepletionNotPaused = errors.New("token depletion is not paused") + var ErrTooDeepUnionPatternFlattening = errors.New("union pattern flattening is too deep") + var ErrTooManyWriteTxsWaited = errors.New("transaction has waited for too many write transactions to finish") + var ErrTopLevelEntitiesAlreadyLoaded = errors.New("top-level entities already loaded") + var ErrTopLevelEntityNamesShouldBeValidInoxIdentifiers = errors.New(...) + var ErrTransactionAlreadyStarted = errors.New("transaction has already started") + var ErrTransactionShouldBeStartedBySameContext = errors.New("a transaction should be started by the same context that created it") + var ErrTransactionsNotSupportedYet = errors.New("transactions not supported yet") + var ErrTriedToParseJSONRepr = errors.New("tried to parse json representation but failed") + var ErrTypeExtensionAlreadyRegistered = errors.New("type extension is already registered") + var ErrURLAlreadySet = errors.New("url already set") + var ErrURLNotCorrespondingToDefinedDB = errors.New("URL does not correspond to a defined database") + var ErrUnexpectedCharsInPropertyName = errors.New("unexpected char(s) in property name") + var ErrUnexpectedCharsInScheme = errors.New("unexpected char(s) in scheme") + var ErrUnexpectedSpaceInURL = errors.New("unexpected space in URL") + var ErrUnknownDynamicOp = errors.New("unknown dynamic operation") + var ErrUnknownStartFloatRange = errors.New("float range has unknown start") + var ErrUnknownStartIntRange = errors.New("integer range has unknown start") + var ErrUnknownStartQtyRange = errors.New("quantity range has unknown start") + var ErrUnreachable = errors.New("unreachable") + var ErrUnsupportedNestedValue = errors.New("unsupported nested value") + var ErrUnsupportedOrder = errors.New("unsupported order") + var ErrUnsupportedYamlNodeType = errors.New("unsupported YAML node type") + var ErrValueAlreadyInSysGraph = errors.New("value already in a system graph") + var ErrValueDoesNotAcceptURL = errors.New("value does not accept URL") + var ErrValueHasNoProperties = errors.New("value has no properties") + var ErrValueInExactPatternValueShouldBeImmutable = errors.New("the value in an exact value pattern should be immutable") + var ErrValueIsNotShared = errors.New("value is not shared") + var ErrValueNoId = errors.New("value has not an identifier") + var ErrValueNoURL = errors.New("value has not an URL") + var ErrValueNotInSysGraph = errors.New("value is not part of system graph") + var ErrValueNotPointer = errors.New("value is not a pointer") + var ErrValueNotSharableNorClonable = errors.New("value is not sharable nor clonable") + var ErrValueNotShared = errors.New("value is not shared") + var ErrWaitReadonlyTxsTimeout = errors.New("waiting for readonly txs timed out") + var ErrWatchTimeout = errors.New("watch timeout") + var ErrZeroOrNegAlignment = errors.New("zero or negative alignment") + var ErrZeroOrNegAllocationSize = errors.New("zero or negative allocation size") + var ErrmaxUnwrappingDepthReached = errors.New("maximum unwrapping depth reached") + var FILE_INFO_TYPE = reflect.TypeOf(FileInfo{}) + var FILE_MODE_PATTERN = &TypePattern + var FILE_MODE_TYPE = reflect.TypeOf(FileMode(0)) + var FILE_SENSITIVITY_MULTIPLIERS = []struct{ ... } + var FLOAT64_TYPE = reflect.TypeOf(Float(0)) + var FLOAT_COMPTIME_TYPE = &BuiltinType + var FLOAT_PATTERN = &TypePattern + var FLOAT_RANGE_PATTERN = &TypePattern + var FLOAT_RANGE_PATTERN_PATTERN = &TypePattern + var FLOAT_RANGE_PATTERN_TYPE = reflect.TypeOf(&FloatRangePattern{}) + var FLOAT_RANGE_STRING_PATTERN_PATTERN = &TypePattern + var FLOAT_RANGE_STRING_PATTERN_TYPE = reflect.TypeOf(&FloatRangeStringPattern{}) + var FLOAT_RANGE_TYPE = reflect.TypeOf(FloatRange{}) + var FREQUENCY_PATTERN = &TypePattern + var FREQUENCY_TYPE = reflect.TypeOf(Frequency(1)) + var FS_PERM_TYPE = reflect.TypeOf(FilesystemPermission{}) + var FS_TREE_DATA_ITEM_PROPNAMES = []string + var GLOBAL_STATE_PROPNAMES = []string + var HOSTPATTERN_PATTERN = &TypePattern + var HOST_PATTERN = &TypePattern + var HOST_PATT_TYPE = reflect.TypeOf(HostPattern("")) + var HOST_TYPE = reflect.TypeOf(Host("")) + var HTTP_PERM_TYPE = reflect.TypeOf(HttpPermission{}) + var IDENTIFIER_TYPE = reflect.TypeOf(Identifier("a")) + var IDENT_PATTERN = &TypePattern + var IMPLICITLY_REMOVED_ROUTINE_PERMS = []Permission + var IMPORT_CONFIG_SECTION_NAMES = []string + var INDEXABLE_INTERFACE_TYPE = reflect.TypeOf((*Indexable)(nil)).Elem() + var INDEXABLE_PATTERN = &TypePattern + var INITIAL_WORKING_DIR_PATH Path + var INITIAL_WORKING_DIR_PATH_PATTERN PathPattern + var INT_COMPTIME_TYPE = &BuiltinType + var INT_PATTERN = &TypePattern + var INT_RANGE_PATTERN = &TypePattern + var INT_RANGE_PATTERN_PATTERN = &TypePattern + var INT_RANGE_PATTERN_TYPE = reflect.TypeOf(&IntRangePattern{}) + var INT_RANGE_STRING_PATTERN_PATTERN = &TypePattern + var INT_RANGE_STRING_PATTERN_TYPE = reflect.TypeOf(&IntRangeStringPattern{}) + var INT_RANGE_TYPE = reflect.TypeOf(IntRange{}) + var INT_TYPE = reflect.TypeOf(Int(1)) + var ITERABLE_INTERFACE_TYPE = reflect.TypeOf((*Iterable)(nil)).Elem() + var ITERABLE_PATTERN = &TypePattern + var JSON_SCHEMA_TYPE_TO_PATTERN = map[string]Pattern + var KEYLIST_PATTERN = &TypePattern + var KEYLIST_TYPE = reflect.TypeOf(KeyList{}) + var LF_CR = []byte + var LINECOUNT_PATTERN = &TypePattern + var LINECOUNT_TYPE = reflect.TypeOf(LineCount(1)) + var LIST_CLOSING_TAG = []byte + var LIST_OPENING_TAG = []byte + var LIST_PATTERN = &TypePattern + var LIST_PATTERN_PATTERN = &TypePattern + var LIST_PATTERN_TYPE = reflect.TypeOf((*ListPattern)(nil)) + var LIST_PTR_TYPE = reflect.TypeOf((*List)(nil)) + var LONG_VALUEPATH_PATTERN = &TypePattern + var LONG_VALUE_PATH_TYPE = reflect.TypeOf((*LongValuePath)(nil)) + var MANIFEST_DATABASE_PROPNAMES = []string + var MANIFEST_SECTION_NAMES = []string + var MAX_CHAR_COUNT_MAXIMUM_FLOAT_64 = max(len(strconv.FormatFloat(math.MaxFloat64, 'f', -1, 64)), ...) + var MAX_INT64 = big.NewInt(math.MaxInt64) + var MAX_UINT64 = big.NewInt(0) + var MODULE_KIND_NAMES = [...]string + var MODULE_KIND_TO_ALLOWED_SECTION_NAMES = map[ModuleKind][]string + var MODULE_TYPE = reflect.TypeOf((*Module)(nil)) + var MOD_PATTERN = &TypePattern + var MSG_PATTERN = &TypePattern + var MSG_PROPNAMES = []string + var MSG_TYPE = reflect.TypeOf(Message{}) + var MUTATION_KIND_NAMES = [...]string + var MUTATION_PATTERN = &TypePattern + var MUTATION_PATTERN_PATTERN = &TypePattern + var MUTATION_PATTERN_TYPE = reflect.TypeOf((*MutationPattern)(nil)) + var MUTATION_TYPE = reflect.TypeOf(Mutation{}) + var NAMED_SEGMENT_PATH_PATTERN = &TypePattern + var NAMED_SEGMENT_PATH_PATTERN_TYPE = reflect.TypeOf((*NamedSegmentPathPattern)(nil)) + var NEVER_PATTERN = &TypePattern + var NIL_PATTERN = &TypePattern + var NIL_TYPE = reflect.TypeOf(Nil) + var NODE_TYPE = reflect.TypeOf(AstNode{}) + var NOT_ACCESSIBLE_PATTERNS = map[string]Pattern + var NewDefaultContext NewDefaultContextFn + var NewDefaultGlobalState NewDefaultGlobalStateFn + var OBJECT_PATTERN = &TypePattern + var OBJECT_PATTERN_PATTERN = &TypePattern + var OBJECT_PATTERN_TYPE = reflect.TypeOf((*ObjectPattern)(nil)) + var OBJECT_TYPE = reflect.TypeOf((*Object)(nil)) + var OPTIONAL_PARAM_TYPE = reflect.TypeOf((*optionalParam)(nil)).Elem() + var OPTION_PATTERN = &TypePattern + var OPTION_TYPE = reflect.TypeOf(Option{}) + var ORDERED_PAIR_PATTERN = &TypePattern + var ORDERED_PAIR_TYPE = reflect.TypeOf((*OrderedPair)(nil)) + var OpcodeConstantIndexes = [...][]bool + var OpcodeNames = [...]string + var OpcodeOperands = [...][]int + var PATHPATTERN_PATTERN = &TypePattern + var PATH_PATTERN = &TypePattern + var PATH_PATT_TYPE = reflect.TypeOf(PathPattern("/")) + var PATH_TYPE = reflect.TypeOf(Path("/")) + var PATTERN_INTERFACE_TYPE = reflect.TypeOf((*Pattern)(nil)).Elem() + var PATTERN_PATTERN = &TypePattern + var PERIODIC_WATCHER_GOROUTINE_TICK_INTERVAL = 100 * time.Microsecond + var PORT_PATTERN = &TypePattern + var PORT_TYPE = reflect.TypeOf(Port{}) + var PROCESS_BEGIN_TIME = time.Now().UTC() + var PROPNAME_PATTERN = &TypePattern + var PROPNAME_TYPE = reflect.TypeOf(PropertyName("a")) + var READABLE_INTERFACE_TYPE = reflect.TypeOf((*Readable)(nil)).Elem() + var READABLE_PATTERN = &TypePattern + var READER_INTERFACE_TYPE = reflect.TypeOf((*Reader)(nil)) + var READER_PATTERN = &TypePattern + var RECORD_PATTERN = &TypePattern + var RECORD_PATTERN_PATTERN = &TypePattern + var RECORD_PATTERN_TYPE = reflect.TypeOf((*RecordPattern)(nil)) + var RECORD_TYPE = reflect.TypeOf((*Record)(nil)) + var REGEX_PATTERN_PATTERN = &TypePattern + var REGEX_PATTERN_TYPE = reflect.TypeOf(&RegexPattern{}) + var REGULAR_STR_TYPE = reflect.TypeOf("") + var RESOURCE_NAME_INTERFACE_TYPE = reflect.TypeOf((*ResourceName)(nil)).Elem() + var RING_BUFFER_PROPNAMES = []string + var ROUTINE_GROUP_PROPNAMES = []string + var ROUTINE_PERM_TYPE = reflect.TypeOf(LThreadPermission{}) + var ROUTINE_PROPNAMES = []string + var RUNECOUNT_PATTERN = &TypePattern + var RUNECOUNT_TYPE = reflect.TypeOf(RuneCount(1)) + var RUNESLICE_PATTERN = &TypePattern + var RUNE_PATTERN = &TypePattern + var RUNE_RANGE_PATTERN = &TypePattern + var RUNE_RANGE_TYPE = reflect.TypeOf(RuneRange{}) + var RUNE_SLICE_PROPNAMES = []string + var RUNE_SLICE_TYPE = reflect.TypeOf((*RuneSlice)(nil)) + var RUNE_TYPE = reflect.TypeOf(Rune('a')) + var SCHEME_PATTERN = &TypePattern + var SCHEME_TYPE = reflect.TypeOf(Scheme("")) + var SECRET_PATTERN = &TypePattern + var SECRET_PATTERN_PATTERN = &TypePattern + var SECRET_PATTERN_TYPE = reflect.TypeOf(&SecretPattern{}) + var SECRET_PEM_STRING_PATTERN = NewSecretPattern(NewPEMRegexPattern(".*"), true) + var SECRET_STRING_PATTERN = NewSecretPattern(NewRegexPattern(".*"), false) + var SECRET_TYPE = reflect.TypeOf((*Secret)(nil)) + var SELF_SENSITIVE_DATA_NAMES = map[string]struct{ ... } + var SERIALIZABLE_ITERABLE_INTERFACE_TYPE = reflect.TypeOf((*SerializableIterable)(nil)).Elem() + var SERIALIZABLE_ITERABLE_PATTERN = &TypePattern + var SERIALIZABLE_PATTERN = &TypePattern + var SERIALIZABLE_TYPE = reflect.TypeOf((*Serializable)(nil)).Elem() + var SHARP_OPENING_PAREN = []byte + var SLASH_SECOND_BYTES = []byte + var SOURCE_POS_PATTERN = NewInexactRecordPattern([]RecordPatternEntry{ ... }) + var SOURCE_POS_RECORD_PROPNAMES = []string + var STATIC_CHECK_DATA_PROP_NAMES = []string + var STRING_COMPTIME_TYPE = &BuiltinType + var STRING_LIKE_PSEUDOPROPS = []string + var STRING_PATTERN = &TypePattern + var STRING_TYPE = reflect.TypeOf(String("")) + var STR_LIKE_INTERFACE_TYPE = reflect.TypeOf((*StringLike)(nil)).Elem() + var STR_PATTERN = &TypePattern + var STR_PATTERN_PATTERN = &TypePattern + var SYMBOLIC_DATA_PROP_NAMES = []string + var SYSGRAPH_EDGE_TYPE = reflect.TypeOf(SystemGraphEdge{}) + var SYSGRAPH_NODE_PATTERN = &TypePattern + var SYSGRAPH_NODE_TYPE = reflect.TypeOf((*SystemGraphNode)(nil)) + var SYSGRAPH_PATTERN = &TypePattern + var SYSGRAPH_TYPE = reflect.TypeOf((*SystemGraph)(nil)) + var SYSTEM_GRAPH_EVENT_PROPNAMES = []string + var SYSTEM_GRAPH_NODE_PROPNAMES = []string + var SYSTEM_GRAPH_PROPNAMES = []string + var SYSTEM_GRAP_EDGE_PROPNAMES = []string + var S_FALSE = []byte + var S_TRUE = []byte + var TEST_CASE_RESULT_DARK_MODE_PRETTY_PRINT_CONFIG = &PrettyPrintConfig + var TEST_CASE_RESULT_LIGTH_MODE_PRETTY_PRINT_CONFIG = &PrettyPrintConfig + var THREE_DOTS = []byte + var TIME_CLOSING_TAG = []byte + var TIME_OPENING_TAG = []byte + var TUPLE_PATTERN = &TypePattern + var TUPLE_PATTERN_PATTERN = &TypePattern + var TUPLE_PATTERN_TYPE = reflect.TypeOf((*TuplePattern)(nil)) + var TUPLE_TYPE = reflect.TypeOf((*Tuple)(nil)) + var TYPE_PATTERN_PATTERN = &TypePattern + var TYPE_PATTERN_TYPE = reflect.TypeOf((*TypePattern)(nil)) + var ULID_PATTERN = &TypePattern + var ULID_STRING_PATTERN = NewParserBasePattern(&ulidParser{}) + var ULID_TYPE = reflect.TypeOf(ULID{}) + var URLPATTERN_PATTERN = &TypePattern + var URL_PATTERN = &TypePattern + var URL_PATT_TYPE = reflect.TypeOf(URLPattern("")) + var URL_TYPE = reflect.TypeOf(URL("")) + var UUIDv4_PATTERN = &TypePattern + var UUIDv4_STRING_PATTERN = NewParserBasePattern(&uuidv4Parser{}) + var UUIDv4_TYPE = reflect.TypeOf(UUIDv4{}) + var UnknownYamlNodeType = errors.New("unknown YAML node type") + var VALUEPATH_PATTERN = &TypePattern + var VALUE_HISTORY_PATTERN = &TypePattern + var VALUE_HISTORY_PROPNAMES = []string + var VALUE_HISTORY_TYPE = reflect.TypeOf((*ValueHistory)(nil)) + var VALUE_PATH_INTERFACE__TYPE = reflect.TypeOf((*ValuePath)(nil)).Elem() + var VALUE_RECEIVER_INTERFACE_TYPE = reflect.TypeOf((*MessageReceiver)(nil)).Elem() + var VALUE_RECEIVER_PATTERN = &TypePattern + var VALUE_TYPE = reflect.TypeOf((*Value)(nil)).Elem() + var VAL_PATTERN = &TypePattern + var WRAPPED_WATCHER_STREAM_CHUNK_DATA_TYPE = &ListPattern + var WS_PERM_TYPE = reflect.TypeOf(WebsocketPermission{}) + var YEAR_PATTERN = &TypePattern + var YEAR_TYPE = reflect.TypeOf(Year{}) + func AddModuleTreeToResourceGraph(m *Module, g *ResourceGraph, ctx *Context, ignoreBadImports bool) error + func AddValidPathPrefix(s string) (string, error) + func AppendTrailingSlashIfNotPresent[S ~string](s S) S + func AreDefaultMaxRequestHandlerLimitsSet() bool + func AreDefaultRequestHandlingLimitsSet() bool + func AreDefaultScriptLimitsSet() bool + func ChildLoggerForSource(logger zerolog.Logger, src string) zerolog.Logger + func CombineParsingErrorValues(errs []Error, positions []parse.SourcePositionRange) error + func ComputeProgramRiskScore(mod *Module, manifest *Manifest) (totalScore RiskScore, requiredPerms []Permission) + func DeallocAll(h *ModuleHeap) + func DoIO2[T any](ctx *Context, fn func() (T, error)) (T, error) + func DoIO[T any](ctx *Context, fn func() T) T + func FileStat(f billy.File, fls billy.Basic) (os.FileInfo, error) + func FindGroupMatchesForRegex(ctx *Context, regexp *regexp.Regexp, s string, config GroupMatchesFindConfig) (groups [][]string, err error) + func FmtErrInvalidArgument(v Value) error + func FmtErrInvalidArgumentAtPos(v Value, pos int) error + func FmtPropOfArgXShouldBeOfTypeY(propName string, argName string, typename string, value Value) error + func FmtUnexpectedElementAtIndexOfArgShowVal(element Value, keyIndex int, argName string) error + func FmtUnexpectedElementInPropIterableShowVal(element Value, propertyName string) error + func FmtUnexpectedValueAtKeyofArgShowVal(val Value, key string, argName string) error + func ForEachValueInIterable(ctx *Context, iterable Iterable, fn func(Value) error) error + func FormatErrPropertyDoesNotExist(name string, v Value) error + func FormatIndexableShouldHaveLen(length int) string + func FormatInstructions(ctx *Context, b []byte, posOffset int, leftPadding string, constants []Value) []string + func FormatRuntimeTypeCheckFailed(pattern Pattern, ctx *Context) error + func GetColorizedChunk(chunk *parse.Chunk, code []rune, lightMode bool, fgColorSequence []byte) string + func GetConcreteGoFuncFromSymbolic(fn *symbolic.GoFunction) (reflect.Value, bool) + func GetFullColorSequence(color termenv.Color, bg bool) []byte + func GetJSONRepresentation(v Serializable, ctx *Context, pattern Pattern) string + func GetJSONRepresentationWithConfig(v Serializable, ctx *Context, config JSONSerializationConfig) (string, error) + func GetPathPatternSensitivityMultiplier(patt PathPattern) int + func GetPathSensitivityMultiplier(pth Path) int + func GetStringifiedSymbolicValue(ctx *Context, v Value, wide bool) (string, error) + func GetWalkEntries(fls afs.Filesystem, walkedDirPath Path) (entries [][]fs.DirEntry, paths [][]string) + func HasIntegralRepresentation(q Quantity) bool + func HeapAddressUintptr(addr HeapAddress) uintptr + func InspectPrint[T any](w *bufio.Writer, v T) + func IsAtomSensitive(v Value) bool + func IsIndexKey(key string) bool + func IsSensitiveProperty(ctx *Context, name string, value Value) bool + func IsSharable(v Value, originState *GlobalState) (bool, string) + func IsSharableOrClonable(v Value, originState *GlobalState) (bool, string) + func IsShared(v Value) bool + func IsSimpleInoxVal(v Value) bool + func IsSimpleInoxValOrOption(v Value) bool + func IsStaticallyCheckDBFunctionRegistered(scheme Scheme) bool + func IsSymbolicEquivalentOfGoFunctionRegistered(fn any) bool + func IterateAll(ctx *Context, it Iterator) [][2]Value + func MakeInstruction(opcode Opcode, operands ...int) []byte + func MapInstructions(b []byte, constants []Value, callbackFn InstructionCallbackFn) ([]byte, error) + func MinMaxOf(ctx *Context, first Value, others ...Value) (Value, Value) + func MustGetJSONRepresentationWithConfig(v Serializable, ctx *Context, config JSONSerializationConfig) string + func NewCompiler(mod *Module, globals map[string]Value, symbolicData *symbolic.Data, ...) *compiler + func NewStoppedWatcher(config WatcherConfiguration) stoppedWatcher + func NoPatternOrAny(p Pattern) bool + func ParseFileChunk(absoluteSourcePath string, fls afs.Filesystem) (*parse.ParsedChunkSource, error) + func ParseLocalIncludedFiles(mod *Module, ctx *Context, fls afs.Filesystem, ...) (unrecoverableError error) + func ParseOrValidateResourceContent(ctx *Context, resourceContent []byte, ctype Mimetype, ...) (res Value, contentType Mimetype, err error) + func PrepareExtractionModeIncludableChunkfile(args IncludableChunkfilePreparationArgs) (state *GlobalState, _ *Module, _ *IncludedChunk, finalErr error) + func PrepareLocalModule(args ModulePreparationArgs) (state *GlobalState, mod *Module, manif *Manifest, finalErr error) + func PrettyPrint(v Value, w io.Writer, config *PrettyPrintConfig, depth, parentIndentCount int) (err error) + func PrettyPrintList(list underlyingList, w *bufio.Writer, config *PrettyPrintConfig, depth int, ...) + func PrintColorizedChunk(w io.Writer, chunk *parse.Chunk, code []rune, lightMode bool, ...) + func PrintType[T any](w *bufio.Writer, v T) + func Publish(ctx *Context, publisher Value, data Value) error + func ReadFileInFS(fls billy.Basic, name string, maxSize int32) ([]byte, error) + func ReadOperands(numOperands []int, instruction []byte) (operands []int, offset int) + func RegisterAddressLessType(typ reflect.Type) + func RegisterDefaultPattern(s string, m Pattern) + func RegisterDefaultPatternNamespace(s string, ns *PatternNamespace) + func RegisterEventSourceFactory(scheme Scheme, factory EventSourceFactory) + func RegisterLimit(name string, kind LimitKind, minimumLimit int64) + func RegisterLoadFreeEntityFn(patternType reflect.Type, fn LoadSelfManagedEntityFn) + func RegisterOpenDbFn(scheme Scheme, fn OpenDBFn) + func RegisterParser(mime Mimetype, p StatelessParser) + func RegisterPatternDeserializer(patternTypePattern *TypePattern, deserializer PatternDeserializer) + func RegisterPermissionTypesInGob() + func RegisterRenderer(t reflect.Type, fn RenderingFn) + func RegisterSimpleValueTypesInGob() + func RegisterStaticallyCheckDbResolutionDataFn(scheme Scheme, fn StaticallyCheckDbResolutionDataFn) + func RegisterStaticallyCheckHostDefinitionFn(scheme Scheme, fn StaticallyCheckHostDefinitionFn) + func RegisterSymbolicGoFunction(fn any, symbolicFn any) + func RegisterSymbolicGoFunctions(entries []any) + func Render(ctx *Context, w io.Writer, renderable Renderable, config RenderingInput) (int, error) + func Same(a, b Value) bool + func SamePointer(a, b interface{}) bool + func SendVal(ctx *Context, value Value, r MessageReceiver, sender Value) error + func SetDefaultMaxRequestHandlerLimits(limits []Limit) + func SetDefaultRequestHandlingLimits(limits []Limit) + func SetDefaultScriptLimits(limits []Limit) + func SetInitialWorkingDir(getWd func() (string, error)) + func SetNewDefaultContext(fn NewDefaultContextFn) + func SetNewDefaultGlobalStateFn(fn NewDefaultGlobalStateFn) + func Share[T PotentiallySharable](v T, originState *GlobalState) T + func Sleep(ctx *Context, d Duration) + func Stringify(v Value, ctx *Context) string + func StringifyWithConfig(v Value, config *PrettyPrintConfig) string + func Subscribe(ctx *Context, subscriber Subscriber, publisher Value, filter Pattern) error + func ToJSONVal(ctx *Context, v Serializable) interface + func ToSerializableValueMap(valMap map[string]Value) map[string]Serializable + func ToSymbolicValue(ctx *Context, v Value, wide bool) (symbolic.Value, error) + func Traverse(v Value, fn traverseVisitFn, config TraversalConfiguration) (terror error) + func UnsetDefaultMaxRequestHandlerLimits() + func UnsetDefaultRequestHandlingLimits() + func UnsetDefaultScriptLimits() + func UnsetNewDefaultContext() + func UnsetNewDefaultGlobalStateFn() + func WalkDir(fls afs.Filesystem, walkedDirPath Path, ...) + func WalkDirLow(fls afs.Filesystem, root string, fn fs.WalkDirFunc) error + func WithSecondaryContextIfPossible[T any](ctx *Context, arg T) T + func WithoutSecondaryContextIfPossible[T any](arg T) T + func WriteConcatenatedRepresentations(ctx *Context, values ...Serializable) ([]byte, [6]int32, error) + func WriteSingleJSONRepresentation(ctx *Context, v Serializable) ([]byte, [6]int32, error) + func WriteUntypedValueJSON(typeName string, fn func(w *jsoniter.Stream) error, w *jsoniter.Stream) error + type API interface + Data func() *Object + Schema func() *ObjectPattern + Version func() string + type AddressableContent interface + ChecksumSHA256 func() [32]byte + Reader func() io.Reader + type ApiIL struct + func WrapAPI(inner API) *ApiIL + func (*ApiIL) IsMutable() bool + func (*ApiIL) SetProp(ctx *Context, name string, value Value) error + func (api *ApiIL) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (api *ApiIL) GetGoMethod(name string) (*GoFunction, bool) + func (api *ApiIL) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (api *ApiIL) Prop(ctx *Context, name string) Value + func (api *ApiIL) PropertyNames(ctx *Context) []string + func (api *ApiIL) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type Array []Value + func NewArray(ctx *Context, elements ...Value) *Array + func NewArrayFrom(elements ...Value) *Array + func (*Array) IsMutable() bool + func (*Array) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (a *Array) At(ctx *Context, i int) Value + func (a *Array) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Value, error) + func (a *Array) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (a *Array) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (a *Array) Len() int + func (a *Array) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type ArrayIterator struct + func (it *ArrayIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *ArrayIterator) IsMutable() bool + func (it *ArrayIterator) Key(ctx *Context) Value + func (it *ArrayIterator) Next(ctx *Context) bool + func (it *ArrayIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *ArrayIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *ArrayIterator) Value(*Context) Value + func (it ArrayIterator) HasNext(*Context) bool + type ArrayPool struct + func NewArrayPool[T any](byteSize int, arrayLen int, releaseElem func(*T)) (*ArrayPool[T], error) + func (p *ArrayPool[T]) AvailableArrayCount() int + func (p *ArrayPool[T]) GetArray() ([]T, error) + func (p *ArrayPool[T]) InUseArrayCount() int + func (p *ArrayPool[T]) IsEmpty() bool + func (p *ArrayPool[T]) IsFull() bool + func (p *ArrayPool[T]) ReleaseArray(s []T) error + func (p *ArrayPool[T]) TotalArrayCount() int + type AssertionData struct + type AssertionError struct + func (err *AssertionError) ShallowCopy() *AssertionError + func (err AssertionError) Error() string + func (err AssertionError) IsTestAssertion() bool + func (err AssertionError) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig) + func (err AssertionError) PrettySPrint(config *PrettyPrintConfig) string + type AstNode struct + Node parse.Node + func (AstNode) PropertyNames(ctx *Context) []string + func (AstNode) SetProp(ctx *Context, name string, value Value) error + func (n AstNode) Chunk() *parse.ParsedChunkSource + func (n AstNode) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (n AstNode) IsMutable() bool + func (n AstNode) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (n AstNode) Prop(ctx *Context, name string) Value + func (n AstNode) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (n AstNode) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (node AstNode) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (node AstNode) Render(ctx *Context, w io.Writer, config RenderingInput) (n int, finalErr error) + type AutoInvocationConfig struct + Async bool + OnAddedElement URL + type BasePermissionRiskScore struct + Kind PermissionKind + Score RiskScore + Type reflect.Type + type BitSetIterator struct + func (it *BitSetIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *BitSetIterator) IsMutable() bool + func (it *BitSetIterator) Key(ctx *Context) Value + func (it *BitSetIterator) Next(ctx *Context) bool + func (it *BitSetIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *BitSetIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *BitSetIterator) Value(*Context) Value + func (it BitSetIterator) HasNext(*Context) bool + type Bool bool + func All(ctx *Context, iterable Iterable, condition Value) Bool + func None(ctx *Context, iterable Iterable, condition Value) Bool + func Some(ctx *Context, iterable Iterable, condition Value) Bool + func (b Bool) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (b Bool) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (b Bool) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (b Bool) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (boolean Bool) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (boolean Bool) IsMutable() bool + func (boolean Bool) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type BoolList struct + func (l *BoolList) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list *BoolList) At(ctx *Context, i int) Value + func (list *BoolList) BoolAt(i int) bool + func (list *BoolList) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (list *BoolList) ConstraintId() ConstraintId + func (list *BoolList) ContainsSimple(ctx *Context, v Serializable) bool + func (list *BoolList) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list *BoolList) IsMutable() bool + func (list *BoolList) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (list *BoolList) Len() int + func (list *BoolList) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list *BoolList) SetSlice(ctx *Context, start, end int, seq Sequence) + func (list *BoolList) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type BooleanCoercible interface + CoerceToBool func() bool + type BoundChildContextOptions struct + Filesystem afs.Filesystem + type BreakpointInfo struct + Chunk *parse.ParsedChunkSource + Id int32 + NodeSpan parse.NodeSpan + StartColumn int32 + StartLine int32 + func GetBreakpointsFromLines(lines []int, chunk *parse.ParsedChunkSource, nextBreakpointId *int32) ([]BreakpointInfo, error) + func (i BreakpointInfo) Verified() bool + type BuiltinType struct + func (t *BuiltinType) GoType() reflect.Type + func (t *BuiltinType) Symbolic() symbolic.CompileTimeType + type Byte byte + func (b Byte) Compare(other Value) (result int, comparable bool) + func (b Byte) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (b Byte) Int64() int64 + func (b Byte) IsMutable() bool + func (b Byte) IsSigned() bool + func (b Byte) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (b Byte) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (b Byte) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ByteCount int64 + func (c ByteCount) AsFloat64() (float64, bool) + func (c ByteCount) AsInt64() (int64, bool) + func (c ByteCount) Compare(other Value) (result int, comparable bool) + func (c ByteCount) Int64() int64 + func (c ByteCount) IsSigned() bool + func (c ByteCount) IsZeroQuantity() bool + func (c ByteCount) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (count ByteCount) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (count ByteCount) IsMutable() bool + func (count ByteCount) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (count ByteCount) Write(w io.Writer, _3digitGroupCount int) (int, error) + func (count ByteCount) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ByteRate int64 + func (r ByteRate) Compare(other Value) (result int, comparable bool) + func (r ByteRate) IsZeroRate() bool + func (r ByteRate) QuantityPerSecond() Value + func (r ByteRate) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r ByteRate) Validate() error + func (rate ByteRate) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (rate ByteRate) IsMutable() bool + func (rate ByteRate) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (rate ByteRate) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ByteSlice struct + func NewByteSlice(bytes []byte, mutable bool, contentType Mimetype) *ByteSlice + func NewImmutableByteSlice(bytes []byte, contentType Mimetype) *ByteSlice + func NewMutableByteSlice(bytes []byte, contentType Mimetype) *ByteSlice + func (s *ByteSlice) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (s *ByteSlice) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (s *ByteSlice) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (s *ByteSlice) RemoveMutationCallbackMicrotasks(ctx *Context) + func (s *ByteSlice) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *ByteSlice) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (slice *ByteSlice) At(ctx *Context, i int) Value + func (slice *ByteSlice) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (slice *ByteSlice) ContentType() Mimetype + func (slice *ByteSlice) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (slice *ByteSlice) GetOrBuildBytes() *ByteSlice + func (slice *ByteSlice) IsMutable() bool + func (slice *ByteSlice) Len() int + func (slice *ByteSlice) Mutable() bool + func (slice *ByteSlice) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (slice *ByteSlice) Reader() *Reader + func (slice *ByteSlice) SetSlice(ctx *Context, start, end int, seq Sequence) + func (slice *ByteSlice) UnderlyingBytes() []byte + func (slice *ByteSlice) UnsafeBytesAsString() string + func (slice *ByteSlice) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Bytecode struct + func Compile(input CompilationInput) (*Bytecode, error) + func (b *Bytecode) Constants() []Value + func (b *Bytecode) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (b *Bytecode) Format(ctx *Context, leftPadding string) string + func (b *Bytecode) FormatConstants(ctx *Context, leftPadding string) (output []string) + func (b *Bytecode) FormatInstructions(ctx *Context, leftPadding string) []string + func (b *Bytecode) IsMutable() bool + func (b *Bytecode) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (b *Bytecode) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (b *Bytecode) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type BytecodeEvaluationConfig struct + CompilationContext *Context + OptimizeBytecode bool + ShowCompilationTrace bool + Tracer io.Writer + type BytesConcatenation struct + func NewBytesConcatenation(bytesLikes ...BytesLike) *BytesConcatenation + func (c *BytesConcatenation) At(ctx *Context, i int) Value + func (c *BytesConcatenation) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (c *BytesConcatenation) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c *BytesConcatenation) GetOrBuildBytes() *ByteSlice + func (c *BytesConcatenation) IsMutable() bool + func (c *BytesConcatenation) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (c *BytesConcatenation) Len() int + func (c *BytesConcatenation) Mutable() bool + func (c *BytesConcatenation) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (c *BytesConcatenation) SetSlice(ctx *Context, start, end int, seq Sequence) + func (c *BytesConcatenation) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (c *BytesConcatenation) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type BytesLike interface + GetOrBuildBytes func() *ByteSlice + Mutable func() bool + func ConcatBytesLikes(bytesLikes ...BytesLike) (BytesLike, error) + type CallbackHandle int + func (h CallbackHandle) Valid() bool + type Change struct + func NewChange(mutation Mutation, datetime DateTime) Change + func (c Change) DateTime() DateTime + type CheckedString struct + func NewCheckedString(slices []Value, node *parse.StringTemplateLiteral, ctx *Context) (CheckedString, error) + func (CheckedString) SetProp(ctx *Context, name string, value Value) error + func (s CheckedString) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (str CheckedString) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (str CheckedString) IsMutable() bool + func (str CheckedString) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (str CheckedString) Prop(ctx *Context, name string) Value + func (str CheckedString) PropertyNames(ctx *Context) []string + func (str CheckedString) String() string + func (str CheckedString) UnderlyingString() string + func (str CheckedString) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Clonable interface + Clone func(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Value, error) + type ClonableSerializable interface + Clone func(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + type Collection interface + GetElementByKey func(ctx *Context, key ElementKey) (Serializable, error) + type Color struct + func ColorFromAnsi256Color(c termenv.ANSI256Color) Color + func ColorFromAnsiColor(c termenv.ANSIColor) Color + func ColorFromRGB24(r, g, b byte) Color + func ColorFromTermenvColor(c termenv.Color, defaultColor ...Color) Color + func (Color) IsMutable() bool + func (c Color) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c Color) GetAnsiEscapeSequence(background bool) []byte + func (c Color) IsDarkBackgroundColor() bool + func (c Color) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (c Color) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (c Color) ToTermColor() termenv.Color + func (c Color) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ColorizationInfo struct + ColorSequence []byte + Span parse.NodeSpan + func GetNodeColorizations(chunk *parse.Chunk, lightMode bool) []ColorizationInfo + type CommandPermission struct + CommandName WrappedString + SubcommandNameChain []string + func (perm CommandPermission) Includes(otherPerm Permission) bool + func (perm CommandPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm CommandPermission) Kind() PermissionKind + func (perm CommandPermission) String() string + type Comparable interface + Compare func(b Value) (result int, comparable bool) + type CompilationInput struct + Context *Context + Globals map[string]Value + IsImportTestingEnabled bool + IsTestingEnabled bool + Mod *Module + StaticCheckData *StaticCheckData + SymbolicData *symbolic.Data + TraceWriter io.Writer + type CompileError struct + Err error + Message string + Module *Module + Node parse.Node + func (e *CompileError) Error() string + type CompileTimeType interface + GoType func() reflect.Type + Symbolic func() symbolic.CompileTimeType + type CompiledFunction struct + Bytecode *Bytecode + IncludedChunk *parse.ParsedChunkSource + Instructions []byte + IsVariadic bool + LocalCount int + ParamCount int + SourceMap map[int]instructionSourcePosition + SourceNodeSpan parse.NodeSpan + func (fn *CompiledFunction) GetSourcePositionRange(ip int) parse.SourcePositionRange + type ComplexPropertyConstraint struct + Expr parse.Node + Properties []string + type ConfluenceStream struct + func NewConfluenceStream(ctx *Context, streams []ReadableStream) (*ConfluenceStream, error) + func (*ConfluenceStream) IsMutable() bool + func (s *ConfluenceStream) ChunkDataType() Pattern + func (s *ConfluenceStream) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *ConfluenceStream) IsMainlyChunked() bool + func (s *ConfluenceStream) IsStopped() bool + func (s *ConfluenceStream) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *ConfluenceStream) Stop() + func (s *ConfluenceStream) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (s *ConfluenceStream) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *ConfluenceStream) WaitNext(ctx *Context, filter Pattern, timeout time.Duration) (Value, error) + func (s *ConfluenceStream) WaitNextChunk(ctx *Context, filter Pattern, sizeRange IntRange, timeout time.Duration) (*DataChunk, error) + type ConstraintId uint64 + func (id ConstraintId) HasConstraint() bool + type Container interface + Contains func(ctx *Context, value Serializable) bool + IsEmpty func(ctx *Context) bool + type Context struct + func NewContexWithEmptyState(config ContextConfig, out io.Writer) *Context + func NewContext(config ContextConfig) *Context + func (ctx *Context) AddHostAlias(alias string, host Host) + func (ctx *Context) AddHostDefinition(h Host, data ResourceName) + func (ctx *Context) AddNamedPattern(name string, pattern Pattern) + func (ctx *Context) AddPatternNamespace(name string, namespace *PatternNamespace) + func (ctx *Context) AddTypeExtension(extension *TypeExtension) + func (ctx *Context) BoundChild() *Context + func (ctx *Context) BoundChildWithOptions(opts BoundChildContextOptions) *Context + func (ctx *Context) CancelGracefully() + func (ctx *Context) CancelIfShortLived() + func (ctx *Context) CancelUngracefully() + func (ctx *Context) CheckHasPermission(perm Permission) error + func (ctx *Context) DefinitelyStopCPUTimeDepletion() error + func (ctx *Context) DefinitelyStopTokenDepletion(limitName string) error + func (ctx *Context) DoIO(fn func() error) error + func (ctx *Context) DropPermissions(droppedPermissions []Permission) + func (ctx *Context) ForEachHostAlias(fn func(name string, value Host) error) error + func (ctx *Context) ForEachNamedPattern(fn func(name string, pattern Pattern) error) error + func (ctx *Context) ForEachPatternNamespace(fn func(name string, namespace *PatternNamespace) error) error + func (ctx *Context) GetAllHostDefinitions() map[Host]Value + func (ctx *Context) GetByteRate(name string) (ByteRate, error) + func (ctx *Context) GetClosestState() *GlobalState + func (ctx *Context) GetFileSystem() afs.Filesystem + func (ctx *Context) GetForbiddenPermissions() []Permission + func (ctx *Context) GetGrantedPermissions() []Permission + func (ctx *Context) GetHostAliases() map[string]Host + func (ctx *Context) GetHostByDefinition(r ResourceName) (Host, bool) + func (ctx *Context) GetHostDefinition(h Host) Value + func (ctx *Context) GetNamedPatterns() map[string]Pattern + func (ctx *Context) GetPatternNamespaces() map[string]*PatternNamespace + func (ctx *Context) GetProtolClient(u URL) (ProtocolClient, error) + func (ctx *Context) GetState() (*GlobalState, bool) + func (ctx *Context) GetTempDir() Path + func (ctx *Context) GetTotal(name string) (int64, error) + func (ctx *Context) GetTx() *Transaction + func (ctx *Context) GetTypeExtension(id string) *TypeExtension + func (ctx *Context) GetWaitConfirmPrompt() WaitConfirmPrompt + func (ctx *Context) GiveBack(limitName string, count int64) error + func (ctx *Context) GracefulTearDownStatus() GracefulTeardownStatus + func (ctx *Context) HasAPermissionWithKindAndType(kind permkind.PermissionKind, typename permkind.InternalPermissionTypename) bool + func (ctx *Context) HasCurrentTx() bool + func (ctx *Context) HasPermission(perm Permission) bool + func (ctx *Context) HasPermissionUntyped(perm any) bool + func (ctx *Context) InefficientlyWaitUntilTearedDown(timeout time.Duration) bool + func (ctx *Context) InitialWorkingDirectory() Path + func (ctx *Context) IsDone() bool + func (ctx *Context) IsDoneSlowCheck() bool + func (ctx *Context) IsLongLived() bool + func (ctx *Context) IsTearedDown() bool + func (ctx *Context) IsValueVisible(v Value) bool + func (ctx *Context) Limits() []Limit + func (ctx *Context) Logger() *zerolog.Logger + func (ctx *Context) New() *Context + func (ctx *Context) NewChildLoggerForInternalSource(src string) zerolog.Logger + func (ctx *Context) Now() DateTime + func (ctx *Context) OnDone(microtask ContextDoneMicrotaskFn) + func (ctx *Context) OnGracefulTearDown(task GracefulTearDownTaskFn) + func (ctx *Context) PauseCPUTimeDepletion() error + func (ctx *Context) PauseCPUTimeDepletionIfNotPaused() error + func (ctx *Context) PauseTokenDepletion(limitName string) error + func (ctx *Context) PromoteToLongLived() + func (ctx *Context) PutUserData(path Path, value Value) + func (ctx *Context) ResolveHostAlias(alias string) Host + func (ctx *Context) ResolveNamedPattern(name string) Pattern + func (ctx *Context) ResolvePatternNamespace(name string) *PatternNamespace + func (ctx *Context) ResolveUserData(path Path) Value + func (ctx *Context) ResumeCPUTimeDepletion() error + func (ctx *Context) ResumeDepletion(limitName string) error + func (ctx *Context) SetClosestState(state *GlobalState) + func (ctx *Context) SetProtocolClientForHost(h Host, client ProtocolClient) error + func (ctx *Context) SetProtocolClientForURL(u URL, client ProtocolClient) error + func (ctx *Context) SetWaitConfirmPrompt(fn WaitConfirmPrompt) + func (ctx *Context) Sleep(duration time.Duration) + func (ctx *Context) Take(limitName string, count int64) error + func (ctx *Context) ToSymbolicValue() (*symbolic.Context, error) + func (ctx *Context) Update(fn func(ctxData LockedContextData) error) error + type ContextConfig struct + CreateFilesystem func(ctx *Context) (afs.Filesystem, error) + DoNotCheckDatabasePerms bool + DoNotSetFilesystemContext bool + DoNotSpawnDoneGoroutine bool + Filesystem afs.Filesystem + ForbiddenPermissions []Permission + HostDefinitions map[Host]Value + InitialWorkingDirectory Path + Kind ContextKind + LimitTokens map[string]int64 + Limits []Limit + OwnedDatabases []DatabaseConfig + ParentContext *Context + ParentStdLibContext context.Context + Permissions []Permission + TypeExtensions []*TypeExtension + WaitConfirmPrompt WaitConfirmPrompt + func (c ContextConfig) Check() (firstErr error, ok bool) + type ContextDoneMicrotaskFn func(timeoutCtx context.Context, teardownStatus GracefulTeardownStatus) error + type ContextKind int + const DefaultContext + const TestingContext + type CurrentTest struct + func (*CurrentTest) IsMutable() bool + func (*CurrentTest) PropertyNames(ctx *Context) []string + func (*CurrentTest) SetProp(ctx *Context, name string, value Value) error + func (t *CurrentTest) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (t *CurrentTest) GetGoMethod(name string) (*GoFunction, bool) + func (t *CurrentTest) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (t *CurrentTest) Prop(ctx *Context, name string) Value + func (t *CurrentTest) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type CustomPermissionTypeHandler func(kind PermissionKind, name string, value Value) (perms []Permission, handled bool, err error) + type DNSPermission struct + Domain WrappedString + Kind_ PermissionKind + func (perm DNSPermission) Includes(otherPerm Permission) bool + func (perm DNSPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm DNSPermission) Kind() PermissionKind + func (perm DNSPermission) String() string + type DataChunk struct + func (*DataChunk) GetGoMethod(name string) (*GoFunction, bool) + func (*DataChunk) IsMutable() bool + func (*DataChunk) PropertyNames(ctx *Context) []string + func (*DataChunk) SetProp(ctx *Context, name string, value Value) error + func (c *DataChunk) Data(ctx *Context) (Value, error) + func (c *DataChunk) Discard(ctx *Context) error + func (c *DataChunk) ElemCount() int + func (c *DataChunk) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c *DataChunk) MergeWith(ctx *Context, other *DataChunk) error + func (c *DataChunk) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (c *DataChunk) Prop(ctx *Context, name string) Value + func (c *DataChunk) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type DataStore interface + BaseURL func() URL + GetSerialized func(ctx *Context, key Path) (string, bool) + Has func(ctx *Context, key Path) bool + InsertSerialized func(ctx *Context, key Path, serialized string) + SetSerialized func(ctx *Context, key Path, serialized string) + type Database interface + Close func(ctx *Context) error + LoadTopLevelEntities func(ctx *Context) (map[string]Serializable, error) + Resource func() SchemeHolder + Schema func() *ObjectPattern + UpdateSchema func(ctx *Context, schema *ObjectPattern, migrationHandlers MigrationOpHandlers) + type DatabaseConfig struct + ExpectedSchema *ObjectPattern + ExpectedSchemaUpdate bool + Name string + Owned bool + Provided *DatabaseIL + ResolutionData Value + Resource SchemeHolder + func (c DatabaseConfig) IsPermissionForThisDB(perm DatabasePermission) bool + type DatabaseConfigs []DatabaseConfig + type DatabaseIL struct + func WrapDatabase(ctx *Context, args DatabaseWrappingArgs) (*DatabaseIL, error) + func (*DatabaseIL) IsMutable() bool + func (*DatabaseIL) SetProp(ctx *Context, name string, value Value) error + func (db *DatabaseIL) AddOwnerStateTeardownCallback() + func (db *DatabaseIL) Close(ctx *Context) error + func (db *DatabaseIL) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (db *DatabaseIL) GetGoMethod(name string) (*GoFunction, bool) + func (db *DatabaseIL) GetOrLoad(ctx *Context, path Path) (Serializable, error) + func (db *DatabaseIL) IsPermissionForThisDB(perm DatabasePermission) bool + func (db *DatabaseIL) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (db *DatabaseIL) Prop(ctx *Context, name string) Value + func (db *DatabaseIL) PropertyNames(ctx *Context) []string + func (db *DatabaseIL) Resource() SchemeHolder + func (db *DatabaseIL) SetOwnerStateOnceAndLoadIfNecessary(ctx *Context, state *GlobalState) error + func (db *DatabaseIL) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (db *DatabaseIL) TopLevelEntitiesLoaded() bool + func (db *DatabaseIL) UpdateSchema(ctx *Context, nextSchema *ObjectPattern, migrations ...*Object) + type DatabasePermission struct + Entity WrappedString + Kind_ PermissionKind + func (perm DatabasePermission) Includes(otherPerm Permission) bool + func (perm DatabasePermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm DatabasePermission) Kind() PermissionKind + func (perm DatabasePermission) String() string + type DatabaseWrappingArgs struct + DevMode bool + ExpectedSchema *ObjectPattern + ExpectedSchemaUpdate bool + ForceLoadBeforeOwnerStateSet bool + Inner Database + Name string + OwnerState *GlobalState + type Date time.Time + func (d Date) Compare(other Value) (result int, comparable bool) + func (d Date) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (d Date) IsMutable() bool + func (d Date) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d Date) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (d Date) Validate() error + func (d Date) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type DateFormat struct + func NewDateFormat(layout, namespaceMemberName string) *DateFormat + func (f *DateFormat) Format(ctx *Context, v Value, w io.Writer) (int, error) + func (f *DateFormat) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt DateFormat) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type DateTime time.Time + func (d DateTime) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (d DateTime) IsMutable() bool + func (d DateTime) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (d DateTime) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d DateTime) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (d DateTime) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (d DateTime) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (dt DateTime) Compare(other Value) (result int, comparable bool) + func (left DateTime) Add(right Value) (Value, error) + func (left DateTime) Sub(right Value) (Value, error) + func (t DateTime) AsGoTime() time.Time + type DbOpenConfiguration struct + FullAccess bool + Project Project + ResolutionData Value + Resource SchemeHolder + type DebugCommandCloseDebugger struct + CancelExecution bool + Done func() + type DebugCommandContinue struct + ResumeAllThreads bool + ThreadId StateId + type DebugCommandGetScopes struct + Get func(globalScope map[string]Value, localScope map[string]Value) + ThreadId StateId + type DebugCommandGetStackTrace struct + Get func(trace []StackFrameInfo) + ThreadId StateId + type DebugCommandInformAboutSecondaryEvent struct + Event SecondaryDebugEvent + type DebugCommandNextStep struct + ResumeAllThreads bool + ThreadId StateId + type DebugCommandPause struct + ThreadId StateId + func (c DebugCommandPause) GetThreadId() StateId + type DebugCommandSetBreakpoints struct + BreakPointsByLine []int + BreakpointsAtNode map[parse.Node]struct{} + Chunk *parse.ParsedChunkSource + GetBreakpointsSetByLine func(breakpoints []BreakpointInfo) + type DebugCommandSetExceptionBreakpoints struct + Disable bool + GetExceptionBreakpointId func(int32) + type DebugCommandStepIn struct + ResumeAllThreads bool + ThreadId StateId + type DebugCommandStepOut struct + ResumeAllThreads bool + ThreadId StateId + type Debugger struct + func NewDebugger(args DebuggerArgs) *Debugger + func (d *Debugger) AttachAndStart(state evaluationState) + func (d *Debugger) Closed() bool + func (d *Debugger) ControlChan() chan any + func (d *Debugger) ExceptionBreakpointsId() (_ int32, enabled bool) + func (d *Debugger) NewChild() *Debugger + func (d *Debugger) SecondaryEventsChan() chan SecondaryDebugEvent + func (d *Debugger) StoppedChan() chan ProgramStoppedEvent + func (d *Debugger) ThreadIfOfStackFrame(stackFrameId int32) (StateId, bool) + func (d *Debugger) Threads() (threads []ThreadInfo) + type DebuggerArgs struct + Context *Context + ExceptionBreakpointId int32 + InitialBreakpoints []BreakpointInfo + Logger zerolog.Logger + type DefaultContextConfig struct + DoNotCheckDatabasePerms bool + Filesystem afs.Filesystem + ForbiddenPermissions []Permission + HostDefinitions map[Host]Value + InitialWorkingDirectory Path + Limits []Limit + OwnedDatabases []DatabaseConfig + ParentContext *Context + ParentStdLibContext context.Context + Permissions []Permission + type DefaultGlobalStateConfig struct + AbsoluteModulePath string + AllowMissingEnvVars bool + ApplicationListeningAddr Host + EnvPattern *ObjectPattern + LogLevels *LogLevels + LogOut io.Writer + Logger zerolog.Logger + Out io.Writer + PreinitFiles PreinitFiles + type DefaultValuePattern interface + DefaultValue func(ctx *Context) (Value, error) + type Dictionary struct + func NewDictionary(entries ValMap) *Dictionary + func NewDictionaryFromKeyValueLists(keys []Serializable, values []Serializable, ctx *Context) *Dictionary + func (*Dictionary) PropertyNames(ctx *Context) []string + func (*Dictionary) SetProp(ctx *Context, name string, value Value) error + func (d *Dictionary) ForEachEntry(ctx *Context, fn func(keyRepr string, key Serializable, v Serializable) error) error + func (d *Dictionary) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (d *Dictionary) Prop(ctx *Context, name string) Value + func (d *Dictionary) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (d *Dictionary) RemoveMutationCallbackMicrotasks(ctx *Context) + func (d *Dictionary) SetValue(ctx *Context, key, value Serializable) + func (d *Dictionary) Value(ctx *Context, key Serializable) (Value, Bool) + func (d *Dictionary) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (d *Dictionary) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (dict *Dictionary) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (dict *Dictionary) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (dict *Dictionary) IsMutable() bool + func (dict *Dictionary) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (dict *Dictionary) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type DifferencePattern struct + func NewDifferencePattern(base, removed Pattern) *DifferencePattern + func (p *DifferencePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *DifferencePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *DifferencePattern) Random(ctx *Context, options ...Option) Value + func (patt *DifferencePattern) StringPattern() (StringPattern, bool) + func (patt *DifferencePattern) Test(ctx *Context, v Value) bool + func (pattern *DifferencePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *DifferencePattern) IsMutable() bool + func (pattern *DifferencePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pattern *DifferencePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type DirWalker struct + func NewDirWalker(fls afs.Filesystem, walkedDirPath Path) *DirWalker + func (it *DirWalker) HasNext(ctx *Context) bool + func (it *DirWalker) Key(*Context) Value + func (it *DirWalker) Next(ctx *Context) bool + func (it *DirWalker) NodeMeta(*Context) WalkableNodeMeta + func (it *DirWalker) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *DirWalker) Prune(ctx *Context) + func (it *DirWalker) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *DirWalker) Value(*Context) Value + func (w *DirWalker) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (w *DirWalker) IsMutable() bool + type DoneChan <-chan struct + func (c DoneChan) IsDone() bool + func (c DoneChan) IsNotDone() bool + type Duration time.Duration + func (d Duration) Compare(other Value) (result int, comparable bool) + func (d Duration) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (d Duration) IsMutable() bool + func (d Duration) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d Duration) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (d Duration) Validate() error + func (d Duration) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (left Duration) Add(right Value) (Value, error) + func (left Duration) Sub(right Value) (Value, error) + type DynamicStringPatternElement struct + func (p *DynamicStringPatternElement) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *DynamicStringPatternElement) IsResolved() bool + func (patt *DynamicStringPatternElement) Parse(ctx *Context, s string) (Serializable, error) + func (patt *DynamicStringPatternElement) PatternNestingDepth(parentDepth int) int + func (patt *DynamicStringPatternElement) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *DynamicStringPatternElement) StringPattern() (StringPattern, bool) + func (patt DynamicStringPatternElement) Call(values []Serializable) (Pattern, error) + func (patt DynamicStringPatternElement) CompiledRegex() *regexp.Regexp + func (patt DynamicStringPatternElement) EffectiveLengthRange() IntRange + func (patt DynamicStringPatternElement) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt DynamicStringPatternElement) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt DynamicStringPatternElement) HasRegex() bool + func (patt DynamicStringPatternElement) IsMutable() bool + func (patt DynamicStringPatternElement) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt DynamicStringPatternElement) LengthRange() IntRange + func (patt DynamicStringPatternElement) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt DynamicStringPatternElement) Random(ctx *Context, options ...Option) Value + func (patt DynamicStringPatternElement) Regex() string + func (patt DynamicStringPatternElement) Resolve() (StringPattern, error) + func (patt DynamicStringPatternElement) Test(ctx *Context, v Value) bool + func (patt DynamicStringPatternElement) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type DynamicValue struct + func NewDynamicCall(ctx *Context, callee Value, args ...Value) *DynamicValue + func NewDynamicIf(ctx *Context, condition *DynamicValue, consequent Value, alternate Value) *DynamicValue + func NewDynamicMapInvocation(ctx *Context, iterable Iterable, mapper Value) (*DynamicValue, error) + func NewDynamicMemberValue(ctx *Context, object Value, memberName string) (*DynamicValue, error) + func (c *DynamicValue) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c *DynamicValue) IsMutable() bool + func (d *DynamicValue) IsFrozen() bool + func (d *DynamicValue) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d *DynamicValue) TakeInMemorySnapshot(ctx *Context) (*Snapshot, error) + func (d *DynamicValue) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (d *DynamicValue) Unfreeze(ctx *Context) error + func (dyn *DynamicValue) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (dyn *DynamicValue) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (dyn *DynamicValue) Prop(ctx *Context, name string) Value + func (dyn *DynamicValue) PropertyNames(ctx *Context) []string + func (dyn *DynamicValue) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (dyn *DynamicValue) RemoveMutationCallbackMicrotasks(ctx *Context) + func (dyn *DynamicValue) Resolve(ctx *Context) Value + func (dyn *DynamicValue) SetProp(ctx *Context, name string, value Value) error + func (dyn *DynamicValue) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (v *DynamicValue) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Effect interface + Apply func(*Context) error + IsApplied func() bool + IsApplying func() bool + PermissionKind func() PermissionKind + Resources func() []ResourceName + Reversability func(*Context) Reversability + Reverse func(*Context) error + type ElementKey string + func ElementKeyFrom(key string) (ElementKey, error) + func MustElementKeyFrom(key string) ElementKey + type ElementsStream struct + func NewElementsStream(elements []Value, filter Pattern) *ElementsStream + func (*ElementsStream) IsMutable() bool + func (s *ElementsStream) ChunkDataType() Pattern + func (s *ElementsStream) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *ElementsStream) IsMainlyChunked() bool + func (s *ElementsStream) IsStopped() bool + func (s *ElementsStream) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *ElementsStream) Stop() + func (s *ElementsStream) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (s *ElementsStream) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *ElementsStream) WaitNext(ctx *Context, filter Pattern, timeout time.Duration) (Value, error) + func (s *ElementsStream) WaitNextChunk(ctx *Context, filter Pattern, sizeRange IntRange, timeout time.Duration) (*DataChunk, error) + type EmailAddress string + func NormalizeEmailAddress(s string) (EmailAddress, error) + func (EmailAddress) SetProp(ctx *Context, name string, value Value) error + func (addr EmailAddress) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (addr EmailAddress) IsMutable() bool + func (addr EmailAddress) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (addr EmailAddress) Prop(ctx *Context, name string) Value + func (addr EmailAddress) PropertyNames(ctx *Context) []string + func (addr EmailAddress) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (addr EmailAddress) UnderlyingString() string + func (addr EmailAddress) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type EntrySnapshotMetadata struct + AbsolutePath Path + ChecksumSHA256 [32]byte + ChildNames []string + CreationTime DateTime + Mode FileMode + ModificationTime DateTime + Size ByteCount + func (m EntrySnapshotMetadata) IsDir() bool + func (m EntrySnapshotMetadata) IsRegularFile() bool + type EnvVarPermission struct + Kind_ PermissionKind + Name string + func (perm EnvVarPermission) Includes(otherPerm Permission) bool + func (perm EnvVarPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm EnvVarPermission) Kind() PermissionKind + func (perm EnvVarPermission) String() string + type Error struct + func NewError(err error, data Serializable) Error + func (Error) PropertyNames(ctx *Context) []string + func (Error) SetProp(ctx *Context, name string, value Value) error + func (e Error) Data() Value + func (e Error) Error() string + func (e Error) Prop(ctx *Context, name string) Value + func (e Error) Text() string + func (e Error) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (err Error) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (err Error) IsMutable() bool + func (err Error) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (v Error) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Event struct + func NewEvent(srcValue any, value Value, time DateTime, affectedResources ...ResourceName) *Event + func (e *Event) Age() time.Duration + func (e *Event) AgeWithCurrentTime(now time.Time) time.Duration + func (e *Event) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (e *Event) IsMutable() bool + func (e *Event) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (e *Event) Prop(ctx *Context, name string) Value + func (e *Event) PropertyNames(ctx *Context) []string + func (e *Event) SetProp(ctx *Context, name string, value Value) error + func (e *Event) SourceValue() any + func (e *Event) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (e *Event) Value() Value + type EventHandler func(event *Event) + type EventPattern struct + func NewEventPattern(valuePattern Pattern) *EventPattern + func (p *EventPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *EventPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *EventPattern) IsMutable() bool + func (patt *EventPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *EventPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *EventPattern) Random(ctx *Context, options ...Option) Value + func (patt *EventPattern) StringPattern() (StringPattern, bool) + func (patt *EventPattern) Test(ctx *Context, v Value) bool + func (patt *EventPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type EventSource interface + Close func() + IsClosed func() bool + OnEvent func(microtask EventHandler) error + func NewEventSource(ctx *Context, resourceNameOrPattern Value) (EventSource, error) + type EventSourceBase struct + func (evs *EventSourceBase) GetHandlers() []EventHandler + func (evs *EventSourceBase) OnEvent(handler EventHandler) error + func (evs *EventSourceBase) OnIDLE(handler IdleEventSourceHandler) + func (evs *EventSourceBase) RemoveAllHandlers() + type EventSourceFactory func(ctx *Context, resourceNameOrPattern Value) (EventSource, error) + func GetEventSourceFactory(scheme Scheme) (EventSourceFactory, bool) + type EventSourceIterator struct + func (*EventSourceIterator) SetProp(ctx *Context, name string, value Value) error + func (it *EventSourceIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *EventSourceIterator) GetGoMethod(name string) (*GoFunction, bool) + func (it *EventSourceIterator) HasNext(*Context) bool + func (it *EventSourceIterator) IsMutable() bool + func (it *EventSourceIterator) Key(ctx *Context) Value + func (it *EventSourceIterator) Next(ctx *Context) bool + func (it *EventSourceIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *EventSourceIterator) Prop(ctx *Context, name string) Value + func (it *EventSourceIterator) PropertyNames(ctx *Context) []string + func (it *EventSourceIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *EventSourceIterator) Value(*Context) Value + type ExactStringPattern struct + func NewExactStringPattern(value String) *ExactStringPattern + func (p *ExactStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *ExactStringPattern) CompiledRegex() *regexp.Regexp + func (patt *ExactStringPattern) IsResolved() bool + func (patt *ExactStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *ExactStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *ExactStringPattern) Resolve() (StringPattern, error) + func (patt *ExactStringPattern) StringPattern() (StringPattern, bool) + func (patt ExactStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (pattern *ExactStringPattern) EffectiveLengthRange() IntRange + func (pattern *ExactStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *ExactStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (matches []Serializable, err error) + func (pattern *ExactStringPattern) HasRegex() bool + func (pattern *ExactStringPattern) IsMutable() bool + func (pattern *ExactStringPattern) LengthRange() IntRange + func (pattern *ExactStringPattern) Regex() string + func (pattern *ExactStringPattern) Test(ctx *Context, v Value) bool + func (pattern ExactStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pattern ExactStringPattern) Random(ctx *Context, options ...Option) Value + func (pattern ExactStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ExactValuePattern struct + func NewExactValuePattern(value Serializable) *ExactValuePattern + func (p *ExactValuePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *ExactValuePattern) StringPattern() (StringPattern, bool) + func (patt ExactValuePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (pattern *ExactValuePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *ExactValuePattern) IsMutable() bool + func (pattern *ExactValuePattern) Test(ctx *Context, v Value) bool + func (pattern *ExactValuePattern) Value() Serializable + func (pattern ExactValuePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pattern ExactValuePattern) Random(ctx *Context, options ...Option) Value + func (pattern ExactValuePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ExecutedStep struct + func (*ExecutedStep) PropertyNames(ctx *Context) []string + func (*ExecutedStep) SetProp(ctx *Context, name string, value Value) error + func (e ExecutedStep) IsMutable() bool + func (s *ExecutedStep) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *ExecutedStep) GetGoMethod(name string) (*GoFunction, bool) + func (s *ExecutedStep) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *ExecutedStep) Prop(ctx *Context, name string) Value + func (s *ExecutedStep) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type ExtendedFileInfo interface + CreationTime func() (time.Time, bool) + type FailedToOpenDatabase struct + func NewFailedToOpenDatabase(resource SchemeHolder) *FailedToOpenDatabase + func (db *FailedToOpenDatabase) Close(ctx *Context) error + func (db *FailedToOpenDatabase) LoadTopLevelEntities(_ *Context) (map[string]Serializable, error) + func (db *FailedToOpenDatabase) Resource() SchemeHolder + func (db *FailedToOpenDatabase) Schema() *ObjectPattern + func (db *FailedToOpenDatabase) UpdateSchema(ctx *Context, schema *ObjectPattern, handlers MigrationOpHandlers) + type FieldRetrievalType int + const GetBoolField + const GetFloatField + const GetIntField + const GetStringField + const GetStructPointerField + type FileInfo struct + AbsPath_ Path + BaseName_ string + CreationTime_ DateTime + HasCreationTime bool + ModTime_ DateTime + Mode_ FileMode + Size_ ByteCount + func (FileInfo) PropertyNames(ctx *Context) []string + func (FileInfo) SetProp(ctx *Context, name string, value Value) error + func (fi FileInfo) CreationTime() (time.Time, bool) + func (fi FileInfo) IsDir() bool + func (fi FileInfo) ModTime() time.Time + func (fi FileInfo) Mode() fs.FileMode + func (fi FileInfo) Name() string + func (fi FileInfo) Size() int64 + func (fi FileInfo) Sys() any + func (i FileInfo) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (i FileInfo) GetGoMethod(name string) (*GoFunction, bool) + func (i FileInfo) IsMutable() bool + func (i FileInfo) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (i FileInfo) Prop(ctx *Context, name string) Value + func (i FileInfo) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (i FileInfo) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type FileMode fs.FileMode + func FileModeFrom(ctx *Context, firstArg Value) FileMode + func (m FileMode) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (m FileMode) Executable() bool + func (m FileMode) FileMode() fs.FileMode + func (m FileMode) IsMutable() bool + func (m FileMode) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (m FileMode) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (m FileMode) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type FilesystemPermission struct + Entity WrappedString + Kind_ PermissionKind + func CreateFsReadPerm(entity WrappedString) FilesystemPermission + func (perm FilesystemPermission) Includes(otherPerm Permission) bool + func (perm FilesystemPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm FilesystemPermission) Kind() PermissionKind + func (perm FilesystemPermission) String() string + type FilesystemSnapshot interface + Content func(path string) (AddressableContent, error) + ForEachEntry func(func(m EntrySnapshotMetadata) error) error + IsStoredLocally func() bool + Metadata func(path string) (EntrySnapshotMetadata, error) + NewAdaptedFilesystem func(maxTotalStorageSizeHint ByteCount) (SnapshotableFilesystem, error) + RootDirEntries func() []string + WriteTo func(fls afs.Filesystem, params SnapshotWriteToFilesystem) error + type FilesystemSnapshotConfig struct + ExclusionFilters []PathPattern + GetContent func(ChecksumSHA256 [32]byte) AddressableContent + InclusionFilters []PathPattern + func (c FilesystemSnapshotConfig) IsFileIncluded(path Path) bool + type FilesystemSnapshotIL struct + func WrapFsSnapshot(snapshot FilesystemSnapshot) *FilesystemSnapshotIL + func (*FilesystemSnapshotIL) IsMutable() bool + func (s *FilesystemSnapshotIL) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *FilesystemSnapshotIL) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *FilesystemSnapshotIL) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *FilesystemSnapshotIL) Underlying() FilesystemSnapshot + func (s *FilesystemSnapshotIL) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Float float64 + func (f Float) Compare(other Value) (result int, comparable bool) + func (f Float) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (f Float) IsMutable() bool + func (f Float) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (f Float) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (f Float) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type FloatList = NumberList[Float] + type FloatRange struct + func NewFloatRange(start, end float64, inclusiveEnd bool) FloatRange + func NewIncludedEndFloatRange(start, end float64) FloatRange + func NewUnknownStartFloatRange(end float64, inclusiveEnd bool) FloatRange + func (r FloatRange) Contains(ctx *Context, v Serializable) bool + func (r FloatRange) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r FloatRange) HasKnownStart() bool + func (r FloatRange) Includes(ctx *Context, n Float) bool + func (r FloatRange) InclusiveEnd() float64 + func (r FloatRange) IsEmpty(ctx *Context) bool + func (r FloatRange) IsMutable() bool + func (r FloatRange) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (r FloatRange) KnownStart() float64 + func (r FloatRange) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r FloatRange) Random(ctx *Context) Value + func (r FloatRange) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r FloatRange) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type FloatRangeIterator struct + func (it *FloatRangeIterator) HasNext(*Context) bool + func (it *FloatRangeIterator) Key(ctx *Context) Value + func (it *FloatRangeIterator) Next(ctx *Context) bool + func (it *FloatRangeIterator) Value(*Context) Value + func (it FloatRangeIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it FloatRangeIterator) IsMutable() bool + func (it FloatRangeIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it FloatRangeIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type FloatRangePattern struct + func NewFloatRangePattern(floatRange FloatRange, multipleOf float64) *FloatRangePattern + func NewSingleElementFloatRangePattern(n float64) *FloatRangePattern + func (p *FloatRangePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p FloatRangePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (patt *FloatRangePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *FloatRangePattern) IsMutable() bool + func (patt *FloatRangePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *FloatRangePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *FloatRangePattern) Random(ctx *Context, options ...Option) Value + func (patt *FloatRangePattern) Range() FloatRange + func (patt *FloatRangePattern) StringPattern() (StringPattern, bool) + func (patt *FloatRangePattern) Test(ctx *Context, v Value) bool + type FloatRangeStringPattern struct + func NewFloatRangeStringPattern(lower, upperIncluded float64, node parse.Node) *FloatRangeStringPattern + func (p *FloatRangeStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *FloatRangeStringPattern) CompiledRegex() *regexp.Regexp + func (patt *FloatRangeStringPattern) EffectiveLengthRange() IntRange + func (patt *FloatRangeStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *FloatRangeStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *FloatRangeStringPattern) HasRegex() bool + func (patt *FloatRangeStringPattern) IsMutable() bool + func (patt *FloatRangeStringPattern) IsResolved() bool + func (patt *FloatRangeStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *FloatRangeStringPattern) LengthRange() IntRange + func (patt *FloatRangeStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *FloatRangeStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *FloatRangeStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *FloatRangeStringPattern) Regex() string + func (patt *FloatRangeStringPattern) Resolve() (StringPattern, error) + func (patt *FloatRangeStringPattern) StringFrom(ctx *Context, v Value) (string, error) + func (patt *FloatRangeStringPattern) StringPattern() (StringPattern, bool) + func (patt *FloatRangeStringPattern) Test(ctx *Context, v Value) bool + func (patt *FloatRangeStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *FloatRangeStringPattern) Random(ctx *Context, options ...Option) Value + type Format interface + Format func(ctx *Context, arg Value, w io.Writer) (int, error) + type FreeEntityLoadingParams struct + AllowMissing bool + InitialValue Serializable + Key Path + Migration *FreeEntityMigrationArgs + Pattern Pattern + Storage DataStore + func (a FreeEntityLoadingParams) IsDeletion(ctx *Context) bool + type FreeEntityMigrationArgs struct + MigrationHandlers MigrationOpHandlers + NextPattern Pattern + type Frequency float64 + func (f Frequency) Compare(other Value) (result int, comparable bool) + func (f Frequency) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (f Frequency) IsMutable() bool + func (f Frequency) IsZeroRate() bool + func (f Frequency) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (f Frequency) QuantityPerSecond() Value + func (f Frequency) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (f Frequency) Validate() error + func (f Frequency) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type FunctionPattern struct + func (p *FunctionPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *FunctionPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *FunctionPattern) Random(ctx *Context, options ...Option) Value + func (patt *FunctionPattern) StringPattern() (StringPattern, bool) + func (patt *FunctionPattern) Test(ctx *Context, v Value) bool + func (patt *FunctionPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *FunctionPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *FunctionPattern) IsMutable() bool + func (pattern *FunctionPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type FunctionStaticData struct + type GenericWatcher struct + func NewGenericWatcher(config WatcherConfiguration) *GenericWatcher + func (w *GenericWatcher) Config() WatcherConfiguration + func (w *GenericWatcher) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (w *GenericWatcher) InformAboutAsync(ctx *Context, v Value) + func (w *GenericWatcher) IsMutable() bool + func (w *GenericWatcher) IsStopped() bool + func (w *GenericWatcher) Stop() + func (w *GenericWatcher) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (w *GenericWatcher) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (w *GenericWatcher) WaitNext(ctx *Context, additionalFilter Pattern, timeout time.Duration) (Value, error) + func (watcher *GenericWatcher) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type GlobalConstness = int + const GlobalConst + const GlobalVar + type GlobalState struct + Bytecode *Bytecode + Ctx *Context + Databases map[string]*DatabaseIL + Debugger atomic.Value + FirstDatabaseOpeningError error + GetBaseGlobalsForImportedModule func(ctx *Context, manifest *Manifest) (GlobalVariables, error) + GetBasePatternsForImportedModule func() (map[string]Pattern, map[string]*PatternNamespace) + Globals GlobalVariables + Heap *ModuleHeap + LThread *LThread + LogLevels *LogLevels + Logger zerolog.Logger + MainPreinitError error + MainState *GlobalState + Manifest *Manifest + Module *Module + Out io.Writer + OutputFieldsInitialized atomic.Bool + PrenitStaticCheckErrors []*StaticCheckError + Project Project + StaticCheckData *StaticCheckData + SymbolicBaseGlobalsForImportedModule map[string]symbolic.Value + SymbolicData *SymbolicData + SystemGraph *SystemGraph + TestingState TestingState + func NewGlobalState(ctx *Context, constants ...map[string]Value) *GlobalState + func (*GlobalState) IsMutable() bool + func (*GlobalState) PropertyNames(ctx *Context) []string + func (*GlobalState) SetProp(ctx *Context, name string, value Value) error + func (g *GlobalState) ComputePriority() ModulePriority + func (g *GlobalState) GetGoMethod(name string) (*GoFunction, bool) + func (g *GlobalState) InitSystemGraph() + func (g *GlobalState) IsMain() bool + func (g *GlobalState) Prop(ctx *Context, name string) Value + func (g *GlobalState) ProposeSystemGraph(v SystemGraphNodeValue, optionalName string) + func (g *GlobalState) SetDescendantState(src ResourceName, state *GlobalState) + func (s *GlobalState) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *GlobalState) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *GlobalState) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type GlobalVarPermission struct + Kind_ PermissionKind + Name string + func (perm GlobalVarPermission) Includes(otherPerm Permission) bool + func (perm GlobalVarPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm GlobalVarPermission) Kind() PermissionKind + func (perm GlobalVarPermission) String() string + type GlobalVariables struct + func GlobalVariablesFromMap(m map[string]Value, startConstants []string) GlobalVariables + func (g *GlobalVariables) CheckedGet(name string) (Value, bool) + func (g *GlobalVariables) Constants() map[string]Value + func (g *GlobalVariables) Entries() map[string]Value + func (g *GlobalVariables) Foreach(fn func(name string, v Value, isStartConstant bool) error) error + func (g *GlobalVariables) Get(name string) Value + func (g *GlobalVariables) Has(name string) bool + func (g *GlobalVariables) PopCapturedGlobals() + func (g *GlobalVariables) PushCapturedGlobals(captured []capturedGlobal) + func (g *GlobalVariables) Set(name string, value Value) + func (g *GlobalVariables) SetCheck(name string, value Value, allow func(defined bool) error) error + type GoFunction struct + func WrapGoClosure(goFn any) *GoFunction + func WrapGoFunction(goFn any) *GoFunction + func WrapGoMethod(goFn any) *GoFunction + func (*GoFunction) GetGoMethod(name string) (*GoFunction, bool) + func (*GoFunction) PropertyNames(ctx *Context) []string + func (*GoFunction) SetProp(ctx *Context, name string, value Value) error + func (f *GoFunction) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (fn *GoFunction) GoFunc() any + func (fn *GoFunction) IsSharable(originState *GlobalState) (bool, string) + func (fn *GoFunction) IsShared() bool + func (fn *GoFunction) Kind() GoFunctionKind + func (fn *GoFunction) Prop(ctx *Context, name string) Value + func (fn *GoFunction) Share(originState *GlobalState) + func (fn *GoFunction) SmartLock(state *GlobalState) + func (fn *GoFunction) SmartUnlock(state *GlobalState) + func (goFunc *GoFunction) Call(args []any, globalState, extState *GlobalState, isExt, must bool) (Value, error) + func (goFunc *GoFunction) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (goFunc *GoFunction) IsMutable() bool + func (v *GoFunction) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type GoFunctionKind int + const GoClosure + const GoFunc + const GoMethod + type GoValue interface + GetGoMethod func(name string) (*GoFunction, bool) + type GracefulTearDownTaskFn func(ctx *Context) error + type GracefulTeardownStatus int32 + const GracefullyTearedDown + const GracefullyTearedDownWithCancellation + const GracefullyTearedDownWithErrors + const GracefullyTearingDown + const NeverStartedGracefulTeardown + type GroupMatchesFindConfig struct + Kind GroupMatchesFindConfigKind + type GroupMatchesFindConfigKind int + const FindAllGroupMatches + const FindFirstGroupMatches + type GroupPattern interface + FindGroupMatches func(*Context, Serializable, GroupMatchesFindConfig) (groups []*Object, err error) + MatchGroups func(*Context, Serializable) (groups map[string]Serializable, ok bool, err error) + type HeapAddress *byte + func Alloc[T any](h *ModuleHeap, size int, alignment int) HeapAddress + func HeapAddressFromUintptr(ptr uintptr) HeapAddress + type Host string + func (Host) SetProp(ctx *Context, name string, value Value) error + func (h Host) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (host Host) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (host Host) ExplicitPort() int + func (host Host) HasHttpScheme() bool + func (host Host) HostWithoutPort() Host + func (host Host) IsMutable() bool + func (host Host) Name() string + func (host Host) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (host Host) Prop(ctx *Context, name string) Value + func (host Host) PropertyNames(ctx *Context) []string + func (host Host) ResourceName() string + func (host Host) Scheme() Scheme + func (host Host) URLWithPath(absPath Path) URL + func (host Host) UnderlyingString() string + func (host Host) Validate() error + func (host Host) WithoutScheme() string + func (host Host) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (patt Host) HasScheme() bool + type HostPattern string + func (HostPattern) Call(values []Serializable) (Pattern, error) + func (HostPattern) SetProp(ctx *Context, name string, value Value) error + func (HostPattern) StringPattern() (StringPattern, bool) + func (host HostPattern) WithoutScheme() string + func (p HostPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt HostPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt HostPattern) HasScheme() bool + func (patt HostPattern) Includes(ctx *Context, v Value) bool + func (patt HostPattern) IsMutable() bool + func (patt HostPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt HostPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt HostPattern) Prop(ctx *Context, name string) Value + func (patt HostPattern) PropertyNames(ctx *Context) []string + func (patt HostPattern) Scheme() Scheme + func (patt HostPattern) Test(ctx *Context, v Value) bool + func (patt HostPattern) UnderlyingString() string + func (patt HostPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern HostPattern) Random(ctx *Context, options ...Option) Value + type HttpPermission struct + AnyEntity bool + Entity WrappedString + Kind_ PermissionKind + func CreateHttpReadPerm(entity WrappedString) HttpPermission + func (perm HttpPermission) Includes(otherPerm Permission) bool + func (perm HttpPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm HttpPermission) Kind() PermissionKind + func (perm HttpPermission) String() string + type IProps interface + Prop func(ctx *Context, name string) Value + PropertyNames func(*Context) []string + SetProp func(ctx *Context, name string, value Value) error + type IPropsPattern interface + ValuePropPattern func(name string) (propPattern Pattern, isOptional bool, ok bool) + ValuePropertyNames func() []string + type IPseudoAdd interface + Add func(right Value) (Value, error) + type IPseudoSub interface + Sub func(right Value) (Value, error) + type IWithSecondaryContext interface + WithSecondaryContext func(*Context) any + WithoutSecondaryContext func() any + type Identifier string + func (i Identifier) Equal(ctx *Context, otherIdent Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (i Identifier) IsMutable() bool + func (i Identifier) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (i Identifier) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (i Identifier) UnderlyingString() string + func (i Identifier) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type IdleEventSourceHandler struct + DontWaitForFirstEvent bool + IsIgnoredEvent func(*Event) Bool + Microtask func() + MinimumLastEventAge time.Duration + type Image interface + FilesystemSnapshot func() FilesystemSnapshot + type ImportConfig struct + ArgObj *Object + GrantedPermListing *Object + Insecure bool + ParentState *GlobalState + Src ResourceName + Timeout time.Duration + ValidationString String + type InMemoryModuleParsingConfig struct + Context *Context + Name string + type InMemorySnapshotable interface + IsFrozen func() bool + TakeInMemorySnapshot func(ctx *Context) (*Snapshot, error) + Unfreeze func(ctx *Context) error + type IncludableChunkfilePreparationArgs struct + Fpath string + IncludedChunkContextFileSystem afs.Filesystem + LogOut io.Writer + Out io.Writer + ParsingContext *Context + StdlibCtx context.Context + type IncludedChunk struct + IncludedChunkForest []*IncludedChunk + OriginalErrors []*parse.ParsingError + ParsingErrorPositions []parse.SourcePositionRange + ParsingErrors []Error + func ParseLocalSecondaryChunk(config LocalSecondaryChunkParsingConfig) (*IncludedChunk, error) + type InclusionMigrationOp struct + Optional bool + Value Pattern + func (op InclusionMigrationOp) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) symbolic.MigrationOp + type IncomingMessageReceivedEvent struct + MessageType string + Url string + func (e IncomingMessageReceivedEvent) SecondaryDebugEventType() SecondaryDebugEventType + type Indexable interface + At func(ctx *Context, i int) Value + Len func() int + type InoxFunction struct + Chunk *parse.ParsedChunkSource + Node parse.Node + func (f *InoxFunction) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (f *InoxFunction) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (f *InoxFunction) RemoveMutationCallbackMicrotasks(ctx *Context) + func (f *InoxFunction) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (f *InoxFunction) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (fn *InoxFunction) Call(globalState *GlobalState, self Value, args []Value, disabledArgSharing []bool) (Value, error) + func (fn *InoxFunction) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (fn *InoxFunction) FuncExpr() *parse.FunctionExpression + func (fn *InoxFunction) IsMutable() bool + func (fn *InoxFunction) IsSharable(originState *GlobalState) (bool, string) + func (fn *InoxFunction) IsShared() bool + func (fn *InoxFunction) Share(originState *GlobalState) + func (fn *InoxFunction) SmartLock(state *GlobalState) + func (fn *InoxFunction) SmartUnlock(state *GlobalState) + func (fn *InoxFunction) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (g *InoxFunction) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type InstructionCallbackFn = func(instr []byte, op Opcode, operands []int, constantIndexOperandIndex []int, ...) ([]byte, error) + type Int int64 + func (i Int) Compare(other Value) (result int, comparable bool) + func (i Int) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (i Int) Int64() int64 + func (i Int) IsMutable() bool + func (i Int) IsSigned() bool + func (i Int) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (i Int) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (i Int) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (n Int) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (n Int) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + type IntList = NumberList[Int] + type IntRange struct + func NewIntRange(start, inclusiveEnd int64) IntRange + func NewUnknownStartIntRange(end int64) IntRange + func (r IntRange) At(ctx *Context, i int) Value + func (r IntRange) Contains(ctx *Context, v Serializable) bool + func (r IntRange) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r IntRange) HasKnownStart() bool + func (r IntRange) Includes(ctx *Context, i Int) bool + func (r IntRange) InclusiveEnd() int64 + func (r IntRange) IsEmpty(ctx *Context) bool + func (r IntRange) IsMutable() bool + func (r IntRange) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (r IntRange) KnownStart() int64 + func (r IntRange) Len() int + func (r IntRange) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r IntRange) Random(ctx *Context) Value + func (r IntRange) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r IntRange) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type IntRangeIterator struct + func (it *IntRangeIterator) HasNext(*Context) bool + func (it *IntRangeIterator) Key(ctx *Context) Value + func (it *IntRangeIterator) Next(ctx *Context) bool + func (it *IntRangeIterator) Value(*Context) Value + func (it IntRangeIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it IntRangeIterator) IsMutable() bool + func (it IntRangeIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it IntRangeIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type IntRangePattern struct + func NewIncludedEndIntRangePattern(start, end int64, multipleOf int64) *IntRangePattern + func NewIntRangePattern(intRange IntRange, multipleOf int64) *IntRangePattern + func NewIntRangePatternFloatMultiple(intRange IntRange, multipleOf Float) *IntRangePattern + func NewSingleElementIntRangePattern(n int64) *IntRangePattern + func (p *IntRangePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p IntRangePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (patt *IntRangePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *IntRangePattern) HasMultipleOfConstraint() bool + func (patt *IntRangePattern) Includes(ctx *Context, n Int) bool + func (patt *IntRangePattern) IsMutable() bool + func (patt *IntRangePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *IntRangePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *IntRangePattern) Random(ctx *Context, options ...Option) Value + func (patt *IntRangePattern) Range() IntRange + func (patt *IntRangePattern) StringPattern() (StringPattern, bool) + func (patt *IntRangePattern) Test(ctx *Context, v Value) bool + type IntRangeStringPattern struct + func NewIntRangeStringPattern(lower, upperIncluded int64, node parse.Node) *IntRangeStringPattern + func (p *IntRangeStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *IntRangeStringPattern) CompiledRegex() *regexp.Regexp + func (patt *IntRangeStringPattern) EffectiveLengthRange() IntRange + func (patt *IntRangeStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *IntRangeStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *IntRangeStringPattern) HasRegex() bool + func (patt *IntRangeStringPattern) IsMutable() bool + func (patt *IntRangeStringPattern) IsResolved() bool + func (patt *IntRangeStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *IntRangeStringPattern) LengthRange() IntRange + func (patt *IntRangeStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *IntRangeStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *IntRangeStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *IntRangeStringPattern) Regex() string + func (patt *IntRangeStringPattern) Resolve() (StringPattern, error) + func (patt *IntRangeStringPattern) StringFrom(ctx *Context, v Value) (string, error) + func (patt *IntRangeStringPattern) StringPattern() (StringPattern, bool) + func (patt *IntRangeStringPattern) Test(ctx *Context, v Value) bool + func (patt *IntRangeStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *IntRangeStringPattern) Random(ctx *Context, options ...Option) Value + type Integral interface + Int64 func() int64 + IsSigned func() bool + type InternalPublicationId int64 + type IntersectionPattern struct + func NewIntersectionPattern(cases []Pattern, node parse.Node) *IntersectionPattern + func (p *IntersectionPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *IntersectionPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *IntersectionPattern) IsMutable() bool + func (patt *IntersectionPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *IntersectionPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *IntersectionPattern) Random(ctx *Context, options ...Option) Value + func (patt *IntersectionPattern) StringPattern() (StringPattern, bool) + func (patt *IntersectionPattern) Test(ctx *Context, v Value) bool + func (patt IntersectionPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type IpropsIterator struct + func (it *IpropsIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *IpropsIterator) HasNext(*Context) bool + func (it *IpropsIterator) IsMutable() bool + func (it *IpropsIterator) Key(*Context) Value + func (it *IpropsIterator) Next(ctx *Context) bool + func (it *IpropsIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *IpropsIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *IpropsIterator) Value(*Context) Value + type Iterable interface + Iterator func(*Context, IteratorConfiguration) Iterator + type IterationChange int + const BreakIteration + const ContinueIteration + const NoIterationChange + const PruneWalk + func (change IterationChange) String() string + type Iterator interface + HasNext func(*Context) bool + Key func(*Context) Value + Next func(*Context) bool + Value func(*Context) Value + func NewEventSourceIterator(source EventSource, config IteratorConfiguration) Iterator + func NewIpropsIterator(ctx *Context, keys []string, values []Value, config IteratorConfiguration) Iterator + type IteratorConfiguration struct + KeyFilter Pattern + KeysNeverRead bool + ValueFilter Pattern + func (config IteratorConfiguration) CreateIterator(base Iterator) Iterator + type JSONSerializationConfig struct + Location string + Pattern Pattern + type KeyFilteredIterator struct + func (it *KeyFilteredIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *KeyFilteredIterator) HasNext(ctx *Context) bool + func (it *KeyFilteredIterator) IsMutable() bool + func (it *KeyFilteredIterator) Key(ctx *Context) Value + func (it *KeyFilteredIterator) Next(ctx *Context) bool + func (it *KeyFilteredIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *KeyFilteredIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *KeyFilteredIterator) Value(ctx *Context) Value + type KeyList []string + func (l KeyList) At(ctx *Context, i int) Value + func (l KeyList) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (l KeyList) Len() int + func (l KeyList) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list KeyList) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list KeyList) IsMutable() bool + func (list KeyList) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list KeyList) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type KeyValueFilteredIterator struct + func (it *KeyValueFilteredIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *KeyValueFilteredIterator) HasNext(ctx *Context) bool + func (it *KeyValueFilteredIterator) IsMutable() bool + func (it *KeyValueFilteredIterator) Key(ctx *Context) Value + func (it *KeyValueFilteredIterator) Next(ctx *Context) bool + func (it *KeyValueFilteredIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *KeyValueFilteredIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *KeyValueFilteredIterator) Value(ctx *Context) Value + type LThread struct + func ImportModule(config ImportConfig) (*LThread, error) + func SpawnLThread(args LthreadSpawnArgs) (*LThread, error) + func SpawnLthreadWithState(args LthreadWithStateSpawnArgs) (*LThread, error) + func (*LThread) PropertyNames(ctx *Context) []string + func (*LThread) SetProp(ctx *Context, name string, value Value) error + func (lthread *LThread) Cancel(*Context) + func (lthread *LThread) IsDone() bool + func (lthread *LThread) IsPaused() bool + func (lthread *LThread) ResumeAsync() error + func (lthread *LThread) WaitResult(ctx *Context) (Value, error) + func (r *LThread) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r *LThread) GetGoMethod(name string) (*GoFunction, bool) + func (r *LThread) IsMutable() bool + func (r *LThread) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r *LThread) Prop(ctx *Context, name string) Value + func (r *LThread) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type LThreadGroup struct + func NewLThreadGroup(ctx *Context) *LThreadGroup + func (*LThreadGroup) PropertyNames(ctx *Context) []string + func (*LThreadGroup) SetProp(ctx *Context, name string, value Value) error + func (g *LThreadGroup) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (g *LThreadGroup) GetGoMethod(name string) (*GoFunction, bool) + func (g *LThreadGroup) IsMutable() bool + func (g *LThreadGroup) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (g *LThreadGroup) Prop(ctx *Context, name string) Value + func (g *LThreadGroup) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (group *LThreadGroup) Add(newRt *LThread) + func (group *LThreadGroup) CancelAll(*Context) + func (group *LThreadGroup) WaitAllResults(ctx *Context) (*Array, error) + type LThreadPermission struct + Kind_ PermissionKind + func (perm LThreadPermission) Includes(otherPerm Permission) bool + func (perm LThreadPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm LThreadPermission) Kind() PermissionKind + func (perm LThreadPermission) String() string + type LThreadSpawnedEvent struct + StateId StateId + func (e LThreadSpawnedEvent) SecondaryDebugEventType() SecondaryDebugEventType + type LengthCheckingStringPattern struct + func NewLengthCheckingStringPattern(minLength, maxLength int64) *LengthCheckingStringPattern + func (p *LengthCheckingStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *LengthCheckingStringPattern) CompiledRegex() *regexp.Regexp + func (patt *LengthCheckingStringPattern) EffectiveLengthRange() IntRange + func (patt *LengthCheckingStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *LengthCheckingStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *LengthCheckingStringPattern) IsMutable() bool + func (patt *LengthCheckingStringPattern) LengthRange() IntRange + func (patt *LengthCheckingStringPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *LengthCheckingStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *LengthCheckingStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *LengthCheckingStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *LengthCheckingStringPattern) Resolve() (StringPattern, error) + func (patt *LengthCheckingStringPattern) StringPattern() (StringPattern, bool) + func (patt LengthCheckingStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt LengthCheckingStringPattern) Random(ctx *Context, options ...Option) Value + func (patt LengthCheckingStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *LengthCheckingStringPattern) HasRegex() bool + func (pattern *LengthCheckingStringPattern) IsResolved() bool + func (pattern *LengthCheckingStringPattern) Regex() string + func (pattern *LengthCheckingStringPattern) Test(ctx *Context, v Value) bool + type LifetimeJob struct + func NewLifetimeJob(meta Value, subjectPattern Pattern, mod *Module, bytecode *Bytecode, ...) (*LifetimeJob, error) + func (*LifetimeJob) IsMutable() bool + func (*LifetimeJob) PropertyNames(ctx *Context) []string + func (*LifetimeJob) SetProp(ctx *Context, name string, value Value) error + func (j *LifetimeJob) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (j *LifetimeJob) GetGoMethod(name string) (*GoFunction, bool) + func (j *LifetimeJob) Instantiate(ctx *Context, self Value) (*LifetimeJobInstance, error) + func (j *LifetimeJob) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (j *LifetimeJob) Prop(ctx *Context, name string) Value + func (j *LifetimeJob) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (j *LifetimeJob) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type LifetimeJobInstance struct + type Limit struct + DecrementFn TokenDepletionFn + Kind LimitKind + Name string + Value int64 + func GetDefaultMaxRequestHandlerLimits() []Limit + func GetDefaultRequestHandlingLimits() []Limit + func GetDefaultScriptLimits() []Limit + func GetLimit(ctx *Context, limitName string, limitValue Serializable) (_ Limit, resultErr error) + func MustMakeNotAutoDepletingCountLimit(limitName string, value int64) Limit + func (l Limit) LessOrAsRestrictiveAs(other Limit) bool + func (l Limit) MoreRestrictiveThan(other Limit) bool + type LimitKind int + type LineCount int64 + func (c LineCount) AsFloat64() (float64, bool) + func (c LineCount) AsInt64() (int64, bool) + func (c LineCount) Compare(other Value) (result int, comparable bool) + func (c LineCount) Int64() int64 + func (c LineCount) IsSigned() bool + func (c LineCount) IsZeroQuantity() bool + func (c LineCount) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (count LineCount) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (count LineCount) IsMutable() bool + func (count LineCount) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (count LineCount) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type List struct + func Filter(ctx *Context, iterable Iterable, condition Value) *List + func GetAtMost(ctx *Context, maxCount Int, iterable SerializableIterable) *List + func MapIterable(ctx *Context, iterable Iterable, mapper Value) *List + func NewWrappedBoolList(elements ...Bool) *List + func NewWrappedFloatList(elements ...Float) *List + func NewWrappedFloatListFrom(elements []Float) *List + func NewWrappedIntList(elements ...Int) *List + func NewWrappedIntListFrom(elements []Int) *List + func NewWrappedStringList(elements ...StringLike) *List + func NewWrappedStringListFrom(elements []StringLike) *List + func NewWrappedValueList(elements ...Serializable) *List + func NewWrappedValueListFrom(elements []Serializable) *List + func WrapUnderlyingList(l underlyingList) *List + func (*List) PropertyNames(ctx *Context) []string + func (*List) SetProp(ctx *Context, name string, value Value) error + func (l *List) Contains(ctx *Context, value Serializable) bool + func (l *List) Dequeue(ctx *Context) Serializable + func (l *List) IsEmpty(ctx *Context) bool + func (l *List) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (l *List) Pop(ctx *Context) Serializable + func (l *List) Prop(ctx *Context, name string) Value + func (l *List) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (l *List) RemoveMutationCallbackMicrotasks(ctx *Context) + func (l *List) SetSlice(ctx *Context, start, end int, seq Sequence) + func (l *List) SortBy(ctx *Context, path ValuePath, orderIdent Identifier) + func (l *List) Sorted(ctx *Context, orderIdent Identifier) *List + func (l *List) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list *List) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (list *List) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list *List) GetOrBuildElements(ctx *Context) []Serializable + func (list *List) IsMutable() bool + func (list *List) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (list *List) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (list *List) Migrate(ctx *Context, key Path, migration *FreeEntityMigrationArgs) (Value, error) + func (list *List) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list *List) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (list *List) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (list *List) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ListPattern struct + func NewListPattern(elementPatterns []Pattern) *ListPattern + func NewListPatternOf(generalElementPattern Pattern) *ListPattern + func NewListPatternVariadic(elementPatterns ...Pattern) *ListPattern + func (p *ListPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *ListPattern) DefaultValue(ctx *Context) (Value, error) + func (patt *ListPattern) ElementPatternAt(i int) (Pattern, bool) + func (patt *ListPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *ListPattern) ExactElementCount() (int, bool) + func (patt *ListPattern) GetMigrationOperations(ctx *Context, next Pattern, pseudoPath string) (migrations []MigrationOp, _ error) + func (patt *ListPattern) IsMutable() bool + func (patt *ListPattern) MaxElementCount() int + func (patt *ListPattern) MinElementCount() int + func (patt *ListPattern) StringPattern() (StringPattern, bool) + func (patt *ListPattern) WithElement(element Pattern) *ListPattern + func (patt *ListPattern) WithMinElements(minCount int) *ListPattern + func (patt *ListPattern) WithMinMaxElements(minCount, maxCount int) *ListPattern + func (patt ListPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt ListPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt ListPattern) Random(ctx *Context, options ...Option) Value + func (patt ListPattern) Test(ctx *Context, v Value) bool + func (patt ListPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type LiteTransactionIsolator struct + func (isolator *LiteTransactionIsolator) WaitForOtherReadWriteTxToTerminate(ctx *Context, requireRunningTx bool) (currentTx *Transaction, _ error) + type LoadSelfManagedEntityFn func(ctx *Context, args FreeEntityLoadingParams) (UrlHolder, error) + type LocalSecondaryChunkParsingConfig struct + ChunkFilepath string + Context *Context + ImportPosition parse.SourcePositionRange + Module *Module + RecoverFromNonExistingIncludedFiles bool + type LocatedEvalError struct + Location parse.SourcePositionStack + Message string + func (e LocatedEvalError) Unwrap() error + func (err LocatedEvalError) LocationStack() parse.SourcePositionStack + func (err LocatedEvalError) MessageWithoutLocation() string + type LockedContextData struct + HostAliases map[string]Host + NamedPatterns map[string]Pattern + PatternNamespaces map[string]*PatternNamespace + type LogLevels struct + func NewLogLevels(init LogLevelsInitialization) *LogLevels + func (l *LogLevels) AreInternalDebugLogsEnabled() bool + func (l *LogLevels) LevelFor(resourceName ResourceName) zerolog.Level + type LogLevelsInitialization struct + ByPath map[Path]zerolog.Level + DefaultLevel zerolog.Level + EnableInternalDebugLogs bool + type LongValuePath []ValuePathSegment + func NewLongValuePath(segments []ValuePathSegment) *LongValuePath + func (p *LongValuePath) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (p *LongValuePath) GetFrom(ctx *Context, v Value) Value + func (p *LongValuePath) IsMutable() bool + func (p *LongValuePath) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (p *LongValuePath) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p *LongValuePath) Validate() error + func (p *LongValuePath) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type LoopKind int + const ForLoop + const WalkLoop + type LthreadSpawnArgs struct + Bytecode *Bytecode + Globals GlobalVariables + IgnoreCreateLThreadPermCheck bool + IsTestingEnabled bool + Logger zerolog.Logger + LthreadCtx *Context + Manifest *Manifest + Module *Module + NewGlobals []string + PauseAfterYield bool + Self Value + SpawnerState *GlobalState + StartPaused bool + TestFilters TestFilters + TestItem TestItem + TestedProgram *Module + Timeout time.Duration + UseBytecode bool + type LthreadWithStateSpawnArgs struct + PauseAfterYield bool + Self Value + SpawnerState *GlobalState + StartPaused bool + State *GlobalState + Timeout time.Duration + UseBytecode bool + type Manifest struct + AutoInvocation *AutoInvocationConfig + Databases DatabaseConfigs + EnvPattern *ObjectPattern + HostDefinitions map[Host]Value + InitialWorkingDirectory Path + Limits []Limit + Parameters ModuleParameters + PreinitFiles PreinitFiles + RequiredPermissions []Permission + func NewEmptyManifest() *Manifest + func (m *Manifest) ArePermsGranted(grantedPerms []Permission, forbiddenPermissions []Permission) (b bool, missingPermissions []Permission) + func (m *Manifest) OwnedDatabases() []DatabaseConfig + func (m *Manifest) RequiresPermission(perm Permission) bool + func (m *Manifest) Usage(ctx *Context) string + type Mapping struct + func NewMapping(expr *parse.MappingExpression, state *GlobalState) (*Mapping, error) + func (*Mapping) PropertyNames(ctx *Context) []string + func (*Mapping) SetProp(ctx *Context, name string, value Value) error + func (*Mapping) SmartLock(state *GlobalState) + func (*Mapping) SmartUnlock(state *GlobalState) + func (m *Mapping) Compute(ctx *Context, key Serializable) Value + func (m *Mapping) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (m *Mapping) GetGoMethod(name string) (*GoFunction, bool) + func (m *Mapping) IsMutable() bool + func (m *Mapping) IsSharable(originState *GlobalState) (bool, string) + func (m *Mapping) IsShared() bool + func (m *Mapping) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (m *Mapping) Prop(ctx *Context, name string) Value + func (m *Mapping) Share(originState *GlobalState) + func (m *Mapping) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (m *Mapping) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type MappingStaticData struct + type MatchesFindConfig struct + Kind MatchesFindConfigKind + type MatchesFindConfigKind int + const FindAllMatches + const FindFirstMatch + type Message struct + func NewMessage(data Value, sender Value) Message + func (Message) IsMutable() bool + func (Message) PropertyNames(ctx *Context) []string + func (Message) SetProp(ctx *Context, name string, value Value) error + func (m Message) Data() Value + func (m Message) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (m Message) Prop(ctx *Context, name string) Value + func (m Message) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (msg Message) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + type MessageReceiver interface + ReceiveMessage func(ctx *Context, msg Message) error + type MigrationAwarePattern interface + GetMigrationOperations func(ctx *Context, next Pattern, pseudoPath string) ([]MigrationOp, error) + type MigrationCapable interface + Migrate func(ctx *Context, key Path, migration *FreeEntityMigrationArgs) (Value, error) + type MigrationMixin struct + PseudoPath string + func (m MigrationMixin) GetPseudoPath() string + type MigrationOp interface + GetPseudoPath func() string + ToSymbolicValue func(ctx *Context, encountered map[uintptr]symbolic.Value) symbolic.MigrationOp + func GetMigrationOperations(ctx *Context, current, next Pattern, pseudoPath string) ([]MigrationOp, error) + func GetTopLevelEntitiesMigrationOperations(ctx *Context, current, next *ObjectPattern) ([]MigrationOp, error) + type MigrationOpHandler struct + Function *InoxFunction + InitialValue Serializable + func (h MigrationOpHandler) GetResult(ctx *Context, state *GlobalState) Value + type MigrationOpHandlers struct + Deletions map[PathPattern]*MigrationOpHandler + Inclusions map[PathPattern]*MigrationOpHandler + Initializations map[PathPattern]*MigrationOpHandler + Replacements map[PathPattern]*MigrationOpHandler + func (handlers MigrationOpHandlers) FilterByPrefix(path Path) MigrationOpHandlers + func (handlers MigrationOpHandlers) FilterTopLevel() MigrationOpHandlers + type MigrationOpKind int + const InclusionMigrationOperation + const InitializationMigrationOperation + const RemovalMigrationOperation + const ReplacementMigrationOperation + type Mimetype string + func GetMimeTypeFromExtension(extensionWithDot string) (Mimetype, bool) + func MimeTypeFrom(s string) (Mimetype, error) + func (mt Mimetype) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (mt Mimetype) IsMutable() bool + func (mt Mimetype) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (mt Mimetype) UnderlyingString() string + func (mt Mimetype) WithoutParams() Mimetype + func (mt Mimetype) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (t Mimetype) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type Module struct + DirectlyImportedModules map[string]*Module + DirectlyImportedModulesByStatement map[*parse.ImportStatement]*Module + FlattenedIncludedChunkList []*IncludedChunk + IncludedChunkForest []*IncludedChunk + IncludedChunkMap map[string]*IncludedChunk + InclusionStatementMap map[*parse.InclusionImportStatement]*IncludedChunk + MainChunk *parse.ParsedChunkSource + ManifestTemplate *parse.Manifest + OriginalErrors []*parse.ParsingError + ParsingErrorPositions []parse.SourcePositionRange + ParsingErrors []Error + func ParseInMemoryModule(codeString String, config InMemoryModuleParsingConfig) (*Module, error) + func ParseLocalModule(fpath string, config ModuleParsingConfig) (*Module, error) + func ParseModuleFromSource(src parse.ChunkSource, resource ResourceName, config ModuleParsingConfig) (*Module, error) + func (*Module) GetGoMethod(name string) (*GoFunction, bool) + func (*Module) IsMutable() bool + func (*Module) PropertyNames(ctx *Context) []string + func (*Module) SetProp(ctx *Context, name string, value Value) error + func (m *Module) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (m *Module) ParsingErrorTuple() *Tuple + func (m *Module) PreInit(preinitArgs PreinitArgs) (_ *Manifest, usedRunningState *TreeWalkState, _ []*StaticCheckError, ...) + func (m *Module) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (m *Module) Prop(ctx *Context, name string) Value + func (m *Module) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (mod *Module) AbsoluteSource() (ResourceName, bool) + func (mod *Module) HasURLSource() bool + func (mod *Module) ImportStatements() (imports []*parse.ImportStatement) + func (mod *Module) Name() string + func (mod *Module) ParameterNames() (names []string) + func (mod *Module) ToSymbolic() *symbolic.Module + type ModuleArgs struct + func NewEmptyModuleArgs() *ModuleArgs + func NewModuleArgs(fields map[string]Value) *ModuleArgs + func (args *ModuleArgs) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *ModuleArgs) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Value, error) + func (s *ModuleArgs) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *ModuleArgs) ForEachField(fn func(fieldName string, fieldValue Value) error) error + func (s *ModuleArgs) IsMutable() bool + func (s *ModuleArgs) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *ModuleArgs) Prop(ctx *Context, name string) Value + func (s *ModuleArgs) PropertyNames(*Context) []string + func (s *ModuleArgs) SetProp(ctx *Context, name string, value Value) error + func (s *ModuleArgs) ValueMap() map[string]Value + type ModuleComptimeTypes struct + func NewModuleComptimeTypes(symb *symbolic.ModuleCompileTimeTypes) *ModuleComptimeTypes + type ModuleHeap struct + Alloc func(size int, alignment int) HeapAddress + DeallocAll func() + func NewArenaHeap(initialCapacity int) *ModuleHeap + type ModuleKind int + const ApplicationModule + const LifetimeJobModule + const SpecModule + const TestCaseModule + const TestSuiteModule + const UnspecifiedModuleKind + const UserLThreadModule + func ParseModuleKind(s string) (ModuleKind, error) + func (k ModuleKind) IsEmbedded() bool + func (k ModuleKind) IsTestModule() bool + func (k ModuleKind) String() string + type ModuleParameter struct + func (p ModuleParameter) CliArgNames() string + func (p ModuleParameter) DefaultValue(ctx *Context) (Value, bool) + func (p ModuleParameter) GetArgumentFromCliArg(ctx *Context, s string) (v Serializable, handled bool, err error) + func (p ModuleParameter) GetRestArgumentFromCliArgs(ctx *Context, args []string) (v Value, err error) + func (p ModuleParameter) Name() string + func (p ModuleParameter) Pattern() Pattern + func (p ModuleParameter) RequiredOnCLI(ctx *Context) bool + func (p ModuleParameter) StringifiedPattern() string + func (p ModuleParameter) StringifiedPatternNoPercent() string + type ModuleParameters struct + func (p *ModuleParameters) GetArgumentsFromCliArgs(ctx *Context, cliArgs []string) (*ModuleArgs, error) + func (p *ModuleParameters) GetArgumentsFromObject(ctx *Context, argObj *Object) (*ModuleArgs, error) + func (p *ModuleParameters) GetArgumentsFromStruct(ctx *Context, argStruct *ModuleArgs) (*ModuleArgs, error) + func (p *ModuleParameters) GetSymbolicArguments(ctx *Context) *symbolic.ModuleArgs + func (p *ModuleParameters) NonPositionalParameters() []ModuleParameter + func (p *ModuleParameters) PositionalParameters() []ModuleParameter + func (p ModuleParameters) NoParameters() bool + type ModuleParamsPattern struct + func NewModuleParamsPattern(keys []string, types []Pattern) *ModuleParamsPattern + func (*ModuleParamsPattern) IsMutable() bool + func (*ModuleParamsPattern) StringPattern() (StringPattern, bool) + func (p *ModuleParamsPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (p *ModuleParamsPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (p *ModuleParamsPattern) Test(ctx *Context, v Value) bool + func (p *ModuleParamsPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (patt *ModuleParamsPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *ModuleParamsPattern) Random(ctx *Context, options ...Option) Value + func (s *ModuleParamsPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type ModuleParsingConfig struct + Context *Context + IgnoreBadlyConfiguredModuleImports bool + InsecureModImports bool + RecoverFromNonExistingIncludedFiles bool + type ModulePreparationArgs struct + AdditionalGlobalsTestOnly map[string]Value + AdditionalPermissions []Permission + AllowMissingEnvVars bool + Args *ModuleArgs + BeforeContextCreation func(*Manifest) ([]Limit, error) + CachedModule *Module + CliArgs []string + DataExtractionMode bool + DefaultLimits []Limit + EnableTesting bool + ForceExpectSchemaUpdate bool + Fpath string + FullAccessToDatabases bool + GetArguments func(*Manifest) (*ModuleArgs, error) + LogLevels *LogLevels + LogOut io.Writer + Logger zerolog.Logger + Out io.Writer + ParentContext *Context + ParentContextRequired bool + ParsingCompilationContext *Context + PreinitFilesystem afs.Filesystem + Project Project + ScriptContextFileSystem afs.Filesystem + StdlibCtx context.Context + TestFilters TestFilters + UseParentStateAsMainState bool + type ModulePriority uint32 + type ModuleRetrievalError struct + func (err ModuleRetrievalError) Error() string + type MutableLengthSequence interface + type MutableSequence interface + SetSlice func(ctx *Context, start, end int, v Sequence) + type Mutation struct + Complete bool + Data []byte + DataElementLengths [6]int32 + Depth WatchingDepth + Kind MutationKind + Path Path + SpecificMutationKind SpecificMutationKind + SpecificMutationVersion SpecificMutationVersion + Tx *Transaction + func NewAddEntryMutation(ctx *Context, key, value Serializable, depth WatchingDepth, path Path) Mutation + func NewAddPropMutation(ctx *Context, name string, value Serializable, depth WatchingDepth, path Path) Mutation + func NewInsertElemAtIndexMutation(ctx *Context, index int, elem Serializable, depth WatchingDepth, path Path) Mutation + func NewInsertSequenceAtIndexMutation(ctx *Context, index int, seq Sequence, depth WatchingDepth, path Path) Mutation + func NewRemovePositionMutation(ctx *Context, index int, depth WatchingDepth, path Path) Mutation + func NewRemovePositionRangeMutation(ctx *Context, intRange IntRange, depth WatchingDepth, path Path) Mutation + func NewSetElemAtIndexMutation(ctx *Context, index int, elem Serializable, depth WatchingDepth, path Path) Mutation + func NewSetSliceAtRangeMutation(ctx *Context, intRange IntRange, slice Serializable, depth WatchingDepth, ...) Mutation + func NewSpecificIncompleteNoDataMutation(meta SpecificMutationMetadata) Mutation + func NewSpecificMutation(ctx *Context, meta SpecificMutationMetadata, values ...Serializable) Mutation + func NewUnspecifiedMutation(depth WatchingDepth, path Path) Mutation + func NewUpdateEntryMutation(ctx *Context, key, newValue Serializable, depth WatchingDepth, path Path) Mutation + func NewUpdatePropMutation(ctx *Context, name string, newValue Serializable, depth WatchingDepth, ...) Mutation + func (m Mutation) AffectedIndex(ctx *Context) Int + func (m Mutation) AffectedProperty(ctx *Context) string + func (m Mutation) AffectedRange(ctx *Context) IntRange + func (m Mutation) ApplyTo(ctx *Context, v Value) error + func (m Mutation) DataElem(ctx *Context, index int) Value + func (m Mutation) Element(ctx *Context) Value + func (m Mutation) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (m Mutation) IsMutable() bool + func (m Mutation) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (m Mutation) PropValue(ctx *Context) Value + func (m Mutation) Relocalized(parent Path) Mutation + func (m Mutation) Sequence(ctx *Context) Sequence + func (m Mutation) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type MutationCallbackMicrotask func(ctx *Context, mutation Mutation) (registerAgain bool) + type MutationCallbacks struct + func NewMutationCallbacks() *MutationCallbacks + func (c *MutationCallbacks) AddMicrotask(m MutationCallbackMicrotask, config MutationWatchingConfiguration) (handle CallbackHandle) + func (c *MutationCallbacks) CallMicrotasks(ctx *Context, m Mutation) + func (c *MutationCallbacks) Functions() []mutationCallback + func (c *MutationCallbacks) RemoveMicrotask(handle CallbackHandle) + func (c *MutationCallbacks) RemoveMicrotasks() + type MutationKind int + const AddEntry + const AddProp + const InsertElemAtIndex + const InsertSequenceAtIndex + const RemovePosition + const RemovePositionRange + const SetElemAtIndex + const SetSliceAtRange + const SpecificMutation + const UnspecifiedMutation + const UpdateEntry + const UpdateProp + func (k MutationKind) String() string + type MutationPattern struct + func NewMutationPattern(kind MutationKind, data0Pattern Pattern) *MutationPattern + func (p *MutationPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *MutationPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *MutationPattern) IsMutable() bool + func (patt *MutationPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *MutationPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *MutationPattern) Random(ctx *Context, options ...Option) Value + func (patt *MutationPattern) StringPattern() (StringPattern, bool) + func (patt *MutationPattern) Test(ctx *Context, v Value) bool + func (patt *MutationPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type MutationWatchingConfiguration struct + Depth WatchingDepth + type NamedSegmentPathPattern struct + func NewNamedSegmentPathPattern(node *parse.NamedSegmentPathPatternLiteral) *NamedSegmentPathPattern + func (*NamedSegmentPathPattern) SetProp(ctx *Context, name string, value Value) error + func (p NamedSegmentPathPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *NamedSegmentPathPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *NamedSegmentPathPattern) FindGroupMatches(*Context, Serializable, GroupMatchesFindConfig) (groups []*Object, err error) + func (patt *NamedSegmentPathPattern) IsMutable() bool + func (patt *NamedSegmentPathPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *NamedSegmentPathPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *NamedSegmentPathPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *NamedSegmentPathPattern) Prop(ctx *Context, name string) Value + func (patt *NamedSegmentPathPattern) PropertyNames(ctx *Context) []string + func (patt *NamedSegmentPathPattern) StringPattern() (StringPattern, bool) + func (patt *NamedSegmentPathPattern) Test(ctx *Context, v Value) bool + func (patt *NamedSegmentPathPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *NamedSegmentPathPattern) Random(ctx *Context, options ...Option) Value + type Namespace struct + func NewMutableEntriesNamespace(name string, entries map[string]Value) *Namespace + func NewNamespace(name string, entries map[string]Value) *Namespace + func (*Namespace) SetProp(ctx *Context, name string, value Value) error + func (ns *Namespace) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (ns *Namespace) IsMutable() bool + func (ns *Namespace) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (ns *Namespace) Prop(ctx *Context, name string) Value + func (ns *Namespace) PropertyNames(ctx *Context) []string + func (ns *Namespace) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type NamespaceMemberPatternReprMixin struct + MemberName string + NamespaceName string + func (m NamespaceMemberPatternReprMixin) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (m NamespaceMemberPatternReprMixin) WriteRepresentation(ctx *Context, w io.Writer, config *ReprConfig, depth int) error + type NewDefaultContextFn func(config DefaultContextConfig) (*Context, error) + type NewDefaultGlobalStateFn func(ctx *Context, conf DefaultGlobalStateConfig) (*GlobalState, error) + type NilT int + func (Nil NilT) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (Nil NilT) IsMutable() bool + func (Nil NilT) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (Nil NilT) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (n NilT) String() string + func (n NilT) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type NillableInitializationMigrationOp struct + Value Pattern + func (op NillableInitializationMigrationOp) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) symbolic.MigrationOp + type NotAllowedError struct + Message string + Permission Permission + func NewNotAllowedError(perm Permission) *NotAllowedError + func (err NotAllowedError) Error() string + func (err NotAllowedError) Is(target error) bool + type NotCallablePatternMixin struct + func (NotCallablePatternMixin) Call(values []Serializable) (Pattern, error) + type NotRenderableMixin struct + func (m NotRenderableMixin) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (m NotRenderableMixin) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + type NumberList struct + func (l *NumberList[N]) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list *NumberList[T]) At(ctx *Context, i int) Value + func (list *NumberList[T]) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (list *NumberList[T]) ConstraintId() ConstraintId + func (list *NumberList[T]) ContainsSimple(ctx *Context, v Serializable) bool + func (list *NumberList[T]) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list *NumberList[T]) IsMutable() bool + func (list *NumberList[T]) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (list *NumberList[T]) Len() int + func (list *NumberList[T]) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list *NumberList[T]) SetSlice(ctx *Context, start, end int, seq Sequence) + func (list *NumberList[T]) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type NumberListIterator struct + func (it *NumberListIterator[T]) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *NumberListIterator[T]) IsMutable() bool + func (it *NumberListIterator[T]) Key(ctx *Context) Value + func (it *NumberListIterator[T]) Next(ctx *Context) bool + func (it *NumberListIterator[T]) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *NumberListIterator[T]) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *NumberListIterator[T]) Value(*Context) Value + func (it NumberListIterator[T]) HasNext(*Context) bool + type Object struct + func CreateDirEntry(path, walkedDirPath string, addDotSlashPrefix bool, d fs.DirEntry) *Object + func EvaluatePermissionListingObjectNode(n *parse.ObjectLiteral, config PreinitArgs) (*Object, error) + func NewObject() *Object + func NewObjectFromMap(valMap ValMap, ctx *Context) *Object + func NewObjectFromMapNoInit(valMap ValMap) *Object + func ParseObjectJSONrepresentation(ctx *Context, it *jsoniter.Iterator, pattern *ObjectPattern, try bool) (_ *Object, finalErr error) + func (o *Object) Migrate(ctx *Context, key Path, migration *FreeEntityMigrationArgs) (Value, error) + func (obj *Object) AddSystemGraphEvent(ctx *Context, text string) + func (obj *Object) Contains(ctx *Context, value Serializable) bool + func (obj *Object) EntryMap(ctx *Context) map[string]Serializable + func (obj *Object) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (obj *Object) ForEachElement(ctx *Context, fn func(index int, v Serializable) error) error + func (obj *Object) ForEachEntry(fn func(k string, v Serializable) error) error + func (obj *Object) HasProp(ctx *Context, name string) bool + func (obj *Object) HasPropValue(ctx *Context, value Value) bool + func (obj *Object) IsEmpty(ctx *Context) bool + func (obj *Object) IsMutable() bool + func (obj *Object) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (obj *Object) IsSharable(originState *GlobalState) (bool, string) + func (obj *Object) IsShared() bool + func (obj *Object) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (obj *Object) Keys(ctx *Context) []string + func (obj *Object) LifetimeJobs() *ValueLifetimeJobs + func (obj *Object) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (obj *Object) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (obj *Object) Prop(ctx *Context, name string) Value + func (obj *Object) PropNotStored(ctx *Context, name string) Value + func (obj *Object) PropertyNames(ctx *Context) []string + func (obj *Object) ProposeSystemGraph(ctx *Context, g *SystemGraph, proposedName string, ...) + func (obj *Object) ReceiveMessage(ctx *Context, msg Message) error + func (obj *Object) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (obj *Object) RemoveMutationCallbackMicrotasks(ctx *Context) + func (obj *Object) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (obj *Object) SetProp(ctx *Context, name string, value Value) error + func (obj *Object) SetURLOnce(ctx *Context, u URL) error + func (obj *Object) Share(originState *GlobalState) + func (obj *Object) SmartLock(state *GlobalState) + func (obj *Object) SmartUnlock(state *GlobalState) + func (obj *Object) SystemGraph() *SystemGraph + func (obj *Object) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (obj *Object) URL() (URL, bool) + func (obj *Object) ValueEntryMap(ctx *Context) map[string]Value + func (obj *Object) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (obj *Object) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ObjectPattern struct + func NewExactObjectPattern(entries []ObjectPatternEntry) *ObjectPattern + func NewInexactObjectPattern(entries []ObjectPatternEntry) *ObjectPattern + func NewObjectPattern(inexact bool, entries []ObjectPatternEntry) *ObjectPattern + func (p *ObjectPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *ObjectPattern) CompleteEntry(name string) (ObjectPatternEntry, bool) + func (patt *ObjectPattern) Entry(name string) (pattern Pattern, optional bool, yes bool) + func (patt *ObjectPattern) EntryCount() int + func (patt *ObjectPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *ObjectPattern) ForEachEntry(fn func(entry ObjectPatternEntry) error) error + func (patt *ObjectPattern) GetMigrationOperations(ctx *Context, next Pattern, pseudoPath string) (migrations []MigrationOp, _ error) + func (patt *ObjectPattern) HasRequiredOrOptionalEntry(name string) bool + func (patt *ObjectPattern) IsMutable() bool + func (patt *ObjectPattern) Random(ctx *Context, options ...Option) Value + func (patt *ObjectPattern) StringPattern() (StringPattern, bool) + func (patt *ObjectPattern) Test(ctx *Context, v Value) bool + func (patt *ObjectPattern) ValuePropPattern(name string) (propPattern Pattern, isOptional bool, ok bool) + func (patt *ObjectPattern) ValuePropertyNames() []string + func (patt *ObjectPattern) WithConstraints(constraints []*ComplexPropertyConstraint) *ObjectPattern + func (patt ObjectPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt ObjectPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt ObjectPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ObjectPatternEntriesHelper []ObjectPatternEntry + func (h ObjectPatternEntriesHelper) CompleteEntry(name string) (ObjectPatternEntry, bool) + func (h ObjectPatternEntriesHelper) Entry(name string) (pattern Pattern, optional bool, yes bool) + func (h ObjectPatternEntriesHelper) HasRequiredOrOptionalEntry(name string) bool + type ObjectPatternEntry struct + Dependencies PropertyDependencies + IsOptional bool + Name string + Pattern Pattern + func (e ObjectPatternEntry) Equal(ctx *Context, other ObjectPatternEntry, alreadyCompared map[uintptr]uintptr, ...) bool + type Opcode = byte + const BindCapturedLocals + const OpAddHostAlias + const OpAddPattern + const OpAddPatternNamespace + const OpAddTestCaseResult + const OpAddTestSuiteResult + const OpAllocStruct + const OpAndJump + const OpAppend + const OpAssert + const OpAt + const OpBlockLock + const OpBlockUnlock + const OpBooleanNot + const OpCall + const OpCallFromXMLFactory + const OpCallPattern + const OpComputedMemb + const OpConcatBytesLikes + const OpConcatStrLikes + const OpConcatTuples + const OpCopyTop + const OpCreateAddTypeExtension + const OpCreateDict + const OpCreateFloatRange + const OpCreateHost + const OpCreateIntRange + const OpCreateKeyList + const OpCreateLifetimeJob + const OpCreateList + const OpCreateListPattern + const OpCreateMapping + const OpCreateObject + const OpCreateObjectPattern + const OpCreateOption + const OpCreateOptionPattern + const OpCreateOptionalPattern + const OpCreateOrderedPair + const OpCreatePath + const OpCreatePathPattern + const OpCreatePatternNamespace + const OpCreateReceptionHandler + const OpCreateRecord + const OpCreateRecordPattern + const OpCreateRepeatedPatternElement + const OpCreateRuneRange + const OpCreateSequenceStringPattern + const OpCreateString + const OpCreateStringUnionPattern + const OpCreateStruct + const OpCreateTestCase + const OpCreateTestSuite + const OpCreateTreedata + const OpCreateTreedataHiearchyEntry + const OpCreateTuple + const OpCreateTuplePattern + const OpCreateURL + const OpCreateUnionPattern + const OpCreateUpperBoundRange + const OpCreateXMLelem + const OpDoSetDifference + const OpDropPerms + const OpDynMemb + const OpEqual + const OpExtensionMethod + const OpExtractProps + const OpFloatBin + const OpGetBoolField + const OpGetFloatField + const OpGetGlobal + const OpGetIntField + const OpGetLocal + const OpGetSelf + const OpGetStructPtrField + const OpGreater + const OpGreaterEqual + const OpGroupMatch + const OpImport + const OpIn + const OpIntBin + const OpIs + const OpIsNot + const OpIterInit + const OpIterKey + const OpIterNext + const OpIterNextChunk + const OpIterPrune + const OpIterValue + const OpJump + const OpJumpIfFalse + const OpKeyOf + const OpLess + const OpLessEqual + const OpLoadDBVal + const OpMatch + const OpMemb + const OpMinus + const OpMoveThirdTop + const OpNilCoalesce + const OpNoOp + const OpNotEqual + const OpNumBin + const OpObjPropNotStored + const OpOptionalMemb + const OpOrJump + const OpPatternNamespaceMemb + const OpPop + const OpPopIncludedChunk + const OpPopJumpIfTestDisabled + const OpPseudoArith + const OpPushConstant + const OpPushFalse + const OpPushIncludedChunk + const OpPushNil + const OpPushTrue + const OpRange + const OpResolveHost + const OpResolvePattern + const OpResolvePatternNamespace + const OpReturn + const OpRuntimeTypecheck + const OpSafeAt + const OpSendValue + const OpSetBoolField + const OpSetFloatField + const OpSetGlobal + const OpSetIndex + const OpSetIntField + const OpSetLocal + const OpSetMember + const OpSetSelf + const OpSetSlice + const OpSetStructPtrField + const OpSlice + const OpSpawnLThread + const OpSpreadList + const OpSpreadObject + const OpSpreadObjectPattern + const OpSpreadRecordPattern + const OpSpreadTuple + const OpStrConcat + const OpSubstrOf + const OpSuspendVM + const OpSwap + const OpToBool + const OpToPattern + const OpUrlOf + const OpWalkerInit + const OpYield + const OptStrQueryParamVal + type OpenDBFn func(ctx *Context, config DbOpenConfiguration) (Database, error) + func GetOpenDbFn(scheme Scheme) (OpenDBFn, bool) + type Option struct + Name string + Value Value + func (o Option) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (opt Option) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (opt Option) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (opt Option) IsMutable() bool + func (opt Option) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (opt Option) String() string + func (opt Option) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type OptionPattern struct + func (p *OptionPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *OptionPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *OptionPattern) IsMutable() bool + func (patt *OptionPattern) StringPattern() (StringPattern, bool) + func (patt OptionPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt OptionPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt OptionPattern) Random(ctx *Context, options ...Option) Value + func (patt OptionPattern) Test(ctx *Context, v Value) bool + func (patt OptionPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type OptionalParam struct + Value T + func ToOptionalParam[T Value](v T) *OptionalParam[T] + func ToValueOptionalParam(v Value) *OptionalParam[Value] + type OptionalPattern struct + func NewOptionalPattern(ctx *Context, pattern Pattern) (*OptionalPattern, error) + func (p *OptionalPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *OptionalPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *OptionalPattern) Random(ctx *Context, options ...Option) Value + func (patt *OptionalPattern) StringPattern() (StringPattern, bool) + func (patt *OptionalPattern) Test(ctx *Context, v Value) bool + func (pattern *OptionalPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *OptionalPattern) IsMutable() bool + func (pattern *OptionalPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pattern *OptionalPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Order = symbolic.Order + type OrderedPair [2]Serializable + func NewOrderedPair(first, second Serializable) *OrderedPair + func (p *OrderedPair) At(ctx *Context, i int) Value + func (p *OrderedPair) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (p *OrderedPair) GetOrBuildElements(ctx *Context) []Serializable + func (p *OrderedPair) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (p *OrderedPair) Len() int + func (p *OrderedPair) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p *OrderedPair) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (p OrderedPair) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (tuple *OrderedPair) IsMutable() bool + type ParserBasedPseudoPattern struct + func NewParserBasePattern(parser StatelessParser) *ParserBasedPseudoPattern + func (p *ParserBasedPseudoPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *ParserBasedPseudoPattern) CompiledRegex() *regexp.Regexp + func (patt *ParserBasedPseudoPattern) EffectiveLengthRange() IntRange + func (patt *ParserBasedPseudoPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *ParserBasedPseudoPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *ParserBasedPseudoPattern) IsMutable() bool + func (patt *ParserBasedPseudoPattern) IsResolved() bool + func (patt *ParserBasedPseudoPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *ParserBasedPseudoPattern) LengthRange() IntRange + func (patt *ParserBasedPseudoPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *ParserBasedPseudoPattern) PatternNestingDepth(parentDepth int) int + func (patt *ParserBasedPseudoPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *ParserBasedPseudoPattern) Resolve() (StringPattern, error) + func (patt *ParserBasedPseudoPattern) StringPattern() (StringPattern, bool) + func (patt *ParserBasedPseudoPattern) Test(ctx *Context, v Value) bool + func (patt ParserBasedPseudoPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *ParserBasedPseudoPattern) HasRegex() bool + func (pattern *ParserBasedPseudoPattern) Random(ctx *Context, options ...Option) Value + func (pattern *ParserBasedPseudoPattern) Regex() string + type Path string + func CreateTempdir(nameSecondPrefix string, fls afs.Filesystem) Path + func DirPathFrom(pth string) Path + func NonDirPathFrom(pth string) Path + func ParsePathLiteral(s string) (Path, bool) + func PathFrom(pth string) Path + func (Path) SetProp(ctx *Context, name string, value Value) error + func (p Path) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p Path) Walker(ctx *Context) (Walker, error) + func (pth Path) Basename() String + func (pth Path) CanBeDirOfEntry(absPath Path) bool + func (pth Path) DirPath() Path + func (pth Path) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pth Path) Extension() string + func (pth Path) IsAbsolute() bool + func (pth Path) IsDirPath() bool + func (pth Path) IsMutable() bool + func (pth Path) IsRelative() bool + func (pth Path) Join(relativePath Path, fls afs.Filesystem) Path + func (pth Path) JoinAbsolute(absPath Path, fls afs.Filesystem) Path + func (pth Path) JoinEntry(name string) Path + func (pth Path) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pth Path) Prop(ctx *Context, name string) Value + func (pth Path) PropertyNames(ctx *Context) []string + func (pth Path) RelativeEquiv() Path + func (pth Path) ResourceName() string + func (pth Path) ToAbs(fls afs.Filesystem) (Path, error) + func (pth Path) ToGlobbingPattern() PathPattern + func (pth Path) ToPrefixPattern() PathPattern + func (pth Path) UnderlyingString() string + func (pth Path) Validate() error + func (pth Path) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type PathPattern string + func (PathPattern) Call(values []Serializable) (Pattern, error) + func (PathPattern) SetProp(ctx *Context, name string, value Value) error + func (p PathPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt PathPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt PathPattern) Includes(ctx *Context, v Value) bool + func (patt PathPattern) IsAbsolute() bool + func (patt PathPattern) IsDirGlobbingPattern() bool + func (patt PathPattern) IsGlobbingPattern() bool + func (patt PathPattern) IsMutable() bool + func (patt PathPattern) IsPrefixPattern() bool + func (patt PathPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt PathPattern) Prefix() string + func (patt PathPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt PathPattern) Prop(ctx *Context, name string) Value + func (patt PathPattern) PropertyNames(ctx *Context) []string + func (patt PathPattern) StringPattern() (StringPattern, bool) + func (patt PathPattern) Test(ctx *Context, v Value) bool + func (patt PathPattern) ToAbs(fls afs.Filesystem) PathPattern + func (patt PathPattern) ToGlobbingPattern() PathPattern + func (patt PathPattern) UnderlyingString() string + func (patt PathPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern PathPattern) Random(ctx *Context, options ...Option) Value + type PathStringPattern struct + func NewStringPathPattern(pathPattern PathPattern) *PathStringPattern + func (p *PathStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *PathStringPattern) Call(values []Serializable) (Pattern, error) + func (patt *PathStringPattern) CompiledRegex() *regexp.Regexp + func (patt *PathStringPattern) EffectiveLengthRange() IntRange + func (patt *PathStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *PathStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *PathStringPattern) IsMutable() bool + func (patt *PathStringPattern) IsResolved() bool + func (patt *PathStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *PathStringPattern) LengthRange() IntRange + func (patt *PathStringPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *PathStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *PathStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *PathStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *PathStringPattern) Resolve() (StringPattern, error) + func (patt *PathStringPattern) StringPattern() (StringPattern, bool) + func (patt *PathStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *PathStringPattern) HasRegex() bool + func (pattern *PathStringPattern) Random(ctx *Context, options ...Option) Value + func (pattern *PathStringPattern) Regex() string + func (pattern *PathStringPattern) Test(ctx *Context, v Value) bool + type Pattern interface + Call func(values []Serializable) (Pattern, error) + Random func(ctx *Context, options ...Option) Value + StringPattern func() (StringPattern, bool) + Test func(*Context, Value) bool + func ConvertJsonSchemaToPattern(schemaBytes string) (Pattern, error) + func GetConstraint(constraintId ConstraintId) (Pattern, bool) + func NewMostAdaptedExactPattern(value Serializable) Pattern + type PatternDeserializer = func(ctx *Context, it *jsoniter.Iterator, pattern Pattern, try bool) (Pattern, error) + type PatternIterator struct + func NewEmptyPatternIterator() *PatternIterator + func (it *PatternIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *PatternIterator) HasNext(ctx *Context) bool + func (it *PatternIterator) IsMutable() bool + func (it *PatternIterator) Key(ctx *Context) Value + func (it *PatternIterator) Next(ctx *Context) bool + func (it *PatternIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *PatternIterator) Value(ctx *Context) Value + func (it PatternIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type PatternNamespace struct + Patterns map[string]Pattern + func CreatePatternNamespace(ctx *Context, init Value) (*PatternNamespace, error) + func (ns *PatternNamespace) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (ns *PatternNamespace) IsMutable() bool + func (ns *PatternNamespace) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (ns *PatternNamespace) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type PeriodicWatcher struct + func NewPeriodicWatcher(config WatcherConfiguration, period time.Duration) *PeriodicWatcher + func (w *PeriodicWatcher) Config() WatcherConfiguration + func (w *PeriodicWatcher) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (w *PeriodicWatcher) InformAboutAsync(ctx *Context, v Value) + func (w *PeriodicWatcher) IsMutable() bool + func (w *PeriodicWatcher) IsStopped() bool + func (w *PeriodicWatcher) Stop() + func (w *PeriodicWatcher) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (w *PeriodicWatcher) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (w *PeriodicWatcher) WaitNext(ctx *Context, additionalFilter Pattern, timeout time.Duration) (Value, error) + func (watcher *PeriodicWatcher) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type Permission interface + Includes func(Permission) bool + InternalPermTypename func() permkind.InternalPermissionTypename + Kind func() PermissionKind + String func() string + func GetDefaultGlobalVarPermissions() (perms []Permission) + func RemovePerms(grantedPerms, removedPerms []Permission) (remainingPerms []Permission) + type PermissionKind = permkind.PermissionKind + type PointerType struct + func (t *PointerType) GetValueAllocParams() (size int, alignment int) + func (t *PointerType) GoType() reflect.Type + func (t *PointerType) New(heap *ModuleHeap) HeapAddress + func (t *PointerType) StructFieldRetrieval(name string) fieldRetrievalInfo + func (t *PointerType) Symbolic() symbolic.CompileTimeType + func (t *PointerType) ValueSize() uintptr + func (t *PointerType) ValueType() CompileTimeType + type Port struct + Number uint16 + Scheme Scheme + func (p Port) Compare(other Value) (result int, comparable bool) + func (port Port) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (port Port) IsMutable() bool + func (port Port) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (port Port) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (port Port) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type PotentiallySharable interface + IsSharable func(originState *GlobalState) (bool, string) + IsShared func() bool + Share func(originState *GlobalState) + SmartLock func(*GlobalState) + SmartUnlock func(*GlobalState) + type PreinitArgs struct + AddDefaultPermissions bool + AdditionalGlobals map[string]Value + DefaultLimits []Limit + Filesystem afs.Filesystem + GlobalConsts *parse.GlobalConstantDeclarations + HandleCustomType CustomPermissionTypeHandler + IgnoreConstDeclErrors bool + IgnoreUnknownSections bool + ParentState *GlobalState + PreinitFilesystem afs.Filesystem + PreinitStatement *parse.PreinitStatement + Project Project + RunningState *TreeWalkState + type PreinitFile struct + Content []byte + Name string + Parsed Serializable + Path Path + Pattern Pattern + ReadParseError error + RequiredPermission FilesystemPermission + type PreinitFiles []*PreinitFile + type PrettyPrintColors struct + Constant []byte + ControlKeyword []byte + CssOtherSelector []byte + CssTypeSelector []byte + IdentifierLiteral []byte + Index []byte + InvalidNode []byte + NumberLiteral []byte + OtherKeyword []byte + PathLiteral []byte + PatternIdentifier []byte + PatternLiteral []byte + StringLiteral []byte + type PrettyPrintConfig struct + Context *Context + func (config *PrettyPrintConfig) WithContext(ctx *Context) *PrettyPrintConfig + type ProgramStopReason int + const BreakpointStop + const ExceptionBreakpointStop + const NextStepStop + const PauseStop + const StepInStop + const StepOutStop + type ProgramStoppedEvent struct + Breakpoint *BreakpointInfo + ExceptionError error + Reason ProgramStopReason + ThreadId StateId + type Project interface + BaseImage func() (Image, error) + CanProvideS3Credentials func(s3Provider string) (bool, error) + Configuration func() ProjectConfiguration + DevDatabasesDirOnOsFs func() string + GetS3CredentialsForBucket func(ctx *Context, bucketName string, provider string) (accessKey, secretKey string, s3Endpoint Host, _ error) + GetSecrets func(ctx *Context) ([]ProjectSecret, error) + Id func() ProjectID + ListSecrets func(ctx *Context) ([]ProjectSecretInfo, error) + type ProjectConfiguration interface + AreExposedWebServersAllowed func() bool + type ProjectID string + func RandomProjectID(projectName string) ProjectID + type ProjectSecret struct + LastModifDate time.Time + Name SecretName + Value *Secret + type ProjectSecretInfo struct + LastModifDate time.Time + Name SecretName + type PropertyDependencies struct + Pattern Pattern + RequiredKeys []string + type PropertyName string + func (n PropertyName) Equal(ctx *Context, otherName Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (n PropertyName) GetFrom(ctx *Context, v Value) Value + func (n PropertyName) IsMutable() bool + func (n PropertyName) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (n PropertyName) SegmentGetFrom(ctx *Context, v Value) Value + func (n PropertyName) UnderlyingString() string + func (n PropertyName) Validate() error + func (p PropertyName) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (p PropertyName) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ProtocolClient interface + Schemes func() []Scheme + type Publication struct + func (Publication) IsMutable() bool + func (p *Publication) Data() Value + func (p *Publication) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (p *Publication) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (p *Publication) PublicationDate() DateTime + func (p *Publication) Publisher() Value + func (p *Publication) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type PublicationCallbackConfiguration struct + type PublicationCallbackMicrotask func(ctx *Context, pub *Publication) + type Quantity interface + AsFloat64 func() (v float64, hasFloatRepr bool) + AsInt64 func() (v int64, hasIntegralRepr bool) + IsZeroQuantity func() bool + type QuantityRange struct + func (r QuantityRange) Contains(ctx *Context, v Serializable) bool + func (r QuantityRange) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r QuantityRange) InclusiveEnd() Serializable + func (r QuantityRange) IsEmpty(ctx *Context) bool + func (r QuantityRange) IsMutable() bool + func (r QuantityRange) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (r QuantityRange) KnownStart() Serializable + func (r QuantityRange) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r QuantityRange) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r QuantityRange) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type QuantityRangeIterator struct + func (it *QuantityRangeIterator) HasNext(*Context) bool + func (it *QuantityRangeIterator) Key(ctx *Context) Value + func (it *QuantityRangeIterator) Next(ctx *Context) bool + func (it *QuantityRangeIterator) Value(*Context) Value + func (it QuantityRangeIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it QuantityRangeIterator) IsMutable() bool + func (it QuantityRangeIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it QuantityRangeIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type RandomnessSource struct + func GetRandomnessSource(default_ *RandomnessSource, options ...Option) *RandomnessSource + func (r *RandomnessSource) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r *RandomnessSource) Int64() int64 + func (r *RandomnessSource) IsMutable() bool + func (r *RandomnessSource) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r *RandomnessSource) RandBit() bool + func (r *RandomnessSource) RandInt64Range(start, end int64) int64 + func (r *RandomnessSource) RandUint64Range(start, end uint64) uint64 + func (r *RandomnessSource) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r *RandomnessSource) Uint64() uint64 + func (s *RandomnessSource) Read(bytes []byte) (int, error) + func (s *RandomnessSource) ReadNBytesAsBase64Unpadded(n int) string + func (s *RandomnessSource) ReadNBytesAsHex(n int) string + type Rate interface + IsZeroRate func() bool + QuantityPerSecond func() Value + type RawTcpPermission struct + Domain WrappedString + Kind_ PermissionKind + func (perm RawTcpPermission) Includes(otherPerm Permission) bool + func (perm RawTcpPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm RawTcpPermission) Kind() PermissionKind + func (perm RawTcpPermission) String() string + type Readable interface + Reader func() *Reader + type ReadableByteStream struct + func NewByteStream(readSourceBytes func(s *ReadableByteStream, p []byte) (int, error), ...) *ReadableByteStream + func (*ReadableByteStream) IsMutable() bool + func (s *ReadableByteStream) ChunkDataType() Pattern + func (s *ReadableByteStream) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *ReadableByteStream) IsMainlyChunked() bool + func (s *ReadableByteStream) IsStopped() bool + func (s *ReadableByteStream) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *ReadableByteStream) Stop() + func (s *ReadableByteStream) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (s *ReadableByteStream) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *ReadableByteStream) WaitNext(ctx *Context, filter Pattern, timeout time.Duration) (Value, error) + func (s *ReadableByteStream) WaitNextChunk(ctx *Context, filter Pattern, sizeRange IntRange, timeout time.Duration) (*DataChunk, error) + type ReadableStream interface + ChunkDataType func() Pattern + IsMainlyChunked func() bool + IsStopped func() bool + Stop func() + WaitNext func(ctx *Context, filter Pattern, timeout time.Duration) (Value, error) + WaitNextChunk func(ctx *Context, filter Pattern, sizeRange IntRange, timeout time.Duration) (*DataChunk, error) + func ToReadableStream(ctx *Context, v Value, optionalFilter Pattern) ReadableStream + type ReadableStreamConfiguration struct + Filter Pattern + type Reader struct + func WrapReader(wrapped io.Reader, lock *sync.Mutex) *Reader + func (*Reader) IsMutable() bool + func (*Reader) SetProp(ctx *Context, name string, value Value) error + func (Reader) PropertyNames(ctx *Context) []string + func (r *Reader) Read(p []byte) (n int, err error) + func (r *Reader) ReadAll() (*ByteSlice, error) + func (r *Reader) ReadAllBytes() ([]byte, error) + func (r *Reader) ReadCtx(ctx *Context, p *ByteSlice) (*ByteSlice, error) + func (r *Reader) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (reader *Reader) AlreadyHasAllData() bool + func (reader *Reader) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (reader *Reader) GetBytesDataToNotModify() []byte + func (reader *Reader) GetGoMethod(name string) (*GoFunction, bool) + func (reader *Reader) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (reader *Reader) Prop(ctx *Context, name string) Value + func (reader *Reader) Reader() *Reader + type Record struct + func NewEmptyRecord() *Record + func NewRecordFromKeyValLists(keys []string, values []Serializable) *Record + func NewRecordFromMap(entryMap ValMap) *Record + func (o *Record) Migrate(ctx *Context, key Path, migration *FreeEntityMigrationArgs) (Value, error) + func (rec *Record) Contains(ctx *Context, value Serializable) bool + func (rec *Record) EntryMap() map[string]Serializable + func (rec *Record) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (rec *Record) ForEachElement(ctx *Context, fn func(index int, v Serializable) error) error + func (rec *Record) ForEachEntry(fn func(k string, v Value) error) error + func (rec *Record) HasProp(ctx *Context, name string) bool + func (rec *Record) IsEmpty(ctx *Context) bool + func (rec *Record) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (rec *Record) Keys() []string + func (rec *Record) Prop(ctx *Context, name string) Value + func (rec *Record) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (rec *Record) ValueEntryMap() map[string]Value + func (rec *Record) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (rec Record) IsMutable() bool + func (rec Record) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (rec Record) PropertyNames(ctx *Context) []string + func (rec Record) SetProp(ctx *Context, name string, value Value) error + type RecordPattern struct + func NewExactRecordPattern(entries []RecordPatternEntry) *RecordPattern + func NewInexactRecordPattern(entries []RecordPatternEntry) *RecordPattern + func NewRecordPattern(inexact bool, entries []RecordPatternEntry) *RecordPattern + func (p *RecordPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *RecordPattern) CompleteEntry(name string) (RecordPatternEntry, bool) + func (patt *RecordPattern) Entry(name string) (pattern Pattern, optional bool, yes bool) + func (patt *RecordPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *RecordPattern) ForEachEntry(fn func(entry RecordPatternEntry) error) error + func (patt *RecordPattern) GetMigrationOperations(ctx *Context, next Pattern, pseudoPath string) (migrations []MigrationOp, _ error) + func (patt *RecordPattern) HasRequiredOrOptionalEntry(name string) bool + func (patt *RecordPattern) IsMutable() bool + func (patt *RecordPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *RecordPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *RecordPattern) Random(ctx *Context, options ...Option) Value + func (patt *RecordPattern) StringPattern() (StringPattern, bool) + func (patt *RecordPattern) Test(ctx *Context, v Value) bool + func (patt *RecordPattern) ValuePropPattern(name string) (propPattern Pattern, isOptional bool, ok bool) + func (patt *RecordPattern) ValuePropertyNames() []string + func (patt RecordPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type RecordPatternEntry struct + IsOptional bool + Name string + Pattern Pattern + func (e RecordPatternEntry) Equal(ctx *Context, other RecordPatternEntry, alreadyCompared map[uintptr]uintptr, ...) bool + type RegexPattern struct + func NewRegexPattern(s string) *RegexPattern + func NewRegexPatternFromPERLCompiled(regexp *regexp.Regexp) *RegexPattern + func (p *RegexPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *RegexPattern) Call(values []Serializable) (Pattern, error) + func (patt *RegexPattern) CompiledRegex() *regexp.Regexp + func (patt *RegexPattern) EffectiveLengthRange() IntRange + func (patt *RegexPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *RegexPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *RegexPattern) IsMutable() bool + func (patt *RegexPattern) IsResolved() bool + func (patt *RegexPattern) LengthRange() IntRange + func (patt *RegexPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *RegexPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *RegexPattern) PatternNestingDepth(parentDepth int) int + func (patt *RegexPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *RegexPattern) Resolve() (StringPattern, error) + func (patt *RegexPattern) StringPattern() (StringPattern, bool) + func (patt *RegexPattern) WithLengthRange(lenRange IntRange) *RegexPattern + func (patt RegexPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt RegexPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *RegexPattern) HasRegex() bool + func (pattern *RegexPattern) Regex() string + func (pattern *RegexPattern) Test(ctx *Context, v Value) bool + func (pattern RegexPattern) Random(ctx *Context, options ...Option) Value + type RelativeTimeInstant64 int64 + func GetRelativeTimeInstant64() RelativeTimeInstant64 + func (i RelativeTimeInstant64) Time() time.Time + type RemovalMigrationOp struct + Value Pattern + func (op RemovalMigrationOp) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) symbolic.MigrationOp + type Renderable interface + IsRecursivelyRenderable func(ctx *Context, config RenderingInput) bool + Render func(ctx *Context, w io.Writer, config RenderingInput) (int, error) + type RenderingFn func(ctx *Context, w io.Writer, renderable Renderable, config RenderingInput) (int, error) + type RenderingInput struct + Mime Mimetype + OptionalUserConfig Value + type RepeatedPatternElement struct + func (p *RepeatedPatternElement) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *RepeatedPatternElement) CompiledRegex() *regexp.Regexp + func (patt *RepeatedPatternElement) EffectiveLengthRange() IntRange + func (patt *RepeatedPatternElement) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *RepeatedPatternElement) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *RepeatedPatternElement) HasRegex() bool + func (patt *RepeatedPatternElement) IsMutable() bool + func (patt *RepeatedPatternElement) IsResolved() bool + func (patt *RepeatedPatternElement) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *RepeatedPatternElement) LengthRange() IntRange + func (patt *RepeatedPatternElement) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *RepeatedPatternElement) MinMaxCounts(maxRandOcurrence int) (int, int) + func (patt *RepeatedPatternElement) Parse(ctx *Context, s string) (Serializable, error) + func (patt *RepeatedPatternElement) PatternNestingDepth(parentDepth int) int + func (patt *RepeatedPatternElement) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *RepeatedPatternElement) Random(ctx *Context, options ...Option) Value + func (patt *RepeatedPatternElement) Regex() string + func (patt *RepeatedPatternElement) Resolve() (StringPattern, error) + func (patt *RepeatedPatternElement) StringPattern() (StringPattern, bool) + func (patt *RepeatedPatternElement) Test(ctx *Context, v Value) bool + func (patt *RepeatedPatternElement) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ReplacementMigrationOp struct + Current Pattern + Next Pattern + func (op ReplacementMigrationOp) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) symbolic.MigrationOp + type ReprConfig struct + AllVisible bool + func (r *ReprConfig) IsPropertyVisible(name string, v Value, info *ValueVisibility, ctx *Context) bool + func (r *ReprConfig) IsValueVisible(v Value) bool + type ResourceGraph struct + func NewResourceGraph() *ResourceGraph + func (g *ResourceGraph) AddEdge(from, to ResourceName, rel ResourceRelationKind) + func (g *ResourceGraph) AddResource(r ResourceName, kind string) + func (g *ResourceGraph) GetEdge(from, to ResourceName) (memds.GraphEdge[ResourceRelationKind], bool) + func (g *ResourceGraph) GetNode(r ResourceName) (*ResourceNode, bool) + func (g *ResourceGraph) Roots() (roots []*ResourceNode) + type ResourceName interface + ResourceName func() string + func ResourceNameFrom(s string) ResourceName + type ResourceNode struct + func (r ResourceNode) Kind() string + type ResourceRelationKind string + type Reversability int + const Irreversible + const Reversible + const SomewhatReversible + type RingBuffer struct + func NewRingBuffer(ctx *Context, size ByteCount) *RingBuffer + func (*RingBuffer) IsMutable() bool + func (*RingBuffer) SetProp(ctx *Context, name string, value Value) error + func (r *RingBuffer) Capacity() int + func (r *RingBuffer) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r *RingBuffer) Free() ByteCount + func (r *RingBuffer) GetGoMethod(name string) (*GoFunction, bool) + func (r *RingBuffer) IsEmpty() bool + func (r *RingBuffer) IsFull() bool + func (r *RingBuffer) IsSharable(originState *GlobalState) (bool, string) + func (r *RingBuffer) IsShared() bool + func (r *RingBuffer) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r *RingBuffer) Prop(ctx *Context, propName string) Value + func (r *RingBuffer) PropertyNames(ctx *Context) []string + func (r *RingBuffer) Read(p []byte) (n int, err error) + func (r *RingBuffer) ReadByte() (b byte, err error) + func (r *RingBuffer) ReadableBytesCopy() []byte + func (r *RingBuffer) ReadableCount(ctx *Context) ByteCount + func (r *RingBuffer) Reset() + func (r *RingBuffer) Share(originState *GlobalState) + func (r *RingBuffer) SmartLock(state *GlobalState) + func (r *RingBuffer) SmartUnlock(state *GlobalState) + func (r *RingBuffer) Stream(ctx *Context, config *ReadableStreamConfiguration) ReadableStream + func (r *RingBuffer) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r *RingBuffer) WritableStream(ctx *Context, config *WritableStreamConfiguration) WritableStream + func (r *RingBuffer) Write(p []byte) (n int, err error) + func (r *RingBuffer) WriteString(s string) (n int, err error) + func (r *RingBuffer) Writer() *Writer + type RiskScore int + func ComputePermissionRiskScore(perm Permission) RiskScore + func (s RiskScore) ValueAndLevel() string + type Rune rune + func (Rune) SetProp(ctx *Context, name string, value Value) error + func (r Rune) Compare(other Value) (result int, comparable bool) + func (r Rune) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r Rune) IsMutable() bool + func (r Rune) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r Rune) Prop(ctx *Context, name string) Value + func (r Rune) PropertyNames(ctx *Context) []string + func (r Rune) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r Rune) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type RuneCount int64 + func (c RuneCount) AsFloat64() (float64, bool) + func (c RuneCount) AsInt64() (int64, bool) + func (c RuneCount) Compare(other Value) (result int, comparable bool) + func (c RuneCount) Int64() int64 + func (c RuneCount) IsSigned() bool + func (c RuneCount) IsZeroQuantity() bool + func (c RuneCount) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (count RuneCount) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (count RuneCount) IsMutable() bool + func (count RuneCount) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (count RuneCount) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type RuneRange struct + End rune + Start rune + func (r RuneRange) At(ctx *Context, i int) Value + func (r RuneRange) Contains(ctx *Context, v Serializable) bool + func (r RuneRange) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r RuneRange) Includes(ctx *Context, i Rune) bool + func (r RuneRange) IsEmpty(ctx *Context) bool + func (r RuneRange) IsMutable() bool + func (r RuneRange) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (r RuneRange) Len() int + func (r RuneRange) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r RuneRange) Random(ctx *Context) interface{} + func (r RuneRange) RandomRune() rune + func (r RuneRange) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (r RuneRange) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type RuneRangeIterator struct + func (it *RuneRangeIterator) HasNext(*Context) bool + func (it *RuneRangeIterator) Key(ctx *Context) Value + func (it *RuneRangeIterator) Next(ctx *Context) bool + func (it *RuneRangeIterator) Value(*Context) Value + func (it RuneRangeIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it RuneRangeIterator) IsMutable() bool + func (it RuneRangeIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it RuneRangeIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type RuneRangeStringPattern struct + func NewRuneRangeStringPattern(lower, upper rune, node parse.Node) *RuneRangeStringPattern + func (p *RuneRangeStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *RuneRangeStringPattern) CompiledRegex() *regexp.Regexp + func (patt *RuneRangeStringPattern) EffectiveLengthRange() IntRange + func (patt *RuneRangeStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *RuneRangeStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *RuneRangeStringPattern) HasRegex() bool + func (patt *RuneRangeStringPattern) IsMutable() bool + func (patt *RuneRangeStringPattern) IsResolved() bool + func (patt *RuneRangeStringPattern) LengthRange() IntRange + func (patt *RuneRangeStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *RuneRangeStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *RuneRangeStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *RuneRangeStringPattern) Random(ctx *Context, options ...Option) Value + func (patt *RuneRangeStringPattern) Regex() string + func (patt *RuneRangeStringPattern) Resolve() (StringPattern, error) + func (patt *RuneRangeStringPattern) StringPattern() (StringPattern, bool) + func (patt *RuneRangeStringPattern) Test(ctx *Context, v Value) bool + func (patt RuneRangeStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt RuneRangeStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type RuneSlice struct + func NewRuneSlice(runes []rune) *RuneSlice + func (*RuneSlice) SetProp(ctx *Context, name string, value Value) error + func (r *RuneSlice) IsFrozen() bool + func (r *RuneSlice) TakeInMemorySnapshot(ctx *Context) (*Snapshot, error) + func (r *RuneSlice) Unfreeze(ctx *Context) error + func (s *RuneSlice) Insert(ctx *Context, v Value, i Int) + func (s *RuneSlice) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (s *RuneSlice) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (s *RuneSlice) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (s *RuneSlice) Prop(ctx *Context, name string) Value + func (s *RuneSlice) PropertyNames(ctx *Context) []string + func (s *RuneSlice) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (s *RuneSlice) RemoveMutationCallbackMicrotasks(ctx *Context) + func (s *RuneSlice) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (s *RuneSlice) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *RuneSlice) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (slice *RuneSlice) At(ctx *Context, i int) Value + func (slice *RuneSlice) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (slice *RuneSlice) ElementsDoNotModify() []rune + func (slice *RuneSlice) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (slice *RuneSlice) IsMutable() bool + func (slice *RuneSlice) Len() int + func (slice *RuneSlice) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (slice *RuneSlice) SetSlice(ctx *Context, start, end int, seq Sequence) + func (slice *RuneSlice) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ScaledTokenCount int64 + func (c ScaledTokenCount) RealCount() int64 + type Scheme string + func (s Scheme) IsDatabaseScheme() bool + func (s Scheme) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s Scheme) UnderlyingString() string + func (s Scheme) Validate() error + func (scheme Scheme) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (scheme Scheme) IsMutable() bool + func (scheme Scheme) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (scheme Scheme) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type SchemeHolder interface + Scheme func() Scheme + type SecondaryDebugEvent interface + SecondaryDebugEventType func() SecondaryDebugEventType + type SecondaryDebugEventType int + func (t SecondaryDebugEventType) String() string + type Secret struct + func (*Secret) IsMutable() bool + func (m *Secret) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (m *Secret) WriteRepresentation(ctx *Context, w io.Writer, config *ReprConfig, depth int) error + func (s *Secret) AssertIsPattern(secret *SecretPattern) + func (s *Secret) DecodedPEM() (*pem.Block, error) + func (s *Secret) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *Secret) Format(f fmt.State, verb rune) + func (s *Secret) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *Secret) String() string + func (s *Secret) StringValue() StringLike + func (s *Secret) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type SecretName string + func SecretNameFrom(name string) (SecretName, error) + type SecretPattern struct + func NewSecretPattern(stringPattern StringPattern, pem bool) *SecretPattern + func (*SecretPattern) IsMutable() bool + func (p *SecretPattern) Test(ctx *Context, v Value) bool + func (p *SecretPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *SecretPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt *SecretPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern *SecretPattern) NewSecret(ctx *Context, s string) (*Secret, error) + func (pattern *SecretPattern) Random(ctx *Context, options ...Option) Value + func (pattern *SecretPattern) StringPattern() (StringPattern, bool) + func (s *SecretPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *SecretPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type Sequence interface + type SequenceStringPattern struct + func NewSequenceStringPattern(node *parse.ComplexStringPatternPiece, nodeChunk *parse.Chunk, ...) (*SequenceStringPattern, error) + func (p *SequenceStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *SequenceStringPattern) Call(values []Serializable) (Pattern, error) + func (patt *SequenceStringPattern) CompiledRegex() *regexp.Regexp + func (patt *SequenceStringPattern) EffectiveLengthRange() IntRange + func (patt *SequenceStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *SequenceStringPattern) FindGroupMatches(ctx *Context, v Serializable, config GroupMatchesFindConfig) (groups []*Object, err error) + func (patt *SequenceStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *SequenceStringPattern) HasRegex() bool + func (patt *SequenceStringPattern) IsMutable() bool + func (patt *SequenceStringPattern) IsResolved() bool + func (patt *SequenceStringPattern) LengthRange() IntRange + func (patt *SequenceStringPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *SequenceStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *SequenceStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *SequenceStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *SequenceStringPattern) Regex() string + func (patt *SequenceStringPattern) Resolve() (StringPattern, error) + func (patt *SequenceStringPattern) StringPattern() (StringPattern, bool) + func (patt *SequenceStringPattern) Test(ctx *Context, v Value) bool + func (patt SequenceStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt SequenceStringPattern) Random(ctx *Context, options ...Option) Value + func (patt SequenceStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Serializable interface + WriteJSONRepresentation func(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func ConvertJSONValToInoxVal(v any, immutable bool) Serializable + func ConvertYamlNodeToInoxVal(ctx *Context, n yaml.Node, immutable bool) Serializable + func ConvertYamlParsedFileToInoxVal(ctx *Context, f *yaml.File, immutable bool) Serializable + func EvalSimpleValueLiteral(n parse.SimpleValueLiteral, global *GlobalState) (Serializable, error) + func FindMatchesForRegex(ctx *Context, regexp *regexp.Regexp, s string, config MatchesFindConfig) (matches []Serializable, err error) + func FindMatchesForStringPattern(ctx *Context, patt StringPattern, val Serializable, config MatchesFindConfig) (matches []Serializable, err error) + func GetOrLoadValueAtURL(ctx *Context, u URL, state *GlobalState) (Serializable, error) + func ParseJSONRepresentation(ctx *Context, s string, pattern Pattern) (Serializable, error) + func ParseNextJSONRepresentation(ctx *Context, it *jsoniter.Iterator, pattern Pattern, try bool) (res Serializable, finalErr error) + func RepresentationBasedClone(ctx *Context, val Serializable) (Serializable, error) + func ToSerializableAsserted(v any) Serializable + func ToSerializableSlice(values []Value) []Serializable + type SerializableIterable interface + type SmartLock struct + func (lock *SmartLock) AssertValueShared() + func (lock *SmartLock) IsHeld() bool + func (lock *SmartLock) IsValueShared() bool + func (lock *SmartLock) Lock(state *GlobalState, embedder PotentiallySharable, ignoreLockedValues ...bool) + func (lock *SmartLock) Share(originState *GlobalState, fn func()) + func (lock *SmartLock) Unlock(state *GlobalState, embedder PotentiallySharable, ignoreLockedValues ...bool) + type Snapshot struct + func TakeSnapshot(ctx *Context, v Serializable, mustBeSerialized bool) (*Snapshot, error) + func (s *Snapshot) Date() DateTime + func (s *Snapshot) InstantiateValue(ctx *Context) (Serializable, error) + func (s *Snapshot) WithChangeApplied(ctx *Context, c Change) (*Snapshot, error) + type SnapshotWriteToFilesystem struct + Overwrite bool + type SnapshotableFilesystem interface + TakeFilesystemSnapshot func(config FilesystemSnapshotConfig) (FilesystemSnapshot, error) + type SortableByNestedValue interface + SortByNestedValue func(ctx *Context, path ValuePath, order Order) error + type SpecificMutationAcceptor interface + ApplySpecificMutation func(ctx *Context, m Mutation) error + type SpecificMutationKind int8 + const SG_AddEdge + const SG_AddEvent + const SG_AddNode + type SpecificMutationMetadata struct + Depth WatchingDepth + Kind SpecificMutationKind + Path Path + Version SpecificMutationVersion + type SpecificMutationVersion int8 + type StackFrameInfo struct + Chunk *parse.ParsedChunkSource + Id int32 + Name string + Node parse.Node + StartColumn int32 + StartLine int32 + StatementStartColumn int32 + StatementStartLine int32 + type StatDirEntry struct + func NewStatDirEntry(info fs.FileInfo) *StatDirEntry + func (d *StatDirEntry) Info() (fs.FileInfo, error) + func (d *StatDirEntry) IsDir() bool + func (d *StatDirEntry) Name() string + func (d *StatDirEntry) Type() fs.FileMode + type StateId int64 + type StatelessParser interface + Parse func(ctx *Context, s string) (Serializable, error) + Validate func(ctx *Context, s string) bool + func GetParser(mime Mimetype) (StatelessParser, bool) + type StaticCheckData struct + func StaticCheck(input StaticCheckInput) (*StaticCheckData, error) + func (*StaticCheckData) IsMutable() bool + func (*StaticCheckData) PropertyNames(ctx *Context) []string + func (*StaticCheckData) SetProp(ctx *Context, name string, value Value) error + func (d *StaticCheckData) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (d *StaticCheckData) ErrorTuple() *Tuple + func (d *StaticCheckData) Errors() []*StaticCheckError + func (d *StaticCheckData) GetGoMethod(name string) (*GoFunction, bool) + func (d *StaticCheckData) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d *StaticCheckData) Prop(ctx *Context, name string) Value + func (d *StaticCheckData) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (d *StaticCheckData) WarningTuple() *Tuple + func (d *StaticCheckData) Warnings() []*StaticCheckWarning + func (data *StaticCheckData) GetFnData(fnExpr *parse.FunctionExpression) *FunctionStaticData + func (data *StaticCheckData) GetMappingData(expr *parse.MappingExpression) *MappingStaticData + type StaticCheckError struct + LocatedMessage string + Location parse.SourcePositionStack + Message string + func NewStaticCheckError(s string, location parse.SourcePositionStack) *StaticCheckError + func (err StaticCheckError) Err() Error + func (err StaticCheckError) Error() string + func (err StaticCheckError) LocationStack() parse.SourcePositionStack + func (err StaticCheckError) MessageWithoutLocation() string + type StaticCheckInput struct + AdditionalGlobalConsts []string + Chunk *parse.ParsedChunkSource + Globals GlobalVariables + Module *Module + Node parse.Node + ParentChecker *checker + PatternNamespaces map[string]*PatternNamespace + Patterns map[string]Pattern + ShellLocalVars map[string]Value + State *GlobalState + type StaticCheckWarning struct + LocatedMessage string + Location parse.SourcePositionStack + Message string + func NewStaticCheckWarning(s string, location parse.SourcePositionStack) *StaticCheckWarning + func (err StaticCheckWarning) LocationStack() parse.SourcePositionStack + func (err StaticCheckWarning) MessageWithoutLocation() string + type StaticallyCheckDbResolutionDataFn func(node parse.Node, optProject Project) (errorMsg string) + func GetStaticallyCheckDbResolutionDataFn(scheme Scheme) (StaticallyCheckDbResolutionDataFn, bool) + type StaticallyCheckHostDefinitionFn func(optionalProject Project, node parse.Node) (errorMsg string) + type StrListIterator struct + func (it *StrListIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *StrListIterator) IsMutable() bool + func (it *StrListIterator) Key(ctx *Context) Value + func (it *StrListIterator) Next(ctx *Context) bool + func (it *StrListIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *StrListIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *StrListIterator) Value(*Context) Value + func (it StrListIterator) HasNext(*Context) bool + type StreamSink interface + WritableStream func(ctx *Context, optionalConfig *WritableStreamConfiguration) WritableStream + type StreamSource interface + Stream func(ctx *Context, optionalConfig *ReadableStreamConfiguration) ReadableStream + type String string + func NewStringFromSlices(slices []Value, node *parse.StringTemplateLiteral, ctx *Context) (String, error) + func ToJSON(ctx *Context, v Serializable, pattern *OptionalParam[Pattern]) String + func ToJSONWithConfig(ctx *Context, v Serializable, config JSONSerializationConfig) String + func ToPrettyJSON(ctx *Context, v Serializable, pattern *OptionalParam[Pattern]) String + func (String) SetProp(ctx *Context, name string, value Value) error + func (s String) At(ctx *Context, i int) Value + func (s String) ByteLen() int + func (s String) ByteLike() []byte + func (s String) Compare(other Value) (result int, comparable bool) + func (s String) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s String) GetOrBuildString() string + func (s String) HasPrefix(ctx *Context, prefix StringLike) Bool + func (s String) HasSuffix(ctx *Context, prefix StringLike) Bool + func (s String) IsMutable() bool + func (s String) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (s String) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (s String) Len() int + func (s String) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s String) Prop(ctx *Context, name string) Value + func (s String) PropertyNames(ctx *Context) []string + func (s String) Reader() *Reader + func (s String) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (s String) Replace(ctx *Context, old, new StringLike) StringLike + func (s String) RuneCount() int + func (s String) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s String) TrimSpace(ctx *Context) StringLike + func (s String) UnderlyingString() string + func (s String) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type StringConcatenation struct + func NewStringConcatenation(elements ...StringLike) *StringConcatenation + func (*StringConcatenation) SetProp(ctx *Context, name string, value Value) error + func (c *StringConcatenation) At(ctx *Context, i int) Value + func (c *StringConcatenation) ByteLen() int + func (c *StringConcatenation) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c *StringConcatenation) GetOrBuildString() string + func (c *StringConcatenation) HasPrefix(ctx *Context, prefix StringLike) Bool + func (c *StringConcatenation) HasSuffix(ctx *Context, prefix StringLike) Bool + func (c *StringConcatenation) IsMutable() bool + func (c *StringConcatenation) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (c *StringConcatenation) Len() int + func (c *StringConcatenation) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (c *StringConcatenation) Prop(ctx *Context, name string) Value + func (c *StringConcatenation) PropertyNames(ctx *Context) []string + func (c *StringConcatenation) Reader() *Reader + func (c *StringConcatenation) Replace(ctx *Context, old, new StringLike) StringLike + func (c *StringConcatenation) RuneCount() int + func (c *StringConcatenation) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (c *StringConcatenation) TrimSpace(ctx *Context) StringLike + func (c *StringConcatenation) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type StringFormat interface + type StringLike interface + ByteLen func() int + GetOrBuildString func() string + HasPrefix func(ctx *Context, prefix StringLike) Bool + HasSuffix func(ctx *Context, prefix StringLike) Bool + Replace func(ctx *Context, old, new StringLike) StringLike + RuneCount func() int + TrimSpace func(ctx *Context) StringLike + func ConcatStringLikes(stringLikes ...StringLike) (StringLike, error) + type StringList struct + func (l *StringList) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list *StringList) At(ctx *Context, i int) Value + func (list *StringList) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (list *StringList) ConstraintId() ConstraintId + func (list *StringList) ContainsSimple(ctx *Context, v Serializable) bool + func (list *StringList) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list *StringList) IsMutable() bool + func (list *StringList) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (list *StringList) Len() int + func (list *StringList) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list *StringList) SetSlice(ctx *Context, start, end int, seq Sequence) + func (list *StringList) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type StringPattern interface + CompiledRegex func() *regexp.Regexp + EffectiveLengthRange func() IntRange + FindMatches func(*Context, Serializable, MatchesFindConfig) (groups []Serializable, err error) + HasRegex func() bool + IsResolved func() bool + LengthRange func() IntRange + Parse func(*Context, string) (Serializable, error) + PatternNestingDepth func(parentDepth int) int + Regex func() string + Resolve func() (StringPattern, error) + func NewPEMRegexPattern(typeRegex string) StringPattern + type StrongTransactionIsolator struct + func (isolator *StrongTransactionIsolator) WaitForOtherTxsToTerminate(ctx *Context, requireRunningTx bool) (currentTx *Transaction, _ error) + type Struct byte + func (Struct) IsMutable() bool + func (Struct) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (Struct) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (ptr *Struct) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + type StructType struct + func (t *StructType) FieldCount() int + func (t *StructType) FieldRetrievalInfo(name string) fieldRetrievalInfo + func (t *StructType) GoType() reflect.Type + func (t *StructType) Symbolic() symbolic.CompileTimeType + type Subscriber interface + ReceivePublication func(ctx *Context, pub *Publication) + type Subscription struct + func (*Subscription) IsMutable() bool + func (s *Subscription) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *Subscription) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *Subscription) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type Subscriptions struct + func (s *Subscriptions) ReceivePublications(ctx *Context, pub *Publication) + type SymbolicData struct + func (*SymbolicData) IsMutable() bool + func (*SymbolicData) PropertyNames(ctx *Context) []string + func (*SymbolicData) SetProp(ctx *Context, name string, value Value) error + func (d *SymbolicData) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (d *SymbolicData) ErrorTuple() *Tuple + func (d *SymbolicData) GetGoMethod(name string) (*GoFunction, bool) + func (d *SymbolicData) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (d *SymbolicData) Prop(ctx *Context, name string) Value + func (d *SymbolicData) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type SynchronousMessageHandler struct + func NewSynchronousMessageHandler(ctx *Context, fn *InoxFunction, pattern Pattern) *SynchronousMessageHandler + func (*SynchronousMessageHandler) IsMutable() bool + func (*SynchronousMessageHandler) PropertyNames(ctx *Context) []string + func (*SynchronousMessageHandler) SetProp(ctx *Context, name string, value Value) error + func (h *SynchronousMessageHandler) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (h *SynchronousMessageHandler) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (h *SynchronousMessageHandler) Pattern() Pattern + func (h *SynchronousMessageHandler) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (h *SynchronousMessageHandler) Prop(ctx *Context, name string) Value + func (h *SynchronousMessageHandler) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (h *SynchronousMessageHandler) RemoveMutationCallbackMicrotasks(ctx *Context) + func (h *SynchronousMessageHandler) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (h *SynchronousMessageHandler) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (h *SynchronousMessageHandler) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type SynchronousMessageHandlers struct + func NewSynchronousMessageHandlers(handlers ...*SynchronousMessageHandler) *SynchronousMessageHandlers + func (handlers *SynchronousMessageHandlers) CallHandlers(ctx *Context, msg Message, self Value) error + type SystemGraph struct + func NewSystemGraph() *SystemGraph + func (*SystemGraph) IsMutable() bool + func (*SystemGraph) PropertyNames(ctx *Context) []string + func (*SystemGraph) SetProp(ctx *Context, name string, value Value) error + func (*SystemGraph) Watcher(ctx *Context, config WatcherConfiguration) Watcher + func (g *SystemGraph) AddChildNode(ctx *Context, parent SystemGraphNodeValue, value SystemGraphNodeValue, ...) + func (g *SystemGraph) AddEvent(ctx *Context, text string, v SystemGraphNodeValue) + func (g *SystemGraph) AddNode(ctx *Context, value SystemGraphNodeValue, name string) + func (g *SystemGraph) AddWatchedNode(ctx *Context, watchingVal SystemGraphNodeValue, ...) + func (g *SystemGraph) ApplySpecificMutation(ctx *Context, m Mutation) error + func (g *SystemGraph) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (g *SystemGraph) IsFrozen() bool + func (g *SystemGraph) IsSharable(originState *GlobalState) (bool, string) + func (g *SystemGraph) IsShared() bool + func (g *SystemGraph) OnMutation(ctx *Context, microtask MutationCallbackMicrotask, ...) (CallbackHandle, error) + func (g *SystemGraph) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (g *SystemGraph) Prop(ctx *Context, name string) Value + func (g *SystemGraph) Ptr() SystemGraphPointer + func (g *SystemGraph) RemoveMutationCallback(ctx *Context, handle CallbackHandle) + func (g *SystemGraph) RemoveMutationCallbackMicrotasks(ctx *Context) + func (g *SystemGraph) Share(originState *GlobalState) + func (g *SystemGraph) SmartLock(state *GlobalState) + func (g *SystemGraph) SmartUnlock(state *GlobalState) + func (g *SystemGraph) TakeInMemorySnapshot(ctx *Context) (*Snapshot, error) + func (g *SystemGraph) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (g *SystemGraph) Unfreeze(ctx *Context) error + func (g *SystemGraph) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type SystemGraphAccessPermission struct + Kind_ PermissionKind + func (perm SystemGraphAccessPermission) Includes(otherPerm Permission) bool + func (perm SystemGraphAccessPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm SystemGraphAccessPermission) Kind() PermissionKind + func (perm SystemGraphAccessPermission) String() string + type SystemGraphEdge struct + func (SystemGraphEdge) IsMutable() bool + func (SystemGraphEdge) PropertyNames(ctx *Context) []string + func (SystemGraphEdge) SetProp(ctx *Context, name string, value Value) error + func (e SystemGraphEdge) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (e SystemGraphEdge) IsSharable(originState *GlobalState) (bool, string) + func (e SystemGraphEdge) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (e SystemGraphEdge) Prop(ctx *Context, name string) Value + func (e SystemGraphEdge) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (e SystemGraphEdge) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type SystemGraphEdgeKind uint8 + const EdgeChild + const EdgeWatched + func (k SystemGraphEdgeKind) DefaultText() string + type SystemGraphEvent struct + func (SystemGraphEvent) IsMutable() bool + func (SystemGraphEvent) PropertyNames(ctx *Context) []string + func (SystemGraphEvent) SetProp(ctx *Context, name string, value Value) error + func (e SystemGraphEvent) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (e SystemGraphEvent) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (e SystemGraphEvent) Prop(ctx *Context, name string) Value + func (e SystemGraphEvent) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (e SystemGraphEvent) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type SystemGraphNode struct + func (*SystemGraphNode) IsMutable() bool + func (*SystemGraphNode) PropertyNames(ctx *Context) []string + func (*SystemGraphNode) SetProp(ctx *Context, name string, value Value) error + func (g *SystemGraphNode) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (n *SystemGraphNode) IsSharable(originState *GlobalState) (bool, string) + func (n *SystemGraphNode) IsShared() bool + func (n *SystemGraphNode) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (n *SystemGraphNode) Prop(ctx *Context, name string) Value + func (n *SystemGraphNode) Share(originState *GlobalState) + func (n *SystemGraphNode) SmartLock(state *GlobalState) + func (n *SystemGraphNode) SmartUnlock() + func (n *SystemGraphNode) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type SystemGraphNodeValue interface + AddSystemGraphEvent func(ctx *Context, text string) + ProposeSystemGraph func(ctx *Context, g *SystemGraph, propoposedName string, ...) + SystemGraph func() *SystemGraph + type SystemGraphNodes struct + func (*SystemGraphNodes) IsMutable() bool + func (n *SystemGraphNodes) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (n *SystemGraphNodes) IsSharable(originState *GlobalState) (bool, string) + func (n *SystemGraphNodes) IsShared() bool + func (n *SystemGraphNodes) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (n *SystemGraphNodes) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (n *SystemGraphNodes) Share(originState *GlobalState) + func (n *SystemGraphNodes) SmartLock(state *GlobalState) + func (n *SystemGraphNodes) SmartUnlock(state *GlobalState) + func (n *SystemGraphNodes) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type SystemGraphPointer struct + func (p *SystemGraphPointer) AddEvent(ctx *Context, text string, v SystemGraphNodeValue) + func (p *SystemGraphPointer) Graph() *SystemGraph + func (p *SystemGraphPointer) Set(ptr SystemGraphPointer) bool + type TestCase struct + func NewTestCase(input TestCaseCreationInput) (*TestCase, error) + func (*TestCase) PropertyNames(ctx *Context) []string + func (*TestCase) SetProp(ctx *Context, name string, value Value) error + func (c *TestCase) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (c *TestCase) FilesystemSnapshot() (FilesystemSnapshot, bool) + func (c *TestCase) IsMutable() bool + func (c *TestCase) ItemName() (string, bool) + func (c *TestCase) ParentChunk() *parse.ParsedChunkSource + func (c *TestCase) ParentModule() *Module + func (c *TestCase) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (c *TestCase) Run(ctx *Context, options ...Option) (*LThread, error) + func (c *TestCase) Statement() parse.Node + func (c *TestCase) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *TestCase) GetGoMethod(name string) (*GoFunction, bool) + func (s *TestCase) Prop(ctx *Context, name string) Value + type TestCaseCreationInput struct + FormattedLocation string + Meta Value + ModChunk *parse.Chunk + Node *parse.TestCaseExpression + ParentChunk *parse.ParsedChunkSource + ParentState *GlobalState + PositionStack parse.SourcePositionStack + type TestCaseResult struct + DarkModePrettyMessage string + LightModePrettyMessage string + Message string + Success bool + func NewTestCaseResult(ctx *Context, executionResult Value, executionError error, testCase *TestCase) (*TestCaseResult, error) + func (c *TestCaseResult) IsMutable() bool + func (r *TestCaseResult) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (r *TestCaseResult) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (r *TestCaseResult) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TestFilter struct + AbsolutePath string + NameRegex string + NodeSpan parse.NodeSpan + func (f TestFilter) IsTestEnabled(absoluteFilePath string, item TestItem, parentState *GlobalState) (enabled bool, reason string) + func (f TestFilter) String() string + type TestFilters struct + NegativeTestFilters []TestFilter + PositiveTestFilters []TestFilter + func (filters TestFilters) IsTestEnabled(item TestItem, parentState *GlobalState) (enabled bool, reason string) + type TestItem interface + FilesystemSnapshot func() (FilesystemSnapshot, bool) + ItemName func() (string, bool) + ParentChunk func() *parse.ParsedChunkSource + ParentModule func() *Module + Statement func() parse.Node + type TestSuite struct + func NewTestSuite(input TestSuiteCreationInput) (*TestSuite, error) + func (*TestSuite) PropertyNames(ctx *Context) []string + func (*TestSuite) SetProp(ctx *Context, name string, value Value) error + func (s *TestSuite) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *TestSuite) FilesystemSnapshot() (FilesystemSnapshot, bool) + func (s *TestSuite) GetGoMethod(name string) (*GoFunction, bool) + func (s *TestSuite) IsMutable() bool + func (s *TestSuite) ItemName() (string, bool) + func (s *TestSuite) ParentChunk() *parse.ParsedChunkSource + func (s *TestSuite) ParentModule() *Module + func (s *TestSuite) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *TestSuite) Prop(ctx *Context, name string) Value + func (s *TestSuite) Run(ctx *Context, options ...Option) (*LThread, error) + func (s *TestSuite) Statement() parse.Node + func (s *TestSuite) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TestSuiteCreationInput struct + EmbeddedModChunk *parse.Chunk + Meta Value + Node *parse.TestSuiteExpression + ParentChunk *parse.ParsedChunkSource + ParentState *GlobalState + type TestSuiteResult struct + DarkModePrettyMessage string + LightModePrettyMessage string + Message string + Success bool + func NewTestSuiteResult(ctx *Context, testCaseResults []*TestCaseResult, ...) (*TestSuiteResult, error) + func (r *TestSuiteResult) MostAdaptedMessage(colorized bool, darkBackground bool) string + type TestValueStorage struct + BaseURL_ URL + Data map[Path]string + func (s *TestValueStorage) BaseURL() URL + func (s *TestValueStorage) GetSerialized(ctx *Context, key Path) (string, bool) + func (s *TestValueStorage) Has(ctx *Context, key Path) bool + func (s *TestValueStorage) InsertSerialized(ctx *Context, key Path, serialized string) + func (s *TestValueStorage) SetSerialized(ctx *Context, key Path, serialized string) + type TestedProgram struct + func (*TestedProgram) IsMutable() bool + func (*TestedProgram) PropertyNames(ctx *Context) []string + func (*TestedProgram) SetProp(ctx *Context, name string, value Value) error + func (p *TestedProgram) Cancel(*Context) + func (p *TestedProgram) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (p *TestedProgram) GetGoMethod(name string) (*GoFunction, bool) + func (p *TestedProgram) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (p *TestedProgram) Prop(ctx *Context, name string) Value + func (p *TestedProgram) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TestingState struct + CaseResults []*TestCaseResult + Filters TestFilters + IsImportTestingEnabled bool + IsTestingEnabled bool + Item TestItem + ItemFullName string + ResultsLock sync.Mutex + SuiteResults []*TestSuiteResult + TestedProgram *Module + type ThreadInfo struct + Id StateId + Name string + type ToStringConversionCapableStringPattern interface + StringFrom func(ctx *Context, v Value) (string, error) + type Token struct + func (Token) PropertyNames(ctx *Context) []string + func (Token) SetProp(ctx *Context, name string, value Value) error + func (t Token) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (t Token) IsMutable() bool + func (t Token) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (t Token) Prop(ctx *Context, name string) Value + func (t Token) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TokenDepletionFn func(lastDecrementTime time.Time, beingDepletedStateCount int32) int64 + type Transaction struct + func StartNewReadonlyTransaction(ctx *Context, options ...Option) *Transaction + func StartNewTransaction(ctx *Context, options ...Option) *Transaction + func (*Transaction) SetProp(ctx *Context, name string, value Value) error + func (tx *Transaction) AddEffect(ctx *Context, effect Effect) error + func (tx *Transaction) Commit(ctx *Context) error + func (tx *Transaction) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (tx *Transaction) Finished() DoneChan + func (tx *Transaction) GetGoMethod(name string) (*GoFunction, bool) + func (tx *Transaction) ID() ULID + func (tx *Transaction) IsFinished() bool + func (tx *Transaction) IsFinishing() bool + func (tx *Transaction) IsMutable() bool + func (tx *Transaction) IsReadonly() bool + func (tx *Transaction) OnEnd(k any, fn TransactionEndCallbackFn) error + func (tx *Transaction) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (tx *Transaction) Prop(ctx *Context, name string) Value + func (tx *Transaction) PropertyNames(ctx *Context) []string + func (tx *Transaction) Rollback(ctx *Context) error + func (tx *Transaction) Start(ctx *Context) error + func (tx *Transaction) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TransactionEndCallbackFn func(tx *Transaction, success bool) + type TransientID [2]uintptr + func TransientIdOf(v Value) (result TransientID, hastFastId bool) + type TraversalConfiguration struct + MaxDepth int + type TreeWalkCall struct + type TreeWalkState struct + Global *GlobalState + LocalScopeStack []map[string]Value + func NewTreeWalkState(ctx *Context, constants ...map[string]Value) *TreeWalkState + func NewTreeWalkStateWithGlobal(global *GlobalState) *TreeWalkState + func (state *TreeWalkState) AttachDebugger(debugger *Debugger) + func (state *TreeWalkState) CurrentLocalScope() map[string]Value + func (state *TreeWalkState) DetachDebugger() + func (state *TreeWalkState) Get(name string) (Value, bool) + func (state *TreeWalkState) GetGlobalState() *GlobalState + func (state *TreeWalkState) HasGlobal(name string) bool + func (state *TreeWalkState) PopScope() + func (state *TreeWalkState) PushScope() + func (state *TreeWalkState) Reset(global *GlobalState) + func (state *TreeWalkState) SetGlobal(name string, value Value, constness GlobalConstness) (ok bool) + type Treedata struct + HiearchyEntries []TreedataHiearchyEntry + Root Serializable + func GetDirTreeData(fls afs.Filesystem, walkedDirPath Path) *Treedata + func (d *Treedata) WalkEntriesDF(...) error + func (d *Treedata) Walker(*Context) (Walker, error) + func (u *Treedata) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (u *Treedata) IsMutable() bool + func (u *Treedata) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (u *Treedata) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (u *Treedata) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type TreedataHiearchyEntry struct + Children []TreedataHiearchyEntry + Value Serializable + func (e TreedataHiearchyEntry) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (e TreedataHiearchyEntry) IsMutable() bool + func (e TreedataHiearchyEntry) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (e TreedataHiearchyEntry) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (u *TreedataHiearchyEntry) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type TreedataWalker struct + func (it *TreedataWalker) HasNext(ctx *Context) bool + func (it *TreedataWalker) Key(*Context) Value + func (it *TreedataWalker) Next(ctx *Context) bool + func (it *TreedataWalker) NodeMeta(*Context) WalkableNodeMeta + func (it *TreedataWalker) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *TreedataWalker) Prune(ctx *Context) + func (it *TreedataWalker) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *TreedataWalker) Value(*Context) Value + func (w *TreedataWalker) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (w *TreedataWalker) IsMutable() bool + type Tuple struct + func ConcatTuples(tuples ...*Tuple) *Tuple + func NewTuple(elements []Serializable) *Tuple + func NewTupleVariadic(elements ...Serializable) *Tuple + func (t *Tuple) Contains(ctx *Context, value Serializable) bool + func (t *Tuple) IsEmpty(ctx *Context) bool + func (t Tuple) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (tuple *Tuple) At(ctx *Context, i int) Value + func (tuple *Tuple) Concat(other *Tuple) *Tuple + func (tuple *Tuple) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (tuple *Tuple) GetOrBuildElements(ctx *Context) []Serializable + func (tuple *Tuple) IsMutable() bool + func (tuple *Tuple) Len() int + func (tuple *Tuple) Migrate(ctx *Context, key Path, migration *FreeEntityMigrationArgs) (Value, error) + func (tuple *Tuple) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (tuple Tuple) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (tuple Tuple) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type TupleIterator struct + func (it *TupleIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *TupleIterator) IsMutable() bool + func (it *TupleIterator) Key(ctx *Context) Value + func (it *TupleIterator) Next(ctx *Context) bool + func (it *TupleIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *TupleIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *TupleIterator) Value(*Context) Value + func (it TupleIterator) HasNext(*Context) bool + type TuplePattern struct + func NewTuplePattern(elementPatterns []Pattern) *TuplePattern + func NewTuplePatternOf(generalElementPattern Pattern) *TuplePattern + func (p *TuplePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *TuplePattern) DefaultValue(ctx *Context) (Value, error) + func (patt *TuplePattern) ElementPatternAt(i int) (Pattern, bool) + func (patt *TuplePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *TuplePattern) ExactElementCount() (int, bool) + func (patt *TuplePattern) IsMutable() bool + func (patt *TuplePattern) StringPattern() (StringPattern, bool) + func (patt *TuplePattern) Test(ctx *Context, v Value) bool + func (patt TuplePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt TuplePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt TuplePattern) Random(ctx *Context, options ...Option) Value + func (patt TuplePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type Type struct + func (t Type) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (t Type) IsMutable() bool + func (t Type) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (t Type) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type TypeExtension struct + func (e TypeExtension) Id() string + type TypePattern struct + CallImpl func(pattern *TypePattern, values []Serializable) (Pattern, error) + Name string + RandomImpl func(options ...Option) Value + SymbolicCallImpl func(ctx *symbolic.Context, values []symbolic.Value) (symbolic.Pattern, error) + SymbolicValue symbolic.Value + Type reflect.Type + func (p *TypePattern) ToSymbolicVal() symbolic.Pattern + func (p *TypePattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *TypePattern) Call(values []Serializable) (Pattern, error) + func (patt *TypePattern) StringPattern() (StringPattern, bool) + func (patt TypePattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (pattern *TypePattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (pattern *TypePattern) IsMutable() bool + func (pattern *TypePattern) Test(ctx *Context, v Value) bool + func (pattern TypePattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (pattern TypePattern) Random(ctx *Context, options ...Option) Value + func (pattern TypePattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ULID ulid.ULID + var MAX_ULID ULID + var MIN_ULID ULID + func NewULID() ULID + func ParseULID(s string) (ULID, error) + func (ULID) IsMutable() bool + func (id ULID) After(other ULID) bool + func (id ULID) Before(other ULID) bool + func (id ULID) Compare(other Value) (result int, comparable bool) + func (id ULID) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (id ULID) GoTime() time.Time + func (id ULID) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (id ULID) String() string + func (id ULID) Time() DateTime + func (id ULID) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (id ULID) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type URL string + func UrlOf(ctx *Context, v Value) (URL, error) + func (URL) SetProp(ctx *Context, name string, value Value) error + func (u URL) AppendAbsolutePath(absPath Path) URL + func (u URL) AppendRelativePath(relPath Path) URL + func (u URL) DirURL() (URL, bool) + func (u URL) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (u URL) GetLastPathSegment() string + func (u URL) HasQueryOrFragment() bool + func (u URL) Host() Host + func (u URL) IsDir() bool + func (u URL) IsDirOf(other URL) (bool, error) + func (u URL) IsMutable() bool + func (u URL) Path() Path + func (u URL) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (u URL) Prop(ctx *Context, name string) Value + func (u URL) PropertyNames(ctx *Context) []string + func (u URL) RawQuery() String + func (u URL) ResourceName() string + func (u URL) Scheme() Scheme + func (u URL) ToDirURL() URL + func (u URL) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (u URL) TruncatedBeforeQuery() URL + func (u URL) UnderlyingString() string + func (u URL) Validate() error + func (u URL) WithScheme(scheme Scheme) URL + func (u URL) WithoutQueryNorFragment() URL + func (u URL) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type URLPattern string + func (URLPattern) Call(values []Serializable) (Pattern, error) + func (URLPattern) SetProp(ctx *Context, name string, value Value) error + func (URLPattern) StringPattern() (StringPattern, bool) + func (p URLPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt URLPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt URLPattern) Host() Host + func (patt URLPattern) Includes(ctx *Context, v Value) bool + func (patt URLPattern) IncludesURL(ctx *Context, u URL) bool + func (patt URLPattern) IsMutable() bool + func (patt URLPattern) IsPrefixPattern() bool + func (patt URLPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt URLPattern) Prefix() string + func (patt URLPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt URLPattern) Prop(ctx *Context, name string) Value + func (patt URLPattern) PropertyNames(ctx *Context) []string + func (patt URLPattern) PseudoPath() (string, bool) + func (patt URLPattern) Scheme() Scheme + func (patt URLPattern) Test(ctx *Context, v Value) bool + func (patt URLPattern) UnderlyingString() string + func (patt URLPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + func (pattern URLPattern) Random(ctx *Context, options ...Option) Value + type UUIDv4 uuid.UUID + func NewUUIDv4() UUIDv4 + func ParseUUIDv4(s string) (UUIDv4, error) + func (UUIDv4) IsMutable() bool + func (id UUIDv4) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (id UUIDv4) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (id UUIDv4) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (id UUIDv4) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type UnionPattern struct + func NewDisjointUnionPattern(cases []Pattern, node parse.Node) *UnionPattern + func NewUnionPattern(cases []Pattern, node parse.Node) *UnionPattern + func (p *UnionPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *UnionPattern) Cases() []Pattern + func (patt *UnionPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *UnionPattern) IsMutable() bool + func (patt *UnionPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *UnionPattern) Random(ctx *Context, options ...Option) Value + func (patt *UnionPattern) StringPattern() (StringPattern, bool) + func (patt *UnionPattern) Test(ctx *Context, v Value) bool + func (patt UnionPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt UnionPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type UnionStringPattern struct + func NewUnionStringPattern(node parse.Node, cases []StringPattern) (*UnionStringPattern, error) + func (p *UnionStringPattern) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (patt *UnionStringPattern) CompiledRegex() *regexp.Regexp + func (patt *UnionStringPattern) EffectiveLengthRange() IntRange + func (patt *UnionStringPattern) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (patt *UnionStringPattern) FindMatches(ctx *Context, val Serializable, config MatchesFindConfig) (groups []Serializable, err error) + func (patt *UnionStringPattern) HasRegex() bool + func (patt *UnionStringPattern) IsMutable() bool + func (patt *UnionStringPattern) IsResolved() bool + func (patt *UnionStringPattern) LengthRange() IntRange + func (patt *UnionStringPattern) MatchGroups(ctx *Context, v Serializable) (map[string]Serializable, bool, error) + func (patt *UnionStringPattern) Parse(ctx *Context, s string) (Serializable, error) + func (patt *UnionStringPattern) PatternNestingDepth(parentDepth int) int + func (patt *UnionStringPattern) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (patt *UnionStringPattern) Regex() string + func (patt *UnionStringPattern) Resolve() (StringPattern, error) + func (patt *UnionStringPattern) StringPattern() (StringPattern, bool) + func (patt *UnionStringPattern) Test(ctx *Context, v Value) bool + func (patt UnionStringPattern) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (patt UnionStringPattern) Random(ctx *Context, options ...Option) Value + func (patt UnionStringPattern) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type UrlHolder interface + SetURLOnce func(ctx *Context, u URL) error + URL func() (URL, bool) + func LoadFreeEntity(ctx *Context, args FreeEntityLoadingParams) (UrlHolder, error) + type VM struct + func NewVM(config VMConfig) (*VM, error) + func (v *VM) Abort() + func (v *VM) IsStackEmpty() bool + func (v *VM) Run() (result Value, err error) + type VMConfig struct + Bytecode *Bytecode + DisabledArgSharing []bool + Fn *InoxFunction + FnArgs []Value + Self Value + State *GlobalState + type ValMap map[string]Serializable + type Value interface + Equal func(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + IsMutable func() bool + PrettyPrint func(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + ToSymbolicValue func(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func CheckSharedOrClone(v Value, clones map[uintptr]Clonable, depth int) (Value, error) + func ConvertReturnValue(rval reflect.Value) Value + func EvalBytecode(bytecode *Bytecode, state *GlobalState, self Value) (Value, error) + func EvalVM(mod *Module, state *GlobalState, config BytecodeEvaluationConfig) (Value, error) + func Fmt(ctx *Context, format Format, arg Value) (Value, error) + func GetGoMethodOrPanic(name string, v GoValue) Value + func ImportWaitModule(config ImportConfig) (Value, error) + func IterateAllValuesOnly(ctx *Context, it Iterator) []Value + func MaxOf(ctx *Context, first Value, others ...Value) Value + func MinOf(ctx *Context, first Value, others ...Value) Value + func NewHost(hostnamePort Value, scheme string) (Value, error) + func NewPath(slices []Value, isStaticPathSliceList []bool) (Value, error) + func NewPathPattern(slices []Value, isStaticPathSliceList []bool) (Value, error) + func NewURL(host Value, pathSlices []Value, isStaticPathSliceList []bool, ...) (Value, error) + func RandBool(options ...Option) Value + func RandFloat(options ...Option) Value + func RandInt(options ...Option) Value + func RandULID(options ...Option) Value + func RandUUIDv4(options ...Option) Value + func ShareOrClone(v Value, originState *GlobalState) (Value, error) + func ShareOrCloneDepth(v Value, originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Value, error) + func SumOptions(ctx *Context, config *Object, options ...Option) (Value, error) + func ToValueAsserted(v any) Value + func ToValueList[T Value](arg []T) []Value + func TreeWalkCallFunc(call TreeWalkCall) (Value, error) + func TreeWalkEval(node parse.Node, state *TreeWalkState) (result Value, err error) + func Unwrap(ctx *Context, v Value) Value + func ValOf(v interface{}) Value + type ValueFilteredIterator struct + func (it *ValueFilteredIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *ValueFilteredIterator) HasNext(ctx *Context) bool + func (it *ValueFilteredIterator) IsMutable() bool + func (it *ValueFilteredIterator) Key(ctx *Context) Value + func (it *ValueFilteredIterator) Next(ctx *Context) bool + func (it *ValueFilteredIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *ValueFilteredIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *ValueFilteredIterator) Value(ctx *Context) Value + type ValueHistory struct + func NewValueHistory(ctx *Context, v InMemorySnapshotable, config *Object) *ValueHistory + func (*ValueHistory) IsMutable() bool + func (*ValueHistory) PropertyNames(ctx *Context) []string + func (h *ValueHistory) AddChange(ctx *Context, c Change) + func (h *ValueHistory) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (h *ValueHistory) ForgetChangesBeforeDate(ctx *Context, d DateTime) + func (h *ValueHistory) ForgetLast(ctx *Context) + func (h *ValueHistory) GetGoMethod(name string) (*GoFunction, bool) + func (h *ValueHistory) IsRecursivelyRenderable(ctx *Context, input RenderingInput) bool + func (h *ValueHistory) IsSharable(originState *GlobalState) (bool, string) + func (h *ValueHistory) IsShared() bool + func (h *ValueHistory) LastValue(ctx *Context) Value + func (h *ValueHistory) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (h *ValueHistory) Prop(ctx *Context, name string) Value + func (h *ValueHistory) Render(ctx *Context, w io.Writer, config RenderingInput) (int, error) + func (h *ValueHistory) RenderCurrentToHTMLFn() *InoxFunction + func (h *ValueHistory) SelectDate(ctx *Context, d DateTime) + func (h *ValueHistory) SetProp(ctx *Context, name string, value Value) error + func (h *ValueHistory) Share(originState *GlobalState) + func (h *ValueHistory) SmartLock(state *GlobalState) + func (h *ValueHistory) SmartUnlock(state *GlobalState) + func (h *ValueHistory) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (h *ValueHistory) ValueAt(ctx *Context, d DateTime) Value + func (h *ValueHistory) ValueAtSelection(ctx *Context) Value + type ValueLifetimeJobs struct + func NewValueLifetimeJobs(ctx *Context, self Value, jobs []*LifetimeJob) *ValueLifetimeJobs + func (jobs *ValueLifetimeJobs) Count() int + func (jobs *ValueLifetimeJobs) Instances() []*LifetimeJobInstance + func (jobs *ValueLifetimeJobs) InstantiateJobs(ctx *Context) error + type ValueList struct + func (l *ValueList) SortByNestedValue(ctx *Context, path ValuePath, order Order) error + func (l *ValueList) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (list *ValueList) At(ctx *Context, i int) Value + func (list *ValueList) Clone(originState *GlobalState, sharableValues *[]PotentiallySharable, ...) (Serializable, error) + func (list *ValueList) ConstraintId() ConstraintId + func (list *ValueList) ContainsSimple(ctx *Context, v Serializable) bool + func (list *ValueList) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (list *ValueList) IsMutable() bool + func (list *ValueList) Iterator(ctx *Context, config IteratorConfiguration) Iterator + func (list *ValueList) Len() int + func (list *ValueList) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (list *ValueList) SetSlice(ctx *Context, start, end int, seq Sequence) + func (list *ValueList) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error + type ValueListIterator struct + func (it *ValueListIterator) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (it *ValueListIterator) IsMutable() bool + func (it *ValueListIterator) Key(ctx *Context) Value + func (it *ValueListIterator) Next(ctx *Context) bool + func (it *ValueListIterator) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (it *ValueListIterator) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (it *ValueListIterator) Value(*Context) Value + func (it ValueListIterator) HasNext(*Context) bool + type ValuePath interface + GetFrom func(ctx *Context, v Value) Value + type ValuePathSegment interface + SegmentGetFrom func(ctx *Context, v Value) Value + type ValueVisibility struct + func GetVisibility(id VisibilityId) (*ValueVisibility, bool) + type ValueVisibilityPermission struct + Pattern Pattern + func (perm ValueVisibilityPermission) Includes(otherPerm Permission) bool + func (perm ValueVisibilityPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm ValueVisibilityPermission) Kind() PermissionKind + func (perm ValueVisibilityPermission) String() string + type ValueWatchers struct + func NewValueWatchers() *ValueWatchers + func (l *ValueWatchers) Add(watcher Watcher) + func (l *ValueWatchers) InformAboutAsync(ctx *Context, v Value, depth WatchingDepth, relocalize bool) + func (l *ValueWatchers) StopAll() + type VisibilityId uint64 + func (v VisibilityId) HasVisibility() bool + type WaitConfirmPrompt func(msg string, accepted []string) (bool, error) + type Walkable interface + Walker func(*Context) (Walker, error) + type WalkableNodeMeta struct + func NewWalkableNodeMeta(ancestors []Value, parentEdge Value) WalkableNodeMeta + type Walker interface + NodeMeta func(*Context) WalkableNodeMeta + Prune func(*Context) + type Watchable interface + OnMutation func(ctx *Context, microtask MutationCallbackMicrotask, ...) (handle CallbackHandle, err error) + RemoveMutationCallback func(ctx *Context, handle CallbackHandle) + RemoveMutationCallbackMicrotasks func(ctx *Context) + Watcher func(*Context, WatcherConfiguration) Watcher + type WatchableSubscriber interface + OnPublication func(ctx *Context, microtask PublicationCallbackMicrotask, ...) CallbackHandle + type Watcher interface + Config func() WatcherConfiguration + InformAboutAsync func(ctx *Context, v Value) + IsStopped func() bool + Stop func() + WaitNext func(ctx *Context, filter Pattern, timeout time.Duration) (Value, error) + func WatchReceivedMessages(ctx *Context, v Watchable) Watcher + type WatcherConfiguration struct + Depth WatchingDepth + Filter Pattern + Path Path + type WatchingDepth int + const DeepWatching + const IntermediateDepthWatching + const ShallowWatching + const UnspecifiedWatchingDepth + func (d WatchingDepth) IsSpecified() bool + func (d WatchingDepth) MinusOne() (WatchingDepth, bool) + func (d WatchingDepth) MustMinusOne() WatchingDepth + func (d WatchingDepth) Plus(n uint) (WatchingDepth, bool) + type WebsocketPermission struct + Endpoint ResourceName + Kind_ PermissionKind + func (perm WebsocketPermission) Includes(otherPerm Permission) bool + func (perm WebsocketPermission) InternalPermTypename() permkind.InternalPermissionTypename + func (perm WebsocketPermission) Kind() PermissionKind + func (perm WebsocketPermission) String() string + type WrappedBytes interface + UnderlyingBytes func() []byte + type WrappedString interface + UnderlyingString func() string + type Writable interface + Writer func() *Writer + type WritableByteStream struct + func NewWritableByteStream(writeByteToSink func(s *WritableByteStream, b byte) error, ...) *WritableByteStream + func (*WritableByteStream) IsMutable() bool + func (s *WritableByteStream) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (s *WritableByteStream) IsStopped() bool + func (s *WritableByteStream) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (s *WritableByteStream) Stop() + func (s *WritableByteStream) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *WritableByteStream) WritableStream(ctx *Context, config *WritableStreamConfiguration) WritableStream + func (s *WritableByteStream) Write(ctx *Context, v Value) error + func (s *WritableByteStream) WriteBytes(ctx *Context, p []byte) error + func (s *WritableByteStream) WriteChunk(ctx *Context, chunk *DataChunk) error + type WritableStream interface + IsStopped func() bool + Stop func() + Write func(ctx *Context, value Value) error + WriteChunk func(ctx *Context, chunk *DataChunk) error + type WritableStreamConfiguration struct + type Writer struct + func WrapWriter(w io.Writer, buffered bool, lock *sync.Mutex) *Writer + func (*Writer) IsMutable() bool + func (*Writer) SetProp(ctx *Context, name string, value Value) error + func (Writer) PropertyNames(ctx *Context) []string + func (w *Writer) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (w *Writer) Flush(ctx *Context) error + func (w *Writer) GetGoMethod(name string) (*GoFunction, bool) + func (w *Writer) Prop(ctx *Context, name string) Value + func (w *Writer) TotalWritten() Int + func (w *Writer) Write(p []byte) (n int, err error) + func (w *Writer) WriteString(s string) (n int, err error) + func (w *Writer) WriteStrings(s ...string) (n int, err error) + func (w *Writer) Writer() *Writer + func (writer *Writer) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (writer *Writer) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + type XMLAttribute struct + func NewXMLAttribute(name string, value Value) XMLAttribute + func (a XMLAttribute) Name() string + func (a XMLAttribute) Value() Value + type XMLElement struct + func NewRawTextXmlElement(name string, attributes []XMLAttribute, rawContent string) *XMLElement + func NewXmlElement(name string, attributes []XMLAttribute, children []Value) *XMLElement + func (*XMLElement) IsMutable() bool + func (e *XMLElement) Attributes() []XMLAttribute + func (e *XMLElement) Children() []Value + func (e *XMLElement) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (e *XMLElement) Name() string + func (e *XMLElement) RawContent() string + func (p *XMLElement) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (s *XMLElement) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + type Year time.Time + func (d Year) IsMutable() bool + func (y Year) Compare(other Value) (result int, comparable bool) + func (y Year) Equal(ctx *Context, other Value, alreadyCompared map[uintptr]uintptr, depth int) bool + func (y Year) PrettyPrint(w *bufio.Writer, config *PrettyPrintConfig, depth int, parentIndentCount int) + func (y Year) ToSymbolicValue(ctx *Context, encountered map[uintptr]symbolic.Value) (symbolic.Value, error) + func (y Year) Validate() error + func (y Year) WriteJSONRepresentation(ctx *Context, w *jsoniter.Stream, config JSONSerializationConfig, depth int) error