Migration Guide for the the Next Scripting Language

Abstract

This document describes the differences between the Next Scripting Language Framework and XOTcl 1. In particular, it presents a migration guide from XOTcl 1 to NX, and presents potential incompatibilities beween XOTcl 1.and XOTcl 2

Todo

Here comes general text, maybe partly from slides/paper …. TODO: Maybe we should not refer to ::nsf here, just to ::nx …

1. Differences Between XOTcl and NX

In general, the Next Scripting Language (NX) differs from XOTcl in the following respects:

The Next Scripting Language favors a stronger form of encapsulation than XOTcl. Calling the own methods or accessing the own instance variables is typographically easier and computationally faster than these operations on other objects. This behavior is achieved via resolvers an makes the definition of methods necessary in XOTcl obsolete. On the other hand, XOTcl is complete symmetrical in this respect.
The encapsulation of Next Scripting is still weak compared to languages like C++; a developer can still access e.g. other variables via some idioms, but this makes accesses to other objects variables explicit and requires more typing effort. Through the weak encapsulation a programmer should be encouraged to implement methods to provide access to instance variables.
The Next Scripting Language provides means of method protection.
The Next Scripting Language provides scripted init blocks for objects and classes (replacement for the somewhat dangerous dash "-" mechanism in XOTcl that allows to set variables and invoke methods upon object creation).
The Next Scripting Language provides much more orthogonal means to define, reuse and introspect scripted and C-implemented methods.
The Next Scripting Language provides an orthogonal framework for parametrization of methods and objects. While XOTcl 1 provided only value-checkers for non-positional arguments for methods, the Next Scripting Framework provides the same value checkers for positional argument of methods, as well as for object parameters (-parameter in XOTcl 1).
The Next Scripting Language has a much smaller interface (less predefined methods) than XOTcl:
- NX:
  
  Methods for Objects:
  
  19
  
  Methods for Classes:
  
  7
  
  Info methods for Objects:
  
  14
  
  Info method for Classes:
  
  6
- XOTcl:
  
  Methods for Objects:
  
  52
  
  Methods for Classes:
  
  24
  
  Info methods for Objects:
  
  25
  
  Info method for Classes:
  
  24

Below is a small, introductory example showing an implementation of a class Stack in NX and XOTcl. NX supports a block syntax, where the methods are defined during the creation of the class. The XOTcl syntax is slightly more redundant, since every definition of a method is a single toplevel command starting with the class name (also NX supports the style used in XOTcl). In NX, all methods are per default protected (XOTcl does not support protection). In NX methods are defined in the definition of the class via :method or :public method. In XOTcl methods are defined via the instproc method.

Another difference is the notation to refere to instance variables. In NX, instance variable are named with a single colon in the front. In XOTcl, instance variables are imported using instvar.

