1 # Reductions
   2 
   3 In Tomo, reductions are a way to express the idea of folding or reducing a
   4 collection of values down to a single value. Reductions use a parenthesized
   5 infix operator followed by a colon, followed by a collection:
   6 
   7 ```tomo
   8 nums := [10, 20, 30]
   9 sum := (+: nums)
  10 assert sum == 60
  11 ```
  12 
  13 Reductions return an optional value which will be a null value if the thing
  14 being iterated over has no values. In such cases, the reduction is undefined.
  15 As with all optionals, you can use either the postfix `!` operator to perform
  16 a runtime check and error if there's a null value, or you can use `or` to
  17 provide a fallback value:
  18 
  19 ```tomo
  20 nums : [Int] = []
  21 sum := (+: nums)
  22 
  23 assert sum == none
  24 
  25 assert sum or 0 == 0
  26 
  27 nums = [10, 20]
  28 assert (+: nums)! == 30
  29 ```
  30 
  31 Reductions can be used as an alternative to generic functions like `sum()`,
  32 `product()`, `any()`, and `all()` in Python, or higher-order functions like
  33 `foldl` and `foldr` in functional programming:
  34 
  35 ```tomo
  36 # Sum:
  37 assert (+: [10, 20, 30])! == 60
  38 
  39 # Product:
  40 assert (*: [2, 3, 4])! == 24
  41 
  42 # Any:
  43 assert (or: [no, yes, no])! == yes
  44 
  45 # All:
  46 assert (and: [no, yes, no])! == no
  47 ```
  48 
  49 ## Minimum and Maximum
  50 
  51 Reductions are _especially_ useful for finding the minimum or maximum values in
  52 a collection using the `_min_` and `_max_` infix operators.
  53 
  54 ```tomo
  55 # Get the maximum value:
  56 assert (_max_: [10, 30, 20])! == 30
  57 
  58 # Get the minimum value:
  59 assert (_min_: [10, 30, 20])! == 10
  60 ```
  61 
  62 Reducers also support field and method call suffixes, which makes it very easy
  63 to compute the argmin/argmax (or keyed minimum/maximum) of a collection. This
  64 is when you want to get the minimum or maximum value _according to some
  65 feature_.
  66 
  67 ```tomo
  68 # Get the longest text:
  69 assert (_max_.length: ["z", "aaaaa", "mmm"])! == "aaaaa"
  70 
  71 # Get the number with the biggest absolute value:
  72 assert (_max_.abs(): [1, -2, 3, -4])! == -4
  73 ```
  74 
  75 You can also use suffixes on other operators:
  76 
  77 ```tomo
  78 texts := ["x", "y", "z"]
  79 assert (==: texts) == no
  80 assert (==.length: texts) == yes
  81 assert (+.length: texts) == 3
  82 
  83 nums := [1, 2, -3]
  84 assert (+.abs(): nums) == 6
  85 ```
  86 
  87 ## Comprehensions
  88 
  89 Reductions work not only with iterable values (lists, sets, integers, etc.),
  90 but also with comprehensions. You can use comprehensions to perform reductions
  91 while filtering out values or while applying a transformation:
  92 
  93 ```tomo
  94 # Sum the lengths of these texts:
  95 assert (+: t.length for t in ["a", "bc", "def"])! == 6
  96 
  97 # Sum the primes between 1-100:
  98 assert (+: i for i in 100 if i.is_prime())! == 1060
  99 ```