🚰Pipes

Pipe Syntax

expr => someFunctionCall(<args with at least one underscore>)

The pipe (=> ) takes the expression on the left and "pipes" it into the function right, wherever there are underscores.

For every underscore you use, a new instance of the left-hand expression will be made. For instance, myExpr ⇒ someFunction(_, _) turns into someFunction(myExpr, myExpr). This many result in unwanted side-effects.

Working Example

Gauntlet

package main

import "fmt" as fmt

fun Int add(Int num, Int addend) {
  return num + addend
}

fun Int subtract(Int num, Int subtrahend) {
  return num - subtrahend
}

fun Int multiply(Int num, Int multiplier) {
  return num * multiplier
}

fun Int divide(Int num, Int divisor) {
  return num / divisor
}

fun Unit main() {
  10
  => add(_, 10)
  => add(_, 30)
  => divide(_, 2)
  => subtract(_, 5)
  => divide(_, 2)
  => multiply(_, 10)
  => fmt.println(_)
}

Transpiled

package main

import fmt "fmt"

func add(num int, addend int) int {

	return num + addend

}

func subtract(num int, subtrahend int) int {

	return num - subtrahend

}

func multiply(num int, multiplier int) int {

	return num * multiplier

}

func divide(num int, divisor int) int {

	return num / divisor

}

func main() {
	fmt.Println(multiply(divide(subtract(divide(add(add(10, 10), 30), 2), 5), 2), 10))

}

Output

100