iamvery

[4] pry(#<HighVoltage::PagesController>)> params
=> {"things"=>{"stuff"=>"123"},
 "id"=>"landing_page",
 "controller"=>"high_voltage/pages",
 "action"=>"show"}
[5] pry(#<HighVoltage::PagesController>)> params.fetch(:stuff){ Hash.new }
=> {}
[6] pry(#<HighVoltage::PagesController>)> params
=> {"things"=>{"stuff"=>"123"},
 "id"=>"landing_page",

iamvery

I watching the demo/use cases video for contracts.ruby and recorded some thoughts.

Use case 1

The use case states that you can avoid bugs like needing string keys instead of symbol keys be enforcing a contract that requires the method input to be a string.

IMO you should instead create a flexible interface that will allow any "stringable" input to be given to the method. That is, use the implicit string conversion methods to_s to make a string of it for indexing into the hash.

Use case 2

iamvery

require 'contracts'

include Contracts

class ConvertableToHash
  def self.valid?(thing)
    thing.to_h
    true
  rescue TypeError
    false

iamvery

Conway's Game of Life, written in Ruby

Run the game

ruby driver.rb

Run the specs

rspec game_of_life_spec.rb

iamvery

Io 20110905
Io> t1 := Object clone
==>  Object_0x7f82795c83d0:

Io> t2 := Object clone
==>  Object_0x7f827a803790:

Io> t1 isIdenticalTo(t2)
==> false
Io> t1 isIdenticalTo = method(true)

iamvery

Conway's Game of Life, written in io

Run the game

io driver.io

Run the specs

io cell_spec.io

iamvery

# Live cells with < 2 living neighbors dies to underpop
# > 3 living neighbors dies to overpop
# Otherwise, lives!
#
# Dead cells with exactly 3 living neighbors is born

# . 0 .
# . 0 .
# . 0 .
#

iamvery

protocol Foobery {
    func asFoo() -> String
}

extension String: Foobery {
    func asFoo() -> String {
        return "foo"
    }
}

iamvery

class Bar {}

class Baz {
  init(str: String!) {
    println(str)
  }
}

class Foo: Bar {
  let bar: String!

iamvery

#!/bin/sh

file=$1
exec=$(echo $file | awk -F\. '{print$1}')

xcrun swift "$file" && ./"$exec"