Contracts on `self`

[vlad-shatskyi]

Let's say I have the following contracts

Contract Alkohol, Underaged => String
def sell(drink, person)
  "Sorry, come back in #{18 - person.age} years."
end

Contract Drink, Person => String
def sell(drink, person)
  "Here's your #{drink}."
end

full code

It works perfectly well, but let's say I want to define the sell method on Person. Now it becomes not obvious how would I check if the person is allowed to have the drink.

I propose to have some sort of self constraints. In Haskell-like syntax it would be

Contract :: (Underaged self) => Drink -> String

[waterlink]

Just like that (normal OO way):

class Underaged
  include Contracts::Core

  Contract Drink => String
  def sell(drink)
    "Sorry, come back in #{18 - person.age} years."
  end
end

class Person
  include Contracts::Core

  Contract Drink => String
  def sell(drink)
    "Here is your drink."
  end
end

[vlad-shatskyi]

@waterlink, now I'd need a factory to create a person depending on age.
You propose to use polymorphism, whereas the gem advertises to enable methods overloading, which I'm trying to achieve. I understand that normally OO languages don't dispatch based on self, but why not?

Update: I guess it's not correct to say that OO languages don't dispatch based on self. If you have only one criteria for dispatching - a type - there is nothing to choose from. Quite easy to pick one from a set of one, right? We, however, have more ways to describe a contract, and that raises a need for the feature I propose.

[nixpulvis]

Thing is you already have a Underaged defined in your example.

[vlad-shatskyi]

I do have an Underaged contract, but it's a constraint, not a class, which I'd use for polymorphic behaviour.

[vlad-shatskyi]

I'm willing to implement the feature providing we agree on the syntax and its usefulness.

[alex-fedorov]

Propose a syntax then :)

Other way: just use private method, that doesn't depend on self. Like this:

class Person
  Contract Drink => String
  def sell(drink)
    _sell(self, drink)
  end

  private

  Contract Underaged, Drink => String
  def _sell(person, drink)
    "Sorry, come back in #{18 - person.age} years."
  end

  Contract Person, Drink => String
  def _sell(person, drink)
    "Here is your #{drink}!"
  end
end

[vlad-shatskyi]

I'm afraid I don't have enough knowledge about which symbols can be used. Since you chose => to delimit arguments from the return value, I guess -> is not possible. Maybe something like

Contract Alkohol > Underaged => String
Contract Alkohol | Underaged => String
Contract Alkohol >> Underaged => String

I hope you'll agree with me that the workaround is super-ugly.

[alex-fedorov]

How about:

Contract Contracts::Receiver[Underaged], Drink => String

?

[vlad-shatskyi]

You know better, but won't it cause difficulties to distinguish whether the contract is for the first parameter or for the receiver?

[alex-fedorov]

It will cause this problem in any case.
On Jul 29, 2015 3:04 PM, "Volodymyr Shatsky" notifications@github.com
wrote:

You know better, but won't it cause difficulties to distinguish whether
the contract is for the first parameter or for the receiver?

—
Reply to this email directly or view it on GitHub
#191 (comment)
.

[vlad-shatskyi]

I mean you chose the same separator as for the parameters list. If the separator was different, it would be easier to tell the difference.

[egonSchiele]

This does sound like a useful feature. Maybe we could do

Contract(Underaged) Drink => String

and

Contract(Person) Drink => String

If we have that code, it will build the foundation for future changes, where we can pass in arbitrary data to the Contract function before specifying the contract itself.

[waterlink]

Unfortunately, this is not a valid ruby. To make it valid we will have to send some message after calling Contract(x):

Contract(Underaged).with Drink => String

[waterlink]

Another example would be to return a lambda and call it:

Contract(Underaged).(Drink => String)
# or
Contract(Underaged)[Drink => String]
# or
Contract[Underaged].(Drink => String)
# or
Contract[Underaged][Drink => String]

[waterlink]

Some interesting syntax still can be used:

Contract[Underaged].>> Drink => String