Type Refinement in Ruby

Abstract

This paper is about refinement in David Murphy Ruby. Ruby is a relational language whose main concern is structure; it describes how primitive relations are structured to form a larger relation. As such, it is admirably suited to the design of VLSI or highly parallel systems.

Design in Ruby usually proceeds by calculation. One starts with a highlevel relational description of a system, and gradually refines it towards an implementation. Refinement is achieved by the use of laws, — every Ruby combinator has many laws describing how it can be manipulated, introduced and eliminated, — and by introducing more information. A refinement step, then, involves calculating a new relation from a old one. Most of the Ruby literature concentrates on refinement using ‘built-in’ laws; this paper, in contrast, will focus on the matter of adding new information from outside the system. (Such information will capture pragmatic engineering decisions, and should be articulated as formally as possible, so that the consequences of those decisions can be elucidated.)

Typically, a Ruby specification will involve user-defined types; in writing the specification of an arithmetic chip, for instance, we may well need to deal with various rings of integers. These types must eventually be implemented in whatever the target medium provides: bits in VLSI; more primitive data-types in some parallel software applications. Hence, at some stage in the design, the user-defined types will need to be refined; a ring of integers, for instance, will often be implemented using fixed size words of bits. We will be concerned with describing how such type refinement information can be used properly. In particular, the later a type refinement happens in a design, the more global we want the effects to be. Thus we will show how to drag type constructors thorugh ‘plumbing’ circuitry to achieve this effect.