Types¶

Type Constraints¶

Data member values can be constrained to hold only particular types of objects. To do this, follow the data member name with two colons (::) and then a type or trait name. When a data member is constrained, it cannot be assigned any value that does not fit the constraint. The following type constrains “firstName” and “lastName” to be string objects and “age” to be an integer value:

define person => type {
   data firstName::string, lastName::string
   data age::integer
}

Default Values¶

Data members can be given default values. When a type instance is first created, before it can be otherwise used, its data members are assigned their default values. A default value can be any single expression. The following type definition uses both type constraints and default values for “firstName” and “lastName”, but just a default value for “age”:

define person => type {
   data firstName::string = '', lastName::string = ''
   data age = 0
}

Accessing Data Members¶

Data members can be accessed from within the methods of a type by targeting the current type instance using the keyword self and the target operator (->) followed by the name of the data member between single quotes. The following expression would set the value of the data member “age” to “36”:

self->'age' = 36

The following expression produces the value of the “age” data member:

self->'age'
// => 36

Equivalently, Lasso supports a shortcut syntax for targeting “self” by using a single period. The examples above could be rewritten using a period in place of self->.

.'age' = 36

.'age'
// => 36

All of the data members in a type are private. This means that a data member can only be directly accessed using either of the above syntaxes; only when “self” is the target object. Optionally, data members can be exposed to the outside world. The following section describes how getters and setters can access data member values from outside of the owning type.

Parent Section¶

The parent section names the parent that the type being defined is to inherit from. For example, the person type can inherit from the entity type by naming it in its parent section. Each person object that gets created will then possess all of the data members and methods found in the entity type, whatever those might be.

define person => type {
   parent entity
}

Only one parent type can be listed. The parent section can appear only once in a type expression. While it can be placed anywhere in the type expression, it is recommended that you place it at the top.

The following code defines two simple types: one and two. Type two inherits from type one. Notice that the second method is overridden by the second type, but the first method is not.

define one => type {
   public first() => 'alpha'
   public second() => 'beta'
   public last() => frozen 'omega'
}

define two => type {
   parent one
   public second() => 'gamma'
   public last() => 'zeta'
}

When the first method of a two object is called, the value “alpha” will be returned since it is automatically calling the method from the parent type. The second method returns “gamma” since it is calling the overridden method from type two. The last method always returns “omega” because the parent type defined it with the frozen keyword.

two->first
// => alpha
two->second
// => gamma
two->last
// => omega

Accessing Inherited Methods¶

Sometimes it is necessary to call “down” to an inherited method. A method inherited from an ancestor (any of the parents down the chain to null) can be accessed by using the inherited keyword followed by the target operator (->) followed by the method call (name and any parameters).

In the following example, the method third is defined to call the inherited method second. The method from type two will be bypassed in favor of the corresponding method from type one.

define one => type {
   public first() => 'alpha'
   public second() => 'beta'
}

define two => type {
   parent one
   public second() => 'gamma'
   public third() => inherited->second
}

two->third
// => beta

Equivalently, Lasso supports a shortcut syntax for targeting “inherited” by using two periods, which can be used to access the methods of a parent type. The example above can be rewritten using .. in place of inherited->.

define two => type {
   parent one
   public second() => 'gamma'
   public third() => ..second
}

Trait Section¶

Every type has a single trait which may be composed of other subtraits. A type inherits all of the methods that its trait defines, provided that the type implements the requirements for the trait. For example, a type must be serializable for it to be stored in a session, which means importing the trait_serializable trait. (See the Traits chapter for a complete description of how traits are created.)

The trait section of a type expression can import one or more other traits. These traits are combined to form the trait for the type. The following code shows a type definition that imports the trait_array and trait_map traits:

define mytype => type {
   trait {
      import trait_array, trait_map
   }
}

A trait section can appear anywhere within a type expression, but can appear only once.

onCreate¶

Many types allow one or more parameters to be provided when a new object is created in order to customize the object before it is used. A type can specify its own type creators by defining one or more methods named onCreate. When a new object is created, the onCreate method corresponding to the given parameters is immediately called before the new object is returned to the user. Each onCreate must be a public member method.

To illustrate, the following type definition defines an onCreate method that requires three parameters: firstName, lastName, and birthdate. These parameters correspond to the data members of the type and allow setting their values when the object is first created. The creator simply assigns the parameter values to the data members.

define person => type {
   data firstName::string, lastName::string
   data birthdate::date

   public onCreate(firstName::string, lastName::string, birthdate::date) => {
      .'firstName' = #firstName
      .'lastName' = #lastName
      .'birthdate' = #birthdate
   }
}

To create an instance of this type, the creator must be called with the required parameters. The following code will create a new instance of the person type:

local(myperson) = person('Cathy', 'Cunningham', date('1/1/1974'))

Note that when a creator has been specified, the default creator, which requires no parameters, is not automatically provided. Lasso will not supply a default type creator when the author has included their own. Also note that if a type overrides its parent’s creator, it needs to include a call to the parent’s creator method, passing on any arguments as required.

