I'm pleased to announce version 1.1.1 of RDL, a lightweight system for
adding
contracts to Ruby. The new release fixes some bugs; adds more precise type
signatures for the numeric tower; adds initial support for dependent types;
and includes support for higher-order types. Comments, questions,
suggestions,
and complaints are all welcome! Email me or post on the forum.
Jeff
### New! Dependent types
This version of RDL has support for some fancier types that can include
arbitrary pre- and post-conditions. For example:
type '(Fixnum x {{ x>y }}, Fixnum y) -> Fixnum z {{ z==(x+y) }}'
types a method that takes two arguments `x` and `y` such that `x` is greater
than `y`, and it returns a result `z` that is equal to the sum of `x` and
`y`.
### New! Support for higher-order types
This version of RDL also adds support for checking higher-order types (the
previous version could parse some cases of these but didn't fully check
them). For example, in
type '(Fixnum, Float) {(Fixnum, String) -> String } -> Float'
the type delimited by `{...}` is for the method's block argument. Or in:
type '(Fixnum, {(Fixnum) -> Fixnum}) -> Fixnum'
the type deliminated by `{...}` is for the method's second arugment, which
must be a `Proc`.
### Coordinates
* code/docs: https://github.com/plum-umd/rdl
* gem: https://rubygems.org/gems/rdl
* install: gem install rdl
* forum: https://groups.google.com/d/forum/rdl-users
### What is RDL?
A contract decorates a method with assertions about the method inputs (a
precondition) and outputs (a postcondition). For example, ignoring complex
numbers, we can write:
require 'rdl'
pre { |x| x > 0 } # input x must be positive
post { |r,x| r > 0 } # return value r must be positive
def sqrt(x)
# return the square root of x
end
RDL intercepts calls to contracted methods and checks their preconditions
when
the method is called, and their postconditions when the method returns.
RDL also has extensive support for contracts that are types. For example:
require 'rdl'
type '(Fixnum, Fixnum) -> String'
def m(x,y) ... end
This will check that m's x and y arguments are Fixnums and its return value
is
a String. (Note: these are contracts, so the checking only occurs at method
entry and exit; there is no static analysis here that reasons about the
method
body.)
### License
BSD 3-Clause
### Changes for 1.1.1
[Fixed]
- Update code to eliminate Ruby 2.3 warning messages
- Fixed errors in post conditions of numeric types (incorrect number of
args)
- Added syntax highlighting in README.md as pointed out by jsyeo
- Comprehensive changes to types of Numeric subclass methods to make types
more
specific & accurate
- Changed superclasses of numeric classes to be `Numeric`
[Added]
- Testing for higher-order contracts
- Dependent types
- `/extras` directory, which contains random type tests for numeric subclass
method types
- `BigDecimal` added to alias `%real`
- Changelog added!