Look Around You

Have you worked out what we're looking for?

Currying, Composition, and You

What is currying?

• Technique for changing how many arguments a function takes
• Popularized by, and named after, American mathematician Haskell Curry
• (Yes, that's where the name comes from)

Actually...

invented by Moses Schönfinkel

Boyer's Law

(discovered by Hubert Kennedy)

First, you need a function

add = lambda do |x, y|
  x + y
end

add.call(5, 6)

More tersely,

add = -> x, y { x + y }
add[5, 6]

Now, instead of returning the value, wrap the value in a lambda.

add = lambda do |x, y|
  lambda do 
    x + y
  end
end

add.call(5, 6).call

Now, just move the argument from the outer lambda to the inner lambda!

add = lambda do |x|
  lambda do |y|
    x + y
  end
end

add.call(5).call(6)

Congrats!!

Y'all are curry masters!

What is a use for Currying?

Function composition!

Scary Math Time

And, in Ruby...

foo = lambda do |x| 
  2 * x + 1
end

bar = lambda do |x|
  x ** 2
end

(foo * bar).call(x) == foo.call(bar.call(x))

Ruby doesn't have a function composition operator...

... yet!!

class Proc
  def *(other)
    lambda do |x|
      self.call(other.call(x))
    end
  end
end

You may be more used to...

Bash pipes!

# How many classes are defined in your app?
$ cat **/*.rb | grep "^class" | wc -l

# Using the * style:
$ (wc -l * grep "^class" * cat)( **/*.rb )
$  wc -l ( grep "^class" ( cat ( **/*.rb ) ) )

Wait a minute...

Those Unix commands are partially applied!

Fully Applied

$ wc -l **/*.rb
$ grep "^class" **/*.rb
$ cat **/*.rb

surprise curry

Unfortunately, Ruby doesn't have the pipe composition operator...

... yet!

class Proc
  def |(other)
    lambda do |x|
      other.call(self.call(x))
    end
  end
end

Ruby is Object Oriented,

not Lambda Oriented.

Super easy in JavaScript!

Tons of higher order functions and callbacks

Normal

function update(index, item) {
  App.data[index] = item;
}

function renderItems() {
  return App.data.map(function (item, index) { 
    return new Item(item, update.bind(this, index));
  });
}

Currified

function update(index) {
  return function (item) {
    App.data[index] = item;
  }
}

function renderItems() {
  return App.data.map(function (item, index) {
    return new Item(item, update(index));
  });
}

Lambdafied

let update = index => item => App.data[index] = item;

function renderItems() {
  return App.data.map(
    (item, index) => new Item(item, update(index))
  );
}

javascript :(

If you'll permit...

let's go to space!

What is a function?

The add function

add = -> x, y { x + y }

public static int add(int x, int y) {
  return x + y; 
}

add :: Int -> Int -> Int
add x y = x + y

A function is:

a transformation from something to some other thing

represented like: $$ A \rightarrow B $$

where $A$ is the type of the original thing, and $B$ is the type of the new thing, and the arrow ($\rightarrow$) represents the transformation

Ruby is Object Oriented, not Lambda or Function Oriented.

Is there an equivalence? How can we translate these ideas?

Ruby Class as a Function

RCaaF -- startup idea!

(this is kinda out there so please stop me and ask questions if you want)

How to make a Ruby class like a function?

Where:

• $f$ is Class#new
• $A$ is the duck-type of the input argument
• $B$ is the duck-type of the resulting object

Formal Definition of a Duck

A Duck is the methods we care about on some object.

Ok...

class F
  attr_reader :b

  def initialize(object)
    @b = object.a
  end
end

Objects from F have the duck b, and it's input argument has the duck a

So...

class G
  attr_reader :a

  def initialize(object)
    @a = object
  end
end

Objects from G have the duck a, and it's input argument doesn't have a duck

Will It Blend Compose?

>> F.new( G.new( 5 ) ).b
=> 5

Yeah!

I wrote the gem Beethoven to make this sort of thing easier

The following are equivalent:

F.new(G.new(5)).b

(F * G).new(5).b

(G | F).new(5).b

[G, F].reduce(&:|).new(5)

To Curry a Class

Single argument functions are boring...

Currying a function:

lambda do |x, y|
  x + y
end.call(5, 6)

 lambda do |x|
  lambda { |y| x + y }
end.call(5).call(6)  

What is the Duck of an instance of Class?

Class#new

Return an object that responds to call new...

Add

class Add
  def initialize(x)
    @x = x
  end

  def new(y)
    @y = y; return self
  end

  def value
    @x + @y
  end
end

>> Add.new(5).new(6).value
=> 11  

Higher order functions?

class Map
  def initialize(func)
    @func = func
  end

  def new(object)
    @list = object.list; self
  end

  def list
    @list.map(&@func)
  end
end

Higher order functions?

class Filter
  def initialize(func)
    @func = func
  end

  def new(object)
    @list = object.list; self
  end

  def list
    @list.filter(&@func)
  end
end

Higher order functions?

class Reduce
  def initialize(func)
    @func = func
  end

  def new(object)
    @list = object.list; self
  end

  def value 
    @list.reduce(&@func)
  end
end

Verbosely...

List = Struct.new(:list)
list = List.new( (1..100).to_a )

Reduce.new(-> sum, next { sum + next }).new(
  Map.new(-> x { x + 10 }).new(
    Filter.new(-> x { x.even? }).new(list)
  )
).value
=> 3050
          

Better!

Pipeline = Filter.new(-> x { x.even? })
         | Map.new(-> x { x + 10 }) 
         | Reduce.new(-> sum, next { sum + next })

Pipeline.new(list).value
=> 3050
          

ooooooh

even    = -> x { x.even? }
add_ten = -> x { x + 10 }
add     = -> x, y { x + y }

Pipeline = Filter.new(even)
         | Map.new(add_ten) 
         | Reduce.new(add)

Pipeline.new(list).value
=> 3050
          

you can curry that

even = -> x { x.even? }
add  = -> x, y { x + y }.curry

Pipeline = Filter.new(even)
         | Map.new(add.call(10)) 
         | Reduce.new(add)

Pipeline.new(list).value
=> 3050

(•_•)

( •_•)>⌐■-■

(⌐■_■)

I'm Matt Parsons?

Ruby and JavaScript @(we're they're hiring!)

Now, Haskell @ Layer 3 Communications

Thanks! :D

questions?

@mattoflambda (Twitter)

@parsonsmatt (Github)