Migration Guide for the the Next Scripting Language

... general text, maybe partly from slides/paper .... TODO: Maybe we should not refer to ::nsf here and import instead the "needed" commands into ::nx namespace.

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

The Next Scripting Language has a much smaller interface (less predefined methods) than XOTcl.
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 weak; a programmer can still access e.g. other variables via some idioms, but this makes these accesses implicit and is 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 (XOTcl used the dash "-" mechanisms to set variables and invoke methods upon object creation).
The Next Scripting Language provides much more orthogonal means to define and name scripted and c-implemented methods.
The Next Scripting Language provides an orthogonal framework for parametrization of methods and objects.

Class create Stack {

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

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

Figure 1: Stack example in the Next Scripting Language

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]
   return $top
}

Figure 2: Stack example in XOTcl

Using XOTcl 2.0 and the Next Scripting Language in the Next Scripting Framework 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 supports primarily XOTcl 2.0 (highly compatible with XOTcl 1.*) and the Next Scripting Language (XOTcl provides about twice as many predefined built-in methods compared to the Next Scripting Language).

A single Tcl interpreter can host both, XOTcl and the Next Scripting Language at the same time. This makes migration from XOTcl to Next easier. The following example script shows to use in a single script XOTcl and Next:

   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"}

      # Import Next into the current namespace
      namespace import -force ::nx::*

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

"Switching" between XOTcl and Next effectively means the load some packages (if needed) and to import either the base classes (Object and Class) of XOTcl or Next into the current namespace.

XOTcl Idioms in the Next Scripting Language

Defining Objects and Classes

XOTcl	Next Scripting Language
`Class ClassName`	`Class create ClassName`
`Object ObjectName`	`Object create ObjectName`
`::xotcl::Class ClassName`	`::nx::Class create ClassName`
`::xotcl::Object ObjectName`	`::nx::Object create ObjectName`

Defining Methods

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

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

Define Different Kinds of Methods

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 # setter # alias # attribute # # All these methods return method-handles.
`Class C C instproc foo args {...} C proc bar args {...} Object o o proc baz args {...}`	# Define scripted methods `Class create C { :method foo args {...} :object method bar args {...} } Object create o { :method baz args {...} }`
`Class C C instforward f1 ... C forward f2 ... Object o o forward f3 ...`	# Define forwarder `Class create C { :forward f1 ... :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 { :setter p1 ?value_constraint? :object setter p2 ?value_constraint? } Object create o { :setter p3 ?value_constraint? }`
# Method "alias" not available	# Define method aliases # (to scripted or non-scripted methods) `Class create C { :alias a1 ... :object alias a2 ... } Object create o { :alias a3 ... }`
# 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} :object attribute oa1 } Object create o { :attribute oa2 }`

Method Modifiers and Method Protection

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

Resolvers

The Next Scripting Framework defines Tcl resolvers for method and variable names to refer to object specific behavior. Withing method bodies 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 Next resolvers can be used in the XOTcl 2.* environment as well.

