let initial_data = [1, 2, 4]
//NOTE 1: Named the function "chute" for a clear example
  //In actual usage a single character works best: "_"
const result = chute(initial_data,/*any functions…*/push(8))
  //Chute can alternate function and method calls.
  //==== METHOD CALLS
  // Method calls native to the current data work as normal:
  .map(double)
  .filter(greater_than(4))
  //==== FUNCTION CALLS
  //Chute provides a few ways to call functions.
  //== SUB CHAINS:
  //".and" sends data through 1+ functions.
  //".and(f1,f2)" sends data to f1, then f1's return to f2.
  .and(push(32),push(64))
  //Nameless calls work the same way as ".and":
  (push(80,128),push(256))
  //these sub-chains use a reducer to mimic nested calls.
    //"(f1,f2)" == "f2(f1(x))"
  //strings can call methods that need no arguments:
  ('reverse')//for sequences like: ".and(f1,'method',f2)".
  //== METHOD STYLE GLOBAL FUNCTION CALLS:
  //".name_of_a_global_function" calls a global function:
  .wrap_in_array()//no arguments == "fn(data)"
  .get_index(0)//arguments == "fn(arguments)(data)"
  //PLACEHOLDERS
  //Call a function with a data argument placeholder.
  .placeholder_test('arg1',chute._/*<-placeholder*/,'arg3')
    //The property "._" of the chute function's name
    //If you name chute "_", the placeholder === '_._'
    //(Initial implementation: subject to change)
  //Chute can call global functions with unoccupied names.
    //Chute looks for methods before global functions.
    //It checks the current data's native methods.
    //It also check's Chute's built in methods:
  //BUILT IN METHODS
  //Chute also has "log", "tap", and "if" methods.
  //".log" calls a built in method that takes 0+ arguments.
  .log()//".log()" logs the current data, then resumes.
  .log('Pre-tap data')// ".log" logs arguments before data.
  //'.tap' calls a built in method that takes one function.
  //'.tap(f1)' sends the data to f1 but ignores the result.
  .tap(mutate)//.tap functions might mutate data directly.
  .log('Post-tap data')
  //'.if' calls a built in method that takes 2 arguments.
  .if(//Argument 1
    //a boolean (some unrelated check e.g. "is_saturday()")
    //or a function that tests the data and return a boolean.
    is_array,
    //Argument 2:A function to send the data through
      //(If the condition equals the boolean true.)
    sum
  )
  .log("After if method:")
  ()//an empty call returns the final value
  //from this point, method calls directly act on the data.
  .toString()
  .replace(/$/,'!')
log(`Chute Result`,result)

//Demo Helper Functions

function placeholder_test(arg_1,the_data,arg_2){
  console.log(new Map([
    ["argument_1", arg_1],
    ["the_data given with placeholder argument", the_data],
    ["argument_2", arg_2]
  ])
  )
  return the_data
}
function get_index(i){return data => data[i]}
function wrap_in_array(data){return [data]}
function push (...a){return l => (l.push(...a),l)}
function log (...x){console.log(...x);return x}
function greater_than(n){ return x => x > n}
function double(x){return x * 2}
function sum(data){return data.reduce((a,b)=>a+b)}
function is_array(data){return Array.isArray(data)}
function mutate (data){
  data.length=2
  return 'chucks this returned value'
}