public onCreate(...) => ..onCreate(: #rest)

Many type creators can be defined by specifying multiple onCreate methods. The following type defines three type creators. The first permits person objects to be created with no parameters; the second, with first and last names; and the third, with first and last names and a birthdate.

define person => type {
   data firstName::string, lastName::string
   data birthdate::date

   public onCreate() => {}
   public onCreate(firstName, lastName) => {
      .'firstName' = string(#firstName)
      .'lastName' = string(#lastName)
   }
   public onCreate(
            firstName::string,
            lastName::string,
            birthdate::date) => {
      .'firstName' = #firstName
      .'lastName' = #lastName
      .'birthdate' = #birthdate
   }
}

asString¶

The asString method is called when an object is expressed as a string. By default, a type instance will simply output the name of the object’s type. Overriding this method allows a type to control how it is output. The following code defines a simple type that outputs a greeting when its asString method is called:

define mytype => type {
   public asString() => 'Hello World!'
}

mytype
// => Hello World!

onCompare¶

The onCompare method is called whenever an object is compared against another object. This includes when using the equality (==), and inequality (!=) operators, and when objects are compared for ordinality using any of the relative equality operators (<, <=, >, >=). It’s also called via null->onCompareStrict, which first verifies that the two objects are the same type, when using the strict equality (===) and inequality (!==) operators.

An onCompare method must accept one parameter and must return an integer value.

public onCompare(rhs)::integer

If the parameter is equal to the current type instance then a value of “0” should be returned. If the current type instance is less than the parameter then an integer less than zero should be returned, e.g. “-1”. If the current type instance is greater than the parameter then an integer greater than zero should be returned, e.g. “1”.

For example, the following person type has an onCompare method that gives person objects the ability to compare themselves with each other:

define person => type {
   data public firstName::string,
         public lastName::string

   public onCompare(other::person) => {
      .firstName != #other->firstName ?
         return .firstName < #other->firstName ? -1 | 1
      .lastName != #other->lastName ?
         return .lastName < #other->lastName ? -1 | 1
      return 0
   }

   public onCreate(firstName::string, lastName::string) => {
      .firstName = string(#firstName)
      .lastName = string(#lastName)
   }
}

Given the above type definition, the following examples use the onCompare method behind the scenes to provide the ability to compare persons:

person('Bob', 'Barker') == person('Bob', 'Barker')
// => true

person('Bob', 'Barker') == person('Bob', 'Parker')
// => false

Multiple onCompare methods can be provided, each specialized to compare against particular object types. For example, an integer type would want to permit itself to be compared against other integer objects, but it should also want to be comparable to decimal objects. Such an integer type would have one onCompare method for integer objects and another for decimal objects. This example also shows how the onCompare method can be manually called on objects. In this case, the “value” data member is responsible for doing the actual comparisons, so its onCompare method is called and the value returned.

define myint => type {
   data private value

   public onCompare(i::integer) => .value->onCompare(#i)
   public onCompare(d::decimal) => .value->onCompare(integer(#d))
}

contains¶

The contains method is called whenever an object is compared using the contains (>>) or not contains (!>>) operators. A contains method definition should accept one parameter and must return a boolean value, either “true” or “false”.

public contains(rhs)::boolean

If the parameter is contained within the current type instance (using whatever logic makes sense for the type) then a value of “true” should be returned; otherwise, a value of “false” should be returned.

For example, the type odds below overrides the contains operators so that odds >> 3 returns “true” and odds >> 4 returns “false”.

define odds => type {
   public contains(rhs::integer)::boolean => {
      return #rhs % 2 == 1
   }
}

Other types that implement their own contains methods include array and map, which search their contained objects for a match before returning “true” or “false”.

invoke¶

The invoke method is called whenever an object is invoked by applying parentheses to it. By default, invoking an object produces a copy of the invoked object. However, objects can add their own invoke methods to alter this behavior. The following code shows how an instance of the person type might be invoked:

define person => type {
   data
      public firstName::string,
      public lastName::string

   public invoke() => .firstName + ' ' + .lastName + ' was invoked!'
   public onCreate(firstName::string, lastName::string) => {
      .firstName = string(#firstName)
      .lastName = string(#lastName)
   }
}

The following shows how a person object would be invoked, by either directly calling the invoke method or by applying parentheses:

local(per) = person('Bob', 'Parker')

#per()
// => Bob Parker was invoked!

#per->invoke
// => Bob Parker was invoked!

_unknowntag¶

Implementing the _unknowntag method allows a type to handle requests for methods that it does not have. When a search for a member method fails, the system will call the _unknowntag method if it is defined. The originally sought method name is available by calling method_name.

The following example creates a type whose only member method is _unknowntag, which returns the name of the called method:

define echo_method => type {
   public _unknowntag => method_name->asString
}

echo_method->rhino
// => rhino

Overloading Arithmetical Operators¶

An arithmetical operator is overloaded by defining a member method whose name is the same as the operator symbol. The method must accept one parameter and return an appropriate value. The type instance should not be modified by these operations.

public +(rhs)
public -(rhs)
public *(rhs)
public /(rhs)
public %(rhs)

The following example provides a full set of arithmetical operators for the myint type:

define myint => type {
   data private value

   public onCreate(value = 0) => { .value = #value }
   public asString() => string(.value)
   public +(rhs::integer) => myint(.value + #rhs)
   public -(rhs::integer) => myint(.value - #rhs)
   public *(rhs::integer) => myint(.value * #rhs)
   public /(rhs::integer) => myint(.value / #rhs)
   public %(rhs::integer) => myint(.value % #rhs)
}

myint(9) + 5 * 40
// => 209

Overloading Equality Operators¶

See the section on the onCompare method for information about how to overload the equality operators (==, !=, <, <=, >, >=, ===, !==).

Overloading Containment Operators¶

See the section on the contains method for information about how to overload the containment operators (>>, !>>).