Invoking Methods

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 {} {...} }`

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. On the contrary, in XOTcl, the variable access to own and other variables are completely symmetric.

In Next Scripting, access to local variables are performed via primarily via name resolvers, but using the standard tcl commands (like e.g. set, incr, append, info exists, etc.). In XOTcl, it is common to provide same-named methods registered on ::xotcl::Object for such purposes. This is one of the reasons, why the Next Scripting Language has a much smaller interface (less predefined methods). It is possible for an application program to register XOTcl-like methods in the Next Scripting Language via the primitives of the Next Scripting Framework.

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
# (prefered and fastest way)

... method ... {    set :newVar value }

... instproc ... {    my instvar newVar    set newVar value } # Set own instance variable via variable import

... method ... {    ::nx::var import [self] varname    set varname value }

... instproc ... {    set newVar [my set otherVar] } # Read own instance variable

... method ... {    set newVar [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 }

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 # (prefered and fastest way) `... method ... { set :newVar value }`
`... instproc ... { my instvar newVar set newVar value }`	# Set own instance variable via variable import `... method ... { ::nx::var import [self] varname set varname value }`
`... instproc ... { set newVar [my set otherVar] }`	# Read own instance variable `... method ... { set newVar [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 }`

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 (prefered way: define setter method on obj) `obj eval [list set :varname value]`
`set newVar [obj set otherVar]`	# Read instance variable of object obj via resolver `set newVar [obj eval {set :otherVar}]`
`... instproc ... { obj instvar newVar set newVar value }`	# Read instance variable of object obj via import `... method ... { ::nx::var import obj newVar set newVar value }`
`obj exists varname`	# Test existence of instance variable of object obj `obj eval {info exists :varname}` `::nx::var exists obj varname`

Object Parameters

XOTcl	Next Scripting Language
`Class Foo -parameter {a {b 1}} # Create instance of the class Foo Foo f1 -a 0 # Object f1 has a == 0 and b == 1 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`	`Class create Foo -parameter {a {b 1}} # Create instance of the class Foo Foo create f1 -a 0 # Object f1 has a == 0 and b == 1 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`
`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"} } } } }`	`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 Class create Foo -parameter { a:boolean {b:integer 1} } Class create Foo { :attribute a:boolean :attribute {b:integer 1} }`
# Required parameter not available	`# Required parameter Class create Foo -parameter { a:boolean,required {b:integer 1} } Class create Foo { :attribute a:boolean,required :attribute {b:integer 1} }`
# Multivalued parameter not available	`# Required parameter Class create Foo -parameter { ... ints:integer,multivalued {objs:object,multivalued ""} } Class create Foo { ... :attribute ints:integer,multivalued :attribute {objs:object,multivalued ""} }`

## allowempty

Method Parameters

Interceptors

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 object mixin ...` `cls 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`

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 object filter ...` `cls 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`

Introspection

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 ...`

List methods defined by classes

`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 ...`

List class object specific methods

`cls info commands ?pattern?`	`cls object info methods ?pattern?`
`cls info parametercmd ?pattern?`	`cls object info methods -methodtype setter ?pattern?`
`cls info procs ?pattern?`	`cls object info methods -methodtype scripted ?pattern?`
n.a.	`cls object info methods -methodtype alias ?pattern?`
n.a.	`cls object info methods -methodtype forwarder ?pattern?`
n.a.	`cls object info methods -methodtype object ?pattern?`
n.a.	`cls object info methods -callprotection public\|protected ...`

List callable methods

XOTcl	Next Scripting Language
`obj info methods ?pattern?`	`obj info callable methods ... ?pattern? # Returns list of method names`
n.a.	`# List only application specific methods` `obj info callable methods -application ... ?pattern? # Returns list of method names`
`# Options for 'info methods' # # -incontext # -nomixins`	`# Options for 'info callable methods' # # -application # -callprotection ... # -incontext # -methodtype ... # -nomixins`

List object/class where some method is defined

XOTcl	Next Scripting Language
`obj procsearch methodName`	`obj info callable method methodName # Returns method-handle`
`obj filtersearch methodName`	`obj info callable filter methodName # Returns method-handle`

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 method parameter 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`

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 post methodName`	`obj info method postcondition methodName`
n.a.	`obj info method definition methodName`

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

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 object info filter methods ?-guards? ?-order? ?pattern?`
`cls info filterguard name`	`cls 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 object info mixin classes ?-guards? ?-order? ?pattern?`
`cls info mixinguard name`	`cls 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`

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`

List fully qualified name of method

XOTcl	Next Scripting Language
n.a.	`obj info method handle methodName`
n.a.	`cls ?object? info method handle methodName`

List type of a method

XOTcl	Next Scripting Language
n.a.	`obj info method type methodName`
n.a.	`cls ?object? info method type methodName`

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?`

Check properties of object and classes

XOTcl	Next Scripting Language
`obj istype sometype`	TODO: ::nsf::objectproperty and/or ::nx::objectproperty and/or nx::is? `::nsf::objectproperty obj type sometype` `obj info is type sometype`
`obj ismixin cls`	`::nsf::objectproperty obj mixin cls` `obj info is mixin cls`
`obj isclass ?cls?`	`::nsf::objectproperty obj\|cls class` `obj info is class`
`obj ismetaclass cls`	`::nsf::objectproperty obj\|cls metaclass` `obj info is metaclass`
n.a.	`::nsf::objectproperty cls baseclass` `cls info is baseclass`
`obj isobject obj2`	`::nsf::isobject obj`

Callstack 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`

Other Predefined Methods

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

Dispatch, Aliases, etc.

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`

Method Protection

Incompatibilities between XOTcl 2.0 and XOTcl 1.*

Resolvers

The resolvers (variable resolvers, function resolvers) of the Next Scripting Framework are used as well within XOTcl 2.0. When names starting with single colons are used in XOTcl 1.* scripts, conflicts will arise.

Calling objects like methods

Since the next framework uses a different handling of objects registered as methods (so called ensemble objects), sub-objects can't be called in the same way as before. In XOTcl 1.*, it was possible to call e.g. a method foo of the slot object Foo::slot::ints via

Foo::slot::ints foo ... or via
Foo slot ints foo ...

Now, only the first form has the same semantic as before. In the second form (call of objects via method) has now the ensemble object semantics, self of foo is now the calling object Foo.

Slots

All slot objects (also those in XOTcl) are now always next-scripting objects of baseclass ::nx::Slot

Obsolete commands

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

Stronger Checking

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

Exit Handlers

The exit hander interface changed from a method of ::xotcl::Object into three Tcl procs in the ::nsf namespace. Next provides now:

   ::nsf::setExitHandler script
   ::nsf::getExitHandler
   ::nsf::unsetExitHandler

Last modified: Tue Aug 31 21:43:43 CEST 2010