← All Examples FP

Pipes & Composition

JAPL's pipe-forward operator |> lets data flow left-to-right through function chains. Combined with higher-order functions, this enables expressive, readable data transformations.

Source Code: Pipes

fn double(x: Int) -> Int { x * 2 }
fn add(x: Int, y: Int) -> Int { x + y }
fn to_str(x: Int) -> String { show(x) }

fn main() {
  let result = 5 |> double |> double
  println(show(result))

  let msg = 42 |> to_str
  println(msg)
}

Source Code: Higher-Order Functions

fn apply(f: fn(Int) -> Int, x: Int) -> Int { f(x) }
fn double(x: Int) -> Int { x * 2 }
fn square(x: Int) -> Int { x * x }

fn apply_twice(f: fn(Int) -> Int, x: Int) -> Int { f(f(x)) }

fn main() {
  println(show(apply(double, 5)))
  println(show(apply(square, 4)))
  println(show(apply_twice(double, 3)))
  let add_ten = fn(x: Int) { x + 10 }
  println(show(apply(add_ten, 5)))
}

What This Demonstrates

• Pipe-forward operator |> -- Passes the left-hand value as the first argument to the right-hand function. 5 |> double is equivalent to double(5).
• Chained pipes -- Multiple pipes compose left-to-right: 5 |> double |> double computes double(double(5)) = 20.
• Functions as values -- Functions can be passed as arguments. apply(double, 5) calls double with 5.
• Function types -- fn(Int) -> Int is the type of a function taking an Int and returning an Int.
• Anonymous functions -- fn(x: Int) { x + 10 } creates an inline function (lambda) without naming it.
• Applying functions multiple times -- apply_twice demonstrates that higher-order functions can express powerful abstractions concisely.

Line-by-Line Breakdown

let result = 5 |> double |> double

Starts with 5, pipes it into double (getting 10), then pipes that into double again (getting 20). Reads left-to-right, like a Unix pipeline.

fn apply(f: fn(Int) -> Int, x: Int) -> Int

Takes a function f and a value x, and applies f to x. The function type is written fn(Int) -> Int.

fn apply_twice(f: fn(Int) -> Int, x: Int) -> Int { f(f(x)) }

Applies f twice. apply_twice(double, 3) computes double(double(3)) = 12.

let add_ten = fn(x: Int) { x + 10 }

An anonymous function bound to a local variable. It can be passed to apply just like a named function.

Try Modifying

• Build a longer pipeline: 5 |> double |> square |> to_str and print the result.
• Write a compose function that takes two functions and returns their composition.
• Create a map function that applies a function to each element of a list.
• Use anonymous functions directly in a pipe: 5 |> fn(x: Int) { x * 3 }.