Fork me on GitHub
Source file: piping.fut

Pipe operators

Futhark programs are typically written as chains of functions that each slightly massage the data somehow. For example, to compute the sum of square roots of all positive numbers in an array:

def square_pos xs =
  f64.sum (map f64.sqrt (filter (>0) xs))

Note that this is not the best way to write this function. Also, These chains can become unwieldy as they grow. Partly because of the parentheses, and partly because they have to be read right-to-left. The pipe forward operator |> lets us write it like this instead:

def square_pos_pipe xs =
  xs |> filter (>0) |> map f64.sqrt |> f64.sum

Now the dataflow is purely left-to-right and we can easily add more links in the processing chain.

There is nothing magical in the pipe operator. It’s a polymorphic higher-order function that you could have defined yourself, but happens to be predefined in the Futhark prelude. It’s defined like this:

let (|>) '^a '^b (x: a) (f: a -> b): b = f x

There is also a pipe backwards operator <|, but due to Futhark’s restrictive size type system, it has some nonintuitive limitations, and usually does not work with functions that return arrays of statically unknown size (such as filter).

See also

Reference manual: Size types