Stack example in NX	Stack example in XOTcl
Class create Stack { # # Stack of Things # :method init {} { set :things "" } :public method push {thing} { set :things [linsert ${:things} 0 $thing] return $thing } :public method pop {} { set top [lindex ${:things} 0] set :things [lrange ${:things} 1 end] return $top } }	# # Stack of Things # Class Stack Stack instproc init {} { my instvar things set things "" } Stack instproc push {thing} { my instvar things set things [linsert $things 0 $thing] return $thing } Stack instproc pop {} { my instvar things set top [lindex $things 0] set things [lrange $things 1 end] }

Stack example in NX

Stack example in XOTcl

Class create Stack {

   #
   # Stack of Things
   #

   :method init {} {
     set :things ""
   }

   :public method push {thing} {
      set :things [linsert ${:things} 0 $thing]
      return $thing
   }

   :public method pop {} {
      set top [lindex ${:things} 0]
      set :things [lrange ${:things} 1 end]
      return $top
   }
}

#
# Stack of Things
#

Class Stack

Stack instproc init {} {
   my instvar things
   set things ""
}

Stack instproc  push {thing} {
   my instvar things
   set things [linsert $things 0 $thing]
   return $thing
}

Stack instproc pop {} {
   my instvar things
   set top [lindex $things 0]
   set things [lrange $things 1 end]
}

2. Using XOTcl 2.0 and the Next Scripting Language in a Single Interpreter

In general, the Next Scripting Framework supports multiple object systems concurrently. Effectively, every object system has different base classes for creating objects and classes. Therefore, these object systems can have different different interfaces and names of built-in methods. Currently, the Next Scripting Framework is packaged with three object systems:

NX
XOTcl 2.0
TclCool

XOTcl 2 is highly compatible with XOTcl 1, the language NX is described below in more details, the language TclCool was introduced in Tip#279 and serves primarily an example of a small OO language.

A single Tcl interpreter can host multiple Next Scripting Object Systems at the same time. This fact makes migration from XOTcl to NX easier. The following example script shows to use XOTcl and NX in a single script:

Using Multiple Object Systems in a single Script

   namespace eval mypackage {

      package require XOTcl 2.0

      # Import XOTcl into the current namespace
      namespace import -force ::xotcl::*

      # Define a class using XOTcl
      Class C1
      C1 instproc foo {} {puts "hello world"}

      package require nx

      # Import NX into the current namespace;
      # "Class" will be after the command "::nx::Class"
      namespace import -force ::nx::*

      # Define a class using NX
      Class create C2 {
         :public method foo {} {puts "hello world"}
      }
   }

One could certainly create object or classes from the different object systems via fully qualified names (e.g. using e.g. ::xotcl::Class or ::nx::Class), but for migration for systems without explicit namespaces switching between the object systems eases migration. "Switching" between XOTcl and NX effectively means the load some packages (if needed) and to import either the base classes (Object and Class) of XOTcl or NX into the current namespace.

3. XOTcl Idioms in the Next Scripting Language

The following sections are intended for reader familiar with XOTcl and show, how certain language Idioms of XOTcl can be expressed in NX. In some cases, multiple possible realizations are listed

3.1. Defining Objects and Classes

When creating objects or classes, one should use the method create explicitly. In XOTcl, a default unknown handler was provided for classes, which create for every unknown method invocation an object/class with the name of the invoked method. This technique was convenient, but as well dangerous, since typos in method names lead easily to unexpected behavior. This default unknown handler is not provided in NX (but can certainly be provided as a one-liner in NX by the application).

XOTcl	Next Scripting Language
Class ClassName	Class create ClassName
Object ObjectName	Object create ObjectName

3.2. Defining Methods

In general, both XOTcl and NX support methods on the object level (per-object methods, i.e. methods only applicable to a single object) and on the class level (methods inherited to instances of the classes). While the naming in XOTcl tried to follow closely the Tcl tradition (using the term proc for functions/methods), NX uses the term method for defining scripted methods.

XOTcl uses the prefix inst to denote that methods are provided for instances, calling therefore scripted methods for instances instproc. This is certainly an unusual term. The approach with the name prefix has the disadvantage, that for every different kind of method, two names have to be provided (eg. proc and instproc, forward and instforward).

NX on the contrary uses the same term for defining inherited or object-specific methods. When the term (e.g. method) is used on a class, the method will be inherited (applicable to the instances of the class). When the term is used on an object, an object-specific method is defined. NX uses the method modifier class-object to defined a class-method (method for the class-object).

Furthermore, both XOTcl and NX distinguish between scripted methods (section 3.2.1) and C-defined methods (section 3.2.2). Section 3.2.3 introduces method protection, which is only supported by NX.

3.2.1. Scripted Methods Defined in the Init-block of a Class/Object or with Separate Calls

The following examples show the definition of a class and its methods in the init-block of a class (NX only), and the definition of methods via separate top level calls (XOTcl and NX).

XOTcl	Next Scripting Language
# Define method 'foo' and class-object method 'bar' # for a Class 'C' with separate toplevel commands Class C C instproc foo args {...} C proc bar args {...}	# Define method and class-object method # in the init-block of a class Class create C { :method foo args {...} :class-object method bar args {...} } # Define method and class-object method with separate # commands Class create C C method foo args {...} C class-object method bar args {...}
# Define object-specific method foo # for an object 'o' with separate commands Object o o set x 1 o proc foo args {...}	# Define class-object method and set instance variable # in the init-block of an object Object create o { set :x 1 :method foo args {...} } # Define class-object method and set instance variable # with separate commands Object create o o eval {set :x 1} o method foo args {...}

XOTcl

Next Scripting Language

# Define method 'foo' and class-object method 'bar'
# for a Class 'C' with separate toplevel commands

Class C
C instproc foo args {...}
C proc bar args {...}

# Define method and class-object method
# in the init-block of a class

Class create C {
  :method foo args {...}
  :class-object method bar args {...}
}

# Define method and class-object method with separate
# commands

Class create C
C method foo args {...}
C class-object method bar args {...}

# Define object-specific method foo
# for an object 'o' with separate commands

Object o
o set x 1
o proc foo args {...}

# Define class-object method and set instance variable
# in the init-block of an object

Object create o {
  set :x 1
  :method foo args {...}
}

# Define class-object method and set instance variable
# with separate commands

Object create o
o eval {set :x 1}
o method foo args {...}

3.2.2. Different Kinds of Methods

This section describes various kinds of methods. The different kinds of methods are defined via different method-defining methods, which are summarized in the following table for XOTcl and NX.

XOTcl	Next Scripting Language
# Methods for defining methods: # # proc # instproc # forward # instforward # parametercmd # instparametercmd # # All these methods return empty.	# Methods for defining methods: # # method # forward # alias # attribute # # All these methods return method-handles.

XOTcl

Next Scripting Language

# Methods for defining methods:
#
#     proc
#     instproc
#     forward
#     instforward
#     parametercmd
#     instparametercmd
#
# All these methods return empty.

# Methods for defining methods:
#
#     method
#     forward
#     alias
#     attribute
#
# All these methods return method-handles.

In addition to scripted methods (previous section) XOTcl supports forwarder (called forward and instforward) and accessor functions to variables (called parametercmd and instparametercmd). The accessor functions are used normally internally when object-specific parameters are defined (see Section 3.4).

In NX forwarders are called forward. NX does not provide an own method to define variable accessors, but uses the Next Scripting Framework primitive nsf::setter for it.

XOTcl	Next Scripting Language
Class C C instforward f1 ... C forward f2 ... Object o o forward f3 ...	# Define forwarder Class create C { :forward f1 ... :class-object forward f2 ... } Object create o { :forward f3 ... }
Class C C instparametercmd p1 C parametercmd p2 Object o o parametercmd p3	# Define setter and getter methods Class create C ::nsf::setter C p1 ::nsf::setter C -per-object p2 Object create o ::nsf::setter o p3

XOTcl

Next Scripting Language

Class C
C instforward f1 ...
C forward f2 ...

Object o
o forward f3 ...

# Define forwarder

Class create C {
  :forward f1 ...
  :class-object forward f2 ...
}

Object create o {
  :forward f3 ...
}

Class C
C instparametercmd p1
C parametercmd p2

Object o
o parametercmd p3

# Define setter and getter methods

Class create C
::nsf::setter C p1
::nsf::setter C -per-object p2

Object create o
::nsf::setter o p3

NX supports in contrary to XOTcl the method alias which can be used to register arbitrary Tcl commands or methods for an object or class under a provided method name. Aliases can be used to reuse a certain implementation in e.g. different object systems under potentially different names. In some respects aliases are similar to forwarders, but they do not involve forwarding overhead.

XOTcl	Next Scripting Language
# Method "alias" not available	# Define method aliases # (to scripted or non-scripted methods) Class create C { :alias a1 ... :class-object alias a2 ... } Object create o { :alias a3 ... }

3.2.3. Method Modifiers and Method Protection

NX supports the three method modifiers class-object, public and protected. All method modifiers can be written in front of every method defining command. The method modifier class-object is used to denote class-object specific methods (see above). The concept of method protection is new in NX.

XOTcl	Next Scripting Language
# Method modifiers # # "class-object", # "public", and # "protected" # # are not available	# Method modifiers orthogonal over all kinds of methods # # Method-definition-methods: # method, forward, alias, attribute Class create C { :/method-definiton-method/ ... :public /method-definiton-method/ ... :protected /method-definiton-method/ ... :class-object /method-definiton-method/ ... :protected class-object /method-definiton-method/ ... :public class-object /method-definiton-method/ ... }

XOTcl

Next Scripting Language

# Method modifiers
#
#   "class-object",
#   "public", and
#   "protected"
#
# are not available

# Method modifiers orthogonal over all kinds of methods
#
# Method-definition-methods:
#    method, forward, alias, attribute

Class create C {
  :/method-definiton-method/ ...
  :public /method-definiton-method/ ...
  :protected /method-definiton-method/ ...
  :class-object /method-definiton-method/ ...
  :protected class-object /method-definiton-method/ ...
  :public class-object /method-definiton-method/ ...
}

While XOTcl does not provide method protection, in NX, all methods are defined per default as protected.

NX allows to configure the default call protection in various ways. The command ::nx::configure defaultMethodCallProtection true|false can be used to set the default call protection for scripted methods, forwarder and aliases, while ::nx::configure defaultAttributeCallProtection true|false can set the default protection for attributes.

3.3. Resolvers

The Next Scripting Framework defines Tcl resolvers for method and variable names to implement object specific behavior. Within the bodies of scripted methods these resolver treat variable and function names starting with a colon : specially. In short, a colon-prefixed variable name refers to an instance variable, and a colon-prefixed function name refers to a method. The sub-sections below provide detailed examples.

Note that the resolvers of the Next Scripting Framework can be used in the XOTcl 2.* environment as well.

3.3.1. Invoking Methods

In XOTcl, a method of the same object can be invoked via my, or in general via using the name of the object in front of the method name.

In NX, the own methods are called via the method name prefixed with a single colon. The invocation of the methods of other objects is the same in NX and XOTcl.

XOTcl	Next Scripting Language
Class C C instproc foo args {...} C instproc bar args { my foo 1 2 3 ;# invoke own method o baz ;# invoke other objects method } Object o o proc baz {} {...}	Class create C { :method foo args {...} :method bar args { :foo 1 2 3 ;# invoke own method o baz ;# invoke other objects method } } Object create o { :method baz {} {...} }

XOTcl

Next Scripting Language

Class C
C instproc foo args {...}
C instproc bar args {
  my foo 1 2 3 ;# invoke own method
  o baz        ;# invoke other objects method
}
Object o
o proc baz {} {...}

Class create C {
  :method foo args {...}
  :method bar args {
     :foo 1 2 3 ;# invoke own method
     o baz      ;# invoke other objects method
  }
}
Object create o {
  :method baz {} {...}
}

3.3.2. Accessing Own Instance Variables from Method Bodies

In general, the Next Scripting Language favors the access to an objects’s own instance variables over variable accesses of other objects. This means that in NX it is syntactically easier to access the own instance variables. On the contrary, in XOTcl, the variable access to own and other variables are fully symmetric.

In XOTcl, the following approaches are used to access instance variables:

Import instance variables via instvar and access variables via $varName
Set or get instance variables via my set varName ?value? or other variable accessing methods registered on xotcl::Object such as append, lappend, incr, etc.
Register same-named accessor functions and set/get values of instance variables via my varName ?value?

In NX, the favored approach to access instance variables is to use the name resolvers, although it is as well possible to import variables via nx::var import or to check for the existence of instance variables via nx::var exists.

The following examples summary the use cases for accessing the own and other instance variables.

XOTcl	Next Scripting Language
Class C C instproc foo args { # Method scoped variable a set a 1 # Instance variable b my instvar b set b 2 # Global variable/namespaced variable c set ::c 3 }	Class create C { :method foo args {...} # Method scoped variable a set a 1 # Instance variable b set :b 2 # Global variable/namespaced variable c set ::c 3 } }
... instproc ... { my set /varName/ ?value? }	# Set own instance variable to a value via resolver # (preferred and fastest way) ... method ... { set /:newVar/ ?value? }
... instproc ... { my instvar /varName/ set /varName/ ?value? }	# Set own instance variable via variable import ... method ... { ::nx::var import [self] /varName/ set /varName/ ?value? }
... instproc ... { set /varName/ [my set /otherVar/] }	# Read own instance variable ... method ... { set /varName/ [set /:otherVar/] } ... method ... { set /newVar/ ${/:otherVar/} }
... instproc ... { my exists /varName/ }	# Test existence of own instance variable ... method ... { info /:varName/ } ... method ... { ::nx::var exists [self] /varName/ }

3.3.3. Accessing Instance Variables of other Objects

XOTcl	Next Scripting Language
/obj/ set /varName/ ?value?	# Set instance variable of object obj to a value via # resolver (preferred way: define attribute on obj) /obj/ eval [list set /:varName/ ?value?]
set /varName/ [/obj/ set /otherVar/]	# Read instance variable of object obj via resolver set /varName/ [/obj/ eval {set /:otherVar/}]
... instproc ... { /obj/ instvar /varName/ set /varName/ ?value? }	# Read instance variable of object /obj/ via import ... method ... { ::nx::var import /obj/ /varName/ set /varName/ ?value? }
/obj/ exists varName	# Test existence of instance variable of object obj /obj/ eval {info exists /:varName/} ::nx::var exists /obj/ /varName/

3.4. Parameters

While XOTcl 1 had very limited forms of parameters, XOTcl 2 and nx provide a generalized and highly orthogonal parameter handling with various kinds of value constraints. We devide the parameters into Object Parameters (parameters used for initializing objects and classes) and Method Parameters (parameters passed to methods). Furthermore, XOTcl 2 and NX support return value checker based on the same mechanisms.

3.4.1. Object Parameters

XOTcl	Next Scripting Language
# Object parameter specified as a list (short form) # "a" has no default, "b" has default "1" Class Foo -parameter {a {b 1}} # Create instance of the class Foo Foo f1 -a 0 # Object f1 has a == 0 and b == 1	# Object parameter specified as a list (short form) # "a" has no default, "b" has default "1" Class create Foo -attributes {a {b 1}} # Create instance of the class Foo Foo create f1 -a 0 # Object f1 has a == 0 and b == 1
# Parameters only available at class level Class C \ -parameter { x {y 1} }	# Define object attributes # (parameters for initializing objects) Class create C { :attribute x :attribute {y 1} :class-object attribute oa1 } Object create o { :attribute oa2 } Class create C \ -attributes { x {y 1} }
# Object parameter specified via slots Class Foo -slots { Attribute a Attribute b -default 1 } # Create instance of the class Foo Foo f1 -a 0 # Object f1 has a == 0 and b == 1	# Object parameter specified via attribute methods # (allow method modifieres and scripted configuration) Class create Foo { :attribute a :attribute {b 1} } # Create instance of the class Foo Foo create f1 -a 0 # Object f1 has a == 0 and b == 1
# Object parameter with configured slot, defining an attribute # specific type checker Class Person -slots { Attribute create sex -type "sex" { my proc type=sex {name value} { switch -glob $value { m* {return m} f* {return f} default {error "expected sex but got $value"} } } } }	# Object parameter with scripted definition, defining an attribute # specific type checker Class create Person { :attribute sex { :type "sex" :method type=sex {name value} { switch -glob $value { m* {return m} f* {return f} default {error "expected sex but got $value"} } } } }
# Predefined value constraints for parameter not available	# Predefined value constraints: # object, class, alnum, alpha, ascii, boolean, control, # digit, double, false, graph, integer, lower, print, # punct, space, true, upper, wordchar, xdigit # # User defined value constraints are possible. # All parameter value checkers can be turned on and off. # # Define a boolean attribute and an integer attribute with a # default Class create Foo -attributes { a:boolean {b:integer 1} } Class create Foo { :attribute a:boolean :attribute {b:integer 1} }
# Required parameter not available	# Required parameter: # Define a required attribute a and a required boolean # attribute b Class create Foo -attributes { a:required b:boolean,required } Class create Foo { :attribute a:required :attribute b:boolean,required }
# Multiplicity for parameter not available	# Parameter with multiplicity Class create Foo -attributes { {ints:integer,0..n ""} ;# list of integers, with default objs:object,1..n ;# non-empty list of objects obj:object,0..1 ;# single object, maybe empty } Class create Foo { :attribute {ints:integer,0..n ""} :attribute objs:object,1..n :attribute obj:object,0..1 }

3.4.2. Method Parameters

The method parameters specifications in XOTcl 1 were limited and allowed only value constraints for non positional arguments. NX and XOTcl 2 provide value constraints for all kind of method parameters. While XOTcl 1 required non-positional arguments to be listed in front of positional arguments, this limitation is lifted in XOTcl 2.

XOTcl	Next Scripting Language
# Define method foo with non-positional parameters # (x, y and y) and positional parameter (a and b) Class C C instproc foo {-x:integer -y:required -z a b} {....} C create c1 # invoke method foo c1 foo -x 1 -y a 2 3	# Define method foo with non-positional parameters # (x, y and y) and positional parameter (a and b) Class create C { :public method foo {-x:integer -y:required -z a b} {....} :create c1 } # invoke method foo c1 foo -x 1 -y a 2 3
# n.a.	# Define various forms of parameters not available in XOTcl 1 Class create C { # trailing (or interleaved) non-positional parameters :public method m1 {a b -x:integer -y} {....} # postional parameters with value constraints :public method m2 {a:integer b:boolean} {....} # optional postional parameter (trailing) :public method set {varName value:optional} {....} # parameter with multiplicty :public method m3 {-objs:object,1..n c:class,0..1} {....} # In general, the same list of value constraints as for # object parameter is available (see above). # # User defined value constraints are possible. # All parameter value checkers can be turned on and off. }

XOTcl

Next Scripting Language

# Define method foo with non-positional parameters
# (x, y and y) and positional parameter (a and b)

Class C
C instproc foo {-x:integer -y:required -z a b} {....}
C create c1

# invoke method foo
c1 foo -x 1 -y a 2 3

# Define method foo with non-positional parameters
# (x, y and y) and positional parameter (a and b)

Class create C {
   :public method foo {-x:integer -y:required -z a b} {....}
   :create c1
}
# invoke method foo
c1 foo -x 1 -y a 2 3

# n.a.

# Define various forms of parameters not available in XOTcl 1

Class create C {
   # trailing (or interleaved) non-positional parameters
   :public method m1 {a b -x:integer -y} {....}

   # postional parameters with value constraints
   :public method m2 {a:integer b:boolean} {....}

   # optional postional parameter (trailing)
   :public method set {varName value:optional} {....}

   # parameter with multiplicty
   :public method m3 {-objs:object,1..n c:class,0..1} {....}

   # In general, the same list of value constraints as for
   # object parameter is available (see above).
   #
   # User defined value constraints are possible.
   # All parameter value checkers can be turned on and off.
}

3.4.3. Return Value Checkers

Return value checker are a functionality that was not yet available in XOTcl 1. A return value checker assures that a method returns always a parameter of a certain value. Return value checkers can be defined on all forms of methods. Like for other value checkers, return value checkers can be turned on and off.

XOTcl	Next Scripting Language
# n.a.	# Define method foo with non-positional parameters # (x, y and y) and positional parameter (a and b) Class create C { # Define method foo which returns an integer value :method foo -returns integer {-x:integer} {....} # Define an alias for the Tcl command ::incr # and assure, it always returns in integer :alias incr -returns integer ::incr # Define a forwarder that has to return integer :forward ++ -returns integer ::expr 1 + # Define a method that has to return a non-empty # list of objects :public class-object method instances {} -returns object,1..n { return [:info instances] } }

XOTcl

Next Scripting Language

# n.a.

# Define method foo with non-positional parameters
# (x, y and y) and positional parameter (a and b)

Class create C {
   # Define method foo which returns an integer value
   :method foo -returns integer {-x:integer} {....}

   # Define an alias for the Tcl command ::incr
   # and assure, it always returns in integer
   :alias incr -returns integer ::incr

   # Define a forwarder that has to return integer
   :forward ++ -returns integer ::expr 1 +

  # Define a method that has to return a non-empty
  # list of objects
  :public class-object method instances {} -returns object,1..n {
    return [:info instances]
   }
}

3.5. Interceptors

3.5.1. Register Mixin Classes and Mixin Guards

XOTcl	Next Scripting Language
/cls/ instmixin ... /cls/ instmixinguard mixin /condition/	# Register per-class mixin and guard for a class /cls/ mixin ... /cls/ mixin guard mixin /condition/
/cls/ mixin ... /cls/ mixin guard mixin /condition/	# Register per-object mixin and guard for a class /cls/ class-object mixin ... /cls/ class-object mixin guard mixin /condition/
/obj/ mixin ... /obj/ mixinguard mixin /condition/	# Register per-object mixin and guard for an object /obj/ mixin ... /obj/ mixin guard mixin /condition/

XOTcl

Next Scripting Language

/cls/ instmixin ...
/cls/ instmixinguard mixin /condition/

# Register per-class mixin and guard for a class

/cls/ mixin ...
/cls/ mixin guard mixin /condition/

/cls/ mixin ...
/cls/ mixin guard mixin /condition/

# Register per-object mixin and guard for a class

/cls/ class-object mixin ...
/cls/ class-object mixin guard mixin /condition/

/obj/ mixin ...
/obj/ mixinguard mixin /condition/

# Register per-object mixin and guard for an object

/obj/ mixin ...
/obj/ mixin guard mixin /condition/

3.5.2. Register Filters and Filter Guards

XOTcl	Next Scripting Language
/cls/ instfilter ... /cls/ instfilterguard filter /condition/	# Register per-class filter and guard for a class /cls/ filter ... /cls/ filter guard filter /condition/
/cls/ filter ... /cls/ filterguard ...	# Register per-object filter and guard for a class /cls/ class-object filter ... /cls/ class-object filter guard filter /condition/
/obj/ filter ... /obj/ filterguard filter /condition/	# Register per-object filter and guard for an object /obj/ filter ... /obj/ filter guard filter /condition/

XOTcl

Next Scripting Language

/cls/ instfilter ...
/cls/ instfilterguard filter /condition/

# Register per-class filter and guard for a class

/cls/ filter ...
/cls/ filter guard filter /condition/

/cls/ filter ...
/cls/ filterguard ...

# Register per-object filter and guard for a class

/cls/ class-object filter ...
/cls/ class-object filter guard filter /condition/

/obj/ filter ...
/obj/ filterguard filter /condition/

# Register per-object filter and guard for an object

/obj/ filter ...
/obj/ filter guard filter /condition/

3.6. Introspection

3.6.1. List methods defined by objects

XOTcl	Next Scripting Language
/obj/ info commands ?pattern?	/obj/ info methods ?pattern?
/obj/ info parametercmd ?pattern?	/obj/ info methods -methodtype setter ?pattern?
/obj/ info procs ?pattern?	/obj/ info methods -methodtype scripted ?pattern?
# n.a.	/obj/ info methods -methodtype alias ?pattern?
# n.a.	/obj/ info methods -methodtype forwarder ?pattern?
# n.a.	/obj/ info methods -methodtype object ?pattern?
# n.a.	/obj/ info methods -callprotection public\|protected ...

3.6.2. List methods defined by classes

XOTcl	Next Scripting Language
/cls/ info instcommands ?pattern?	/cls/ info methods ?pattern?
/cls/ info instparametercmd ?pattern?	/cls/ info methods -methodtype setter ?pattern?
/cls/ info instprocs ?pattern?	/cls/ info methods -methodtype scripted ?pattern?
# n.a.	/cls/ info methods -methodtype alias ?pattern?
# n.a.	/cls/ info methods -methodtype forwarder ?pattern?
# n.a.	/cls/ info methods -methodtype object ?pattern?
# n.a.	/cls/ info methods -callprotection public\|protected ...

3.6.3. List class object specific methods

XOTcl	Next Scripting Language
/cls/ info commands ?pattern?	/cls/ class-object info methods ?pattern?
/cls/ info parametercmd ?pattern?	/cls/ class-object info methods -methodtype setter ?pattern?
/cls/ info procs ?pattern?	/cls/ class-object info methods -methodtype scripted ?pattern?
# n.a.	/cls/ class-object info methods -methodtype alias ?pattern?
# n.a.	/cls/ class-object info methods -methodtype forwarder ?pattern?
# n.a.	/cls/ class-object info methods -methodtype object ?pattern?
# n.a.	/cls/ class-object info methods -callprotection public\|protected ...

3.6.4. List callable methods

XOTcl	Next Scripting Language
/obj/ info methods ?pattern?	/obj/ info lookup methods ... ?pattern? # Returns list of method names
# n.a.	# List only application specific methods /obj/ info lookup methods -source application ... ?pattern? # Returns list of method names
# Options for 'info methods' # # -incontext # -nomixins	# Options for 'info lookup methods' # # -source ... # -callprotection ... # -incontext # -methodtype ... # -nomixins
# n.a.	# List slot objects defined for obj /obj/ info lookup slots # Returns list of slot objects

3.6.5. List object/class where some method is defined

XOTcl	Next Scripting Language
/obj/ procsearch /methodName/	/obj/ info lookup method /methodName/ # Returns method-handle
/obj/ filtersearch /methodName/	/obj/ info lookup filter /methodName/ # Returns method-handle

3.6.6. List definition of scripted methods defined by classes

XOTcl	Next Scripting Language
/cls/ info instbody /methodName/	/cls/ info method body /methodName/
/cls/ info instargs /methodName/	/cls/ info method args /methodName/
/cls/ info instnonposargs /methodName/	/cls/ info method parameter /methodName/
/cls/ info instdefault /methodName/	/cls/ info instdefault /methodName/
/cls/ info instpre /methodName/	/cls/ info method precondition /methodName/
/cls/ info instpost /methodName/	/cls/ info method postcondition /methodName/
# n.a.	/cls/ info method definition /methodName/

3.6.7. List definition of scripted object specific methods

XOTcl	Next Scripting Language
/obj/ info body /methodName/	/obj/ info method body /methodName/
/obj/ info args /methodName/	/obj/ info method args /methodName/
/obj/ info nonposargs /methodName/	/obj/ info method parameter /methodName/
/obj/ info default /methodName/	/obj/ info method parameter /methodName/
/obj/ info pre /methodName/	/obj/ info method precondition /methodName/
/obj/ info pre /methodName/	/obj/ info method precondition /methodName/
/obj/ info post /methodName/	/obj/ info post /methodName/
# n.a.	/obj/ info method definition /methodName/

For definition of class object specific methods, use modifier class-object as shown in examples above.

3.6.8. List Filter or Mixins

XOTcl	Next Scripting Language
/obj/ info filter ?-guards? ?-order? ?pattern?	# ... info filter methods -order ... returns method-handles # instead of triples (applies to all three variants) /obj/ info filter methods ?-guards? ?-order? ?pattern?
/obj/ info filterguard /name/	/obj/ info filter guard /name/
/cls/ info filter ?-guards? ?-order? ?pattern?	/cls/ class-object info filter methods ?-guards? ?-order? ?pattern?
/cls/ info filterguard /name/	/cls/ class-object info filter guard /name/
/cls/ info instfilter ?-guards? ?-order? ?pattern?	/cls/ info filter methods ?-guards? ?-order? ?pattern?
/cls/ info instfilterguard /name/	/cls/ info filter guard /name/
/obj/ info mixin ?-guards? ?-order? ?pattern?	/obj/ info mixin classes ?-guards? ?-order? ?pattern?
/obj/ info mixinguard /name/	/obj/ info mixin guard /name/
/cls/ info mixin ?-guards? ?-order? ?pattern?	/cls/ class-object info mixin classes ?-guards? ?-order? ?pattern?
/cls/ info mixinguard /name/	/cls/ class-object info mixin guard /name/
/cls/ info instmixin ?-guards? ?-order? ?pattern?	/cls/ info mixin classes ?-guards? ?-order? ?pattern?
/cls/ info instmixinguard /name/	/cls/ info mixin guard /name/

3.6.9. List definition of methods defined by aliases, setters or forwarders

XOTcl	Next Scripting Language
# n.a.	/obj/ info method definition /methodName/
# n.a.	/cls/ info method definition /methodName/

3.6.10. List fully qualified name of method

XOTcl	Next Scripting Language
# n.a.	/obj/ info method handle /methodName/
# n.a.	/cls/ ?class-object? info method handle /methodName/

3.6.11. List type of a method

XOTcl	Next Scripting Language
# n.a.	/obj/ info method type /methodName/
# n.a.	/cls/ ?class-object? info method type /methodName/

3.6.12. List the scope of mixin classes

XOTcl	Next Scripting Language
/cls/ info mixinof ?-closure? ?pattern?	# List objects, where /cls/ is a per-object mixin /cls/ info mixinof -scope object ?-closure? ?pattern?
/cls/ info instmixinof ?-closure? ?pattern?	# List classes, where /cls/ is a per-class mixin /cls/ info mixinof -scope class ?-closure? ?pattern?
# n.a.	# List objects and classes, where /cls/ is # either a per-object or a per-class mixin /cls/ info mixinof -scope all ?-closure? ?pattern? /cls/ info mixinof ?-closure? ?pattern?

XOTcl

Next Scripting Language

/cls/ info mixinof ?-closure? ?pattern?

# List objects, where /cls/ is a per-object mixin

/cls/ info mixinof -scope object ?-closure? ?pattern?

/cls/ info instmixinof ?-closure? ?pattern?

# List classes, where /cls/ is a per-class mixin

/cls/ info mixinof -scope class ?-closure? ?pattern?

# n.a.

# List objects and classes, where /cls/ is
# either a per-object or a per-class mixin

/cls/ info mixinof -scope all ?-closure? ?pattern?

/cls/ info mixinof ?-closure? ?pattern?

3.6.13. Check properties of object and classes

XOTcl	Next Scripting Language
/obj/ istype /sometype/	/obj/ info has type /sometype/
/obj/ ismixin /cls/	/obj/ info has mixin /cls/
/obj/ isclass ?/cls/?	/obj/ info is class
/obj/ ismetaclass /cls/	/obj/ info is metaclass
# n.a.	/obj/ info is baseclass
/obj/ isobject /obj/	::nsf::isobject /obj/

3.6.14. Call-stack Introspection

XOTcl	Next Scripting Language
self	current current object
self class	current class
self proc	current method
self callingclass	current currentclass
self callingobject	current callingobject
self callingproc	current callingmethod
self calledclass	current calledclass
self calledproc	current calledmethod
self isnextcall	current isnextcall
self next	# Returns method-handle current next
self filterreg	# Returns method-handle current filterreg
self callinglevel	current callinglevel
self activelevel	current activelevel

3.7. Other Predefined Methods

XOTcl	Next Scripting Language
/obj/ requireNamespace	/obj/ require namespace

3.8. Dispatch, Aliases, etc.

todo: to be done or omitted

3.9. Assertions

XOTcl	Next Scripting Language
/obj/ check /checkoptions/	::nsf::assertion /obj/ check /checkptions/
/obj/ info check	::nsf::assertion /obj/ check
/obj/ invar /conditions/	::nsf::assertion /obj/ object-invar /conditions/
/obj/ info invar	::nsf::assertion /obj/ object-invar
/cls/ instinvar /conditions/	::nsf::assertion /cls/ class-invar /conditions/
/cls/ info instinvar	::nsf::assertion /cls/ class-invar
/cls/ invar /conditions/	::nsf::assertion /cls/ object-invar /conditions/
/cls/ info invar	::nsf::assertion /cls/ object-invar

3.10. Method Protection

As described above, NX supports method protection via the method modifiers protected and public. A protected method can be only called from an object of that class, while public methods can be called from every object. The method protection can be used to every kind of method, such as e.g. scripted methods, aliases, forwarders, or attributes. For invocations, the most specific definition (might be a mixin) is used for determining the protection.

4. Incompatibilities between XOTcl 1 and XOTcl 2

4.1. Resolvers

The resolvers (variable resolvers, function resolvers) of the Next Scripting Framework are used as well within XOTcl 2. When variable names or method names starting with a single colon are used in XOTcl 1 scripts, conflicts will arise with the resolver. These names must be replaced.

4.2. Parameters

The following changes for parameters could be regarded as bug-fixes.

4.2.1. Parameter usage without a value

In XOTcl 1, it was possible to call a parameter method during object creation via the -param without a value (in the example below -x.

Class Foo -parameter {x y}
Foo f1 -x -y 1

Such cases are most likely mistakes. All parameter configurations in XOTcl 2 require an argument.

4.2.2. Ignored Parameter definitions

In XOTcl 1, a more specific parameter definition without a default was ignored when a more general parameter definition with a default was present. In the example below, the object b1 contained in XOTcl 1 incorrectly the parameter x (set via default from Foo), while in XOTcl 2, the variable won’t be set.

Class Foo -parameter {{x 1}}
Class Bar -superclass Foo -parameter x
Bar b1

4.3. Calling objects via method interface

Since the Next Scripting Framework supports the so-called ensemble objects, which ease the definition of sub-methods substantially, objects registered as methods have different semantics. In XOTcl 1, it was possible to call e.g. a method foo of the slot object Foo::slot::ints via the following two interfaces the same way:

Foo::slot::ints foo ...
Foo slot ints foo ...

In the Next Scripting Framework, only the first form has the same semantic as before. In the second form (invocation of objects via method interface) has now the ensemble object semantics. This means that in the second case the current object of method foo is now Foo instead of ints.

4.4. Slots

All slot objects (also XOTcl slot objects) are now next-scripting objects of baseclass ::nx::Slot. The name of the experimental default-setter initcmd was changed to defaultcmd. Code directly working on the slots objects has to be adapted.

4.5. Obsolete commands

Parameter-classes were rarely used and have been replaced by the more general object parameterization. Therefore, cl info parameterclass has been removed.

4.6. Stronger Checking

The Next Scripting Framework performs stronger checking than XOTcl 1 For example, the requiredness of slots in XOTcl 1 was just a comment, while XOTcl 2 enforces it.

4.7. Exit Handlers

The exit hander interface changed from a method of ::xotcl::Object into the Tcl command ::nsf::exithandler:

::nsf::exithandler set|get|unset ?arg?

Methods for Objects:	19
Methods for Classes:	7
Info methods for Objects:	14
Info method for Classes:	6