txt: ## operators.md
  ## Chunk 6 of 6
   Capitalize the words
      <== <people of earth>;  # (1) Start with the input
  
  # It can be useful to capture a partial result
  my @result
      <== sort()
      <== grep({ /<[PE]>/ })
      <== my @caps            # unlike ==>, there's no need for additional statement
      <== map({ .tc })
      <== <people of earth>;
  ```
  
  Unlike the rightward feed operator, the result is not closely mappable to method-chaining. However, compared to the traditional structure above where each argument is separated by a line, the resulting code is more demonstrative than commas. The leftward feed operator also allows you to "break into" the statement and capture an intermediary result which can be extremely useful for debugging or to take that result and create another variation on the final result.
  
  Note: In the future, this operator will see some change as it gains the ability to run list operations in parallel. It will enforce that the **right** operand is enclosable as a closure (that can be cloned and run in a subthread).
  
  # [Identity](#Operators "go to top of document")[§](#Identity "direct link")
  
  In general, infix operators can be applied to a single or no element without yielding an error, generally in the context of a [reduce](/routine/reduce) operation.
  
  ```raku
  say [-] ()  # OUTPUT: «0␤»
  ```
  
  The design documents specify that this should return [an identity value](https://en.wikipedia.org/wiki/Identity_element), and that an identity value [must be specified for every operator](http://design.raku.org/S03.html#Reduction_operators). In general, the identity element returned should be intuitive. However, here is a table that specifies how it is defined for operator classes in Raku, which corresponds to the table in the above definition in the types and operators defined by the language:
  
  | Operator class | Identity value |
  | --- | --- |
  | Equality | True |
  | Arithmetic + | 0 |
  | Arithmetic \* | 1 |
  | Comparison | True |
  | Bitwise | 0 |
  | Stringy | '' |
  | Sets | Empty set or equivalent |
  | Or-like Bool | False |
  | And-like Bool | True |
  
  For instance, union of an empty list will return an empty set:
  
  ```raku
  say [∪];  # OUTPUT: «Set()␤»
  ```
  
  This only applies to operators where empty or 0 is always a valid operand. For instance, applying it to division will yield an exception.
  
  ```raku
  say [%] ();  # OUTPUT: «(exit code 1) No zero-arg meaning for infix:<%>␤»
  
  ```
  