1. Overview
  2. Tutorials
  3. 1. Overview
  4. 2. Entry-level Model Checker Tutorial
  5. 3. Type Checker Tutorial
  6. 4. Checking Pluscal specifications
  7. 5. Apalache trail tips: how to check your specs faster
  8. 6. Symbolic Model Checking
  9. 7. Specifying temporal properties and understanding counterexamples
  10. HOWTOs
  11. 8. Overview
  12. 9. How to write type annotations
  13. 10. How to use uninterpreted types
  14. Apalache User Manual
  15. 11. Getting Started
    1. 11.1. Installation
      1. 11.1.1. Prebuilt Packages
      2. 11.1.2. Docker
      3. 11.1.3. Build from Source
    2. 11.2. Running the Tool
    3. 11.3. An Example TLA+ Specification
    4. 11.4. Specification Parameters
    5. 11.5. Symbolic Model Checking with Apalache
      1. 11.5.1. Assignments and symbolic transitions
      2. 11.5.2. Folding sets and sequences
      3. 11.5.3. Invariants: State, Action, Trace
      4. 11.5.4. Enumeration of counterexamples
      5. 11.5.5. The Apalache Module
      6. 11.5.6. Naturals
    6. 11.6. Apalache global configuration file
    7. 11.7. TLA+ Execution Statistics
    8. 11.8. Profiling Your Specification
    9. 11.9. Five minutes of theory
  16. 12. Fine Tuning
  17. 13. TLC Configuration Files
  18. 14. The Snowcat Type Checker
  19. 15. Supported Features
  20. 16. Obsolete: Recursive operators and functions
  21. 17. Known Issues
  22. 18. Antipatterns
  23. 19. TLA+ Preprocessing
  24. 20. Assignments and Symbolic Transitions in Depth
  25. 21. KerA: kernel logic of actions
  26. TLA+ Language Manual for Engineers
  27. 22. Introduction
  28. 23. The standard operators of TLA+
    1. 23.1. Booleans
    2. 23.2. Control And Nondeterminism
    3. 23.3. Conditionals
    4. 23.4. Integers
    5. 23.5. Sets
    6. 23.6. Logic
    7. 23.7. Functions
    8. 23.8. Records
    9. 23.9. Tuples
    10. 23.10. Sequences
    11. 23.11. Bags
  29. 24. Apalache extensions
    1. 24.1. Apalache module
    2. 24.2. Variants
    3. 24.3. Option types
  30. 25. User-defined operators
    1. 25.1. Top-level operator definitions
    2. 25.2. LET-IN definitions
    3. 25.3. Higher-order operators definitions
    4. 25.4. Anonymous operator definitions
    5. 25.5. Local operator definitions
  31. 26. Modules, Extends, and Instances
  32. Idiomatic TLA+
  33. 27. Introduction
  34. 28. Keep state variables to the minimum
  35. 29. Update state variables with assignments
  36. 30. Apply primes only to state variables
  37. 31. Use Boolean operators in actions, not IF-THEN-ELSE
  38. 32. Avoid sets of mixed records
  39. Design Documents
  40. 33. RFC 001: types and type annotations
  41. 34. ADR-002: types and type annotations
  42. 35. ADR-003: transition executor (TRex)
  43. 36. ADR-004: code annotations
  44. 37. ADR-005: JSON Serialization Format
  45. 38. RFC-006: unit tests and property-based tests
  46. 39. ADR-007: restructuring
  47. 40. ADR-008: exceptions
  48. 41. ADR-009: outputs
  49. 42. RFC-010: Implementation of Transition Exploration Server
  50. 43. ADR-011: alternative SMT encoding using arrays
  51. 44. ADR-012: Adopt an ADR Template
  52. 45. ADR-013: Configuration Management Component
  53. 46. ADR-014: Precise type inference for records and variants
  54. 47. ADR-015: ITF: informal trace format
  55. 48. ADR-016: ReTLA: Relational TLA
  56. 49. PDR-017: Checking temporal properties
  57. 50. ADR-018: Inlining in Apalache
  58. 51. ADR-019: Harmonize changelog management
  59. 52. ADR-020: Improving membership in arenas
  60. 53. RFC-021: Prioritization of Work
  61. 54. ADR-022: Unify Configuration Management and "Pass Options"
  62. 55. ADR-023: Trace evaluation
  63. 56. ADR-024: Arena computation isolation

Apalache Documentation

Higher-order operator definitions

work in progress...

[Back to user operators]