On this page:

1. Tuples

Up one level:

1. Reference
   1. The Ecosystem
      1. Eco
      2. Packages
      3. Versions
   2. Core
   3. Dynamic Environment
   4. Lists
   5. Tuples
   6. Strings
   7. Regular Expressions
   8. String Formatting
      1. Syntax
      2. Basic Formatters
      3. Alignment
      4. Pluralization
      5. Case Conversion
      6. Skipping & Indirection
      7. Iteration & Breaking
      8. Conditionals
      9. Justification
   9. Class Objects
      1. Defining Classes
      2. Modules & Mixins
   10. Blocks
   11. Concurrency
   12. Conditions & Restarts
       1. Signals
       2. Handlers
       3. Traditional Exceptions
   13. Continuations
   14. Particles
   15. Numbers
   16. Boolean
       1. Logic
       2. Control Flow
   17. Comparable
   18. Input & Output
       1. Parameters
   19. Timer
       1. The Timer Object
       2. Unit Helpers
   20. Associations
   21. Ordered Values
   22. Ranges
   23. Pretty-Printing
       1. Documents From Values
       2. Simple Shortcuts
       3. Wrapping Documents
       4. Combining Documents
       5. Rendering

Tuples

Atomo's tuples are very different from the tuples you'll find in most other languages. In fact, they are primarily a syntactic construct, and should never, ever be used for persistent data. Their use is restricted to temporary groupings of arbitrary values, such as pattern-matching and variadic message roles.

For example, they can be used to quickly swap two values via pattern-matching:

> (a, b) = (1, 2)
(1, 2)
> (a, b) = (b, a)
(2, 1)
> [a, b]
[2, 1]

They're also used for variadic roles - that is, roles that may take zero, one, or any number of values:

> { a | a + 1 } call: 2
3
> { a b | a + b } call: (2, 1)
3

But things can go very wrong when you try to use them as data:

> [(1, $1), (2, $2), (3, $3)] map: @pretty
[1, 2, 3]

What happened here was that when we called @pretty on each value of the list, the tuple was used as a variadic role value, rather than some "tuple" value. So, do not confuse tuples with how they're used in Python or even Haskell - they are strictly for temporary groupings of data. When used persistently, it is often the case that you will end up with only some of the data contained in them.

And that's really all there is to Atomo's tuples. There isn't a huge method list here because there isn't really anything you should be doing with them. In fact, the only method defined on Tuple is @pretty, for pretty-printing.