Migration Guide for the Next Scripting Language

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

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

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

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

# Define instance method and object method
# with separate commands

Class create C
C method foo args {...}
C 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 object method and set
# instance variable in the init-block of
# an object

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

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

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

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

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

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 {
  :object forward f3 ...
}

# Define setter and getter methods in XOTcl.
#
# XOTcl provides methods for these.

Class C
C instparametercmd p1
C parametercmd p2

Object o
o parametercmd p3

# Define setter and getter methods in NX.
#
# NX does not provide own methods, but uses
# the low level framework commands, since
# application developer will only seldomly
# need it.

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

Object create o
::nsf::method::setter o p3

# Method "alias" not available

# Define method aliases
# (to scripted or non-scripted methods)

Class create C {
  :alias a1 ...
  :object alias a2 ...
}

Object create o {
  :object alias a3 ...
}

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

# Method modifiers
#
#   "object",
#   "public",
#   "protected"
#
# are applicable for all kinds of
# method defining methods:
#
#    method, forward, alias
#
# The modifier "private" is available for
#
#    method, forward, alias
#
Class create C {
  :/method-definiton-method/ ...
  :public /method-definiton-method/ ...
  :protected /method-definiton-method/ ...
  :private /method-definiton-method/ ...
  :object /method-definiton-method/ ...
  :public object /method-definiton-method/ ...
  :protected object /method-definiton-method/ ...
  :private object /method-definiton-method/ ...
}

# XOTcl provides no means for
# method hiding

# Hiding of methods via "private"
#
nx::Class create Base {
  :private method baz {a b} {expr {$a + $b}}
  :public method foo {a b} {: -local baz $a $b}
}

nx::Class create Sub -superclass Base {
  :public method bar {a b} {: -local baz $a $b}
  :private method baz {a b} {expr {$a * $b}}

  :create s1
}

s1 foo 3 4  ;# returns 7
s1 bar 3 4  ;# returns 12
s1 baz 3 4  ;# unable to dispatch method 'baz'

# XOTcl provides only method deletion with
# the equivalent of Tcl's "proc foo {} {}"
/cls/ instproc foo {} {}
/obj/ proc foo {} {}

# Deletion of Methods
#
/cls/ delete method /name/
/obj/ delete object method /name/

Class C
C instproc foo args {...}
C instproc bar args {
  my foo 1 2 3 ;# invoke own method
  o baz        ;# invoke other object's 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 object's method
  }
}
Object create o {
  :public object method baz {} {...}
}

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

/obj/ set /varName/ ?value?

# Set instance variable of object obj to a
# value via resolver
# (preferred way: define property 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/

# Define class "Foo" with instance
# variables "x" and "y" initialized
# on instance creation. The initialization
# has to be performed in the constructor.

Class Foo
Foo instproc init args {
   instvar x y
   set x 1
   set y 2
}

# Create instance of the class Foo
Foo f1

# Object f1 has instance variables
# x == 1 and y == 2

# Define class "Foo" with instance variables
# "x" and "y" initialized on instance creation.
# The method "variable" is similar in syntax
# to Tcl's "variable" command. During
# instance creation, the variable
# definitions are used for the
# initialization of the variables of the object.

Class create Foo {
  :variable x 1
  :variable y 2
}

# Create instance of the class Foo
Foo create f1

# Object f1 has instance variables
# x == 1 and y == 2

# No syntactic support for creating
# class variables

# Define a object variable "V" with value 100 and
# an instance variable "x". "V" is defined for the
# class object Foo, "x" is defined in the
# instances of the class. "object variable" works
# similar to "object method".

Class create Foo {
  :object variable V 100
  :variable x 1
}

# Parameters specified as a list
# (short form); parameter
# "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 instance variables
# a == 0 and b == 1

# XOTcl registers automatically accessors
# for the parameters. Use the accessor
# "b" to output the value of variable "b"
puts [f1 b]

# Use the setter to alter value of
# instance variable "b"
f1 b 100

# Define property "a" and "b". The
# property "a" has no default, "b" has
# default value "1"

Class create Foo {
  :property a
  :property {b 1}
}

# Create instance of the class Foo
Foo create f1 -a 0

# Object f1 has instance variables
# a == 0 and b == 1

# Use the method "cget" to query the value
# of a configuration parameter
puts [f1 cget -b]

# Use the method "configure" to alter the
# value of instance variable "b"
f1 configure -b 100

# "parameter" creates always accessor
# methods, accessor methods are
# always public, no "cget" is available.

Class create Foo -parameter {a {b1}}

# Use the accessor method to query
# the value of a configuration parameter
puts [f1 b]

# Use the accessor method to set the
# value of instance variable "a"
f1 a 100

# Use the accessor method to unset the
# value of instance variable "a" n.a. via
# accessor

# Define property "a" and "b". The
# property "a" has no default, "b" has
# default value "1"

Class create Foo {
  :variable -accessor public a
  :property -accessor public {b 1}
}

# Use the accessor method to query
# the value of a configuration parameter
puts [f1 b get]

# Use the accessor method to set the
# value of instance variable "a"
f1 a set 100

# Use the accessor method to unset the
# value of instance variable "a"
f1 a unset

# XOTcl provides no means to define
# configurable variables at the object
# level

# Define class with a property for the class object
# named "cp". This is similar to "static variables"
# in some other object-oriented programming
# languages.

Class create Foo {
  ...
  :object property cp 101
}

# Define object property "op"

Object create o {
  :object property op 102
}

# No value constraints for
# parameter available

# Predefined value constraints:
#    object, class, alnum, alpha, ascii, boolean,
#    control, digit, double, false, graph, integer,
#    lower, parameter, print, punct, space, true,
#    upper, wordchar, xdigit
#
# User defined value constraints are possible.
# All parameter value checkers can be turned on
# and off at runtime.
#
# Define a required boolean property "a"
# and an integer property "b" with a default.
# The first definition uses "properties",
# the second definition uses multiple
# "property" statements.

Class create Foo -properties {
   a:boolean
   {b:integer 1}
}

Class create Foo {
   :property a:boolean
   :property {b:integer 1}
}

# Required parameter not available

# Required parameter:
# Define a required property "a" and a
# required boolean property "b"

Class create Foo -properties {
   a:required
   b:boolean,required
}

Class create Foo {
   :property a:required
   :property b:boolean,required
}

# Multiplicity for parameter
# not available

# Parameter with multiplicity
#   ints is a list of integers, with default
#   objs is a non-empty list of objects
#   obj is a single object, maybe empty

Class create Foo -properties {
  {ints:integer,0..n ""}
   objs:object,1..n
   obj:object,0..1
}

Class create Foo {
  :property {ints:integer,0..n ""}
  :property objs:object,1..n
  :property obj:object,0..1
}

# Define parameters via slots

Class Foo -slots {
   Attribute a
   Attribute b -default 1
}

# Create instance of the class Foo
# and provide a value for instance
# variable "a"
Foo f1 -a 0

# Object f1 has a == 0 and b == 1

# Configurable parameters specified via the
# method "property" (supports method
# modifiers and scripted configuration;
# see below)

Class create Foo {
   :property a
   :property {b 1}
}

# Create instance of the class Foo and
# provide a value for instance variable "a"
Foo create f1 -a 0

# Object f1 has a == 0 and b == 1

# Define parameter with an 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"
        }
      }
    }
  }
}

# Configure parameter with scripted
# definition (init-block), defining a
# property specific type checker

Class create Person {
    :property -accessor public sex:sex,convert {

      # define a converter to standardize representation
      :object method type=sex {name value} {
        switch -glob $value {
          m* {return m}
          f* {return f}
          default {error "expected sex but got $value"}
        }
      }

    }
}

# No syntactic support for deleting
# variable handlers

# Like deletion of Methods:
# Delete on the object, where the
# variable handler is defined.

/cls/ delete property /name/
/obj/ delete object property /name/

/cls/ delete variable /name/
/obj/ delete object variable /name/

# 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

# Only leading non-positional
# parameters are available; no
# optional positional parameters,
# no value constraints on
# positional parameters,
# no multiplicity, ...

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

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

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

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

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

# No return value checking
# available

# 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 an integer
  # value
  :alias incr -returns integer ::incr

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

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

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

# Query per-class mixin
/cls/ instmixin

# Register/clear per-class mixin and guard for
# a class

/cls/ mixins add|set|clear ...
/cls/ mixins guard /mixin/ ?condition?
/cls/ configure -mixin ...

# Query per-class mixins
/cls/ mixins get
/cls/ cget -mixins

# Query per-class mixins (without guards)
/cls/ mixins classes

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

# Query per-object mixins
/obj/ mixin

# Register/clear per-object mixin and guard for
# an object

/obj/ object mixins add|set|clear ...
/obj/ object mixins guard /mixin/ ?condition?
/obj/ configure -object-mixins ...

# Query per-object mixin
/obj/ object mixins get
/obj/ cget -object-mixin

# Query per-object mixins (without guards)
/cls/ mixins classes

# Register per-class filter and guard for
# a class
/cls/ instfilter ...
/cls/ instfilterguard /filter/ ?condition?

# Query per-class filter
/cls/ instfilter

# Register/clear per-class filter and guard for
# a class

/cls/ filters add|set|clear ...
/cls/ filters guard /filter/ ?condition?
/cls/ configure -filters ...

# Query per-class filters
/cls/ filters get
/cls/ cget -filters

# Query per-class filters (without guards)
/cls/ filters methods

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

# Register(clear per-object filter and guard for
# an object

/obj/ object filters add|set|clear ...
/obj/ object filters guard /filter/ ?condition?
/obj/ configure -object-filters ...

# Query per-object filters
/cls/ object filters get
/obj/ cget -object-filters

# Query per-object filters (without guards)
/cls/ object filters methods

/cls/ info superclass ?pattern?

/cls/ info superclasses ?pattern?

/cls/ info subclass ?pattern?

/cls/ info subclasses -type setter ?pattern?

/cls/ info instcommands ?pattern?

/cls/ info methods ?pattern?

/cls/ info instparametercmd ?pattern?

/cls/ info methods -type setter ?pattern?

/cls/ info instprocs ?pattern?

/cls/ info methods -type scripted ?pattern?

# n.a.

/cls/ info methods -type alias ?pattern?
/cls/ info methods -type forwarder ?pattern?
/cls/ info methods -type object ?pattern?
/cls/ info methods -callprotection public|protected ...

/obj/ info commands ?pattern?

/obj/ info object methods ?pattern?

/obj/ info parametercmd ?pattern?

/obj/ info object methods -type setter ?pattern?

/obj/ info procs ?pattern?

/obj/ info object methods -type scripted ?pattern?

# n.a.

/obj/ info object methods -type alias ?pattern?
/obj/ info object methods -type forwarder ?pattern?
/obj/ info object methods -type object ?pattern?
/obj/ info object methods -callprotection public|protected ...

/obj|cls/ info \
   [inst](commands|procs|parametercmd) \
   ?pattern?

/cls/ info method exists /methodName/
/cls/ info methods /methodName/
/obj/ info object method exists /methodName/
/obj/ info object methods /methodName/

/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
# -type ...
# -nomixins

# n.a.

# List slot objects defined for obj
# -source might be all|application|baseclasses
# -type is the class of the slot object

/obj/ info lookup slots ?-type ...? ?-source ...? ?pattern?

# Returns list of slot objects

# List registered filters
/obj/ info filters -order ?-guards? ?pattern?

# List registered mixins
/obj/ info mixins -heritage ?-guards? ?pattern?

# List registered filters
/obj/ info lookup filters ?-guards? ?pattern?

# List registered mixins
/obj/ info lookup mixins ?-guards? ?pattern?

/obj/ procsearch /methodName/

/obj/ info lookup method /methodName/
# Returns method-handle

/obj/ filtersearch /methodName/

/obj/ info lookup filter /methodName/
# Returns method-handle

# n.a.

/cls/ info method definition /methodName/
/obj/ info object method definition /methodName/

/cls/ info instbody /methodName/
/obj/ info body /methodName/

/cls/ info method body /methodName/
/obj/ info object method body /methodName/

/cls/ info instargs /methodName/
/obj/ info args /methodName/

/cls/ info method args /methodName/
/obj/ info object method args /methodName/

/cls/ info instnonposargs /methodName/
/obj/ info object method args /methodName/

/cls/ info method parameter /methodName/
/obj/ info object method parameter /methodName/

/cls/ info instdefault /methodName/
/obj/ info default /methodName/

# not needed, part of
# "info ?object? method parameter"

/cls/ info instpre /methodName/
/obj/ info pre /methodName/

/cls/ info method precondition /methodName/
/obj/ info object method precondition /methodName/

/cls/ info instpost /methodName/
/obj/ info post /methodName/

/cls/ info method postcondition /methodName/
/obj/ info object method postcondition /methodName/

# n.a.

/cls/ info method syntax /methodName/
/obj/ info object method syntax /methodName/

# n.a.

# Return the parameters applicable to
# the create method of a certain class.
# class can be configured. A pattern can
# be used to filter the results.

/cls/ info lookup parameters create ?/pattern/?

# Return in the result in documentation syntax

/cls/ info lookup syntax create ?/pattern/?

# "info lookup parameters configure" returns
# parameters available for configuring the
# current object  (might contain object
# specific information)

/obj/ info lookup parameters configure ?pattern?

# "info lookup configure syntax" returns syntax of
# a call to configure in the Tcl parameter syntax

/obj/ info lookup syntax configure

# Obtain information from a parameter
# (as e.g. returned from "info lookup
# parameters configure").

nsf::parameter::info name /parameter/
nsf::parameter::info syntax /parameter/
nsf::parameter::info type /parameter/

# obtain parameter definitions defined
# for a class
/cls/ info parameter

# "info variables" returns handles of
# properties and variables defined by this
# class or object

/cls/ info variables ?pattern?
/obj/ info object variables ?pattern?

# "info lookup variables" returns handles
# of variables and properties applicable
# for the current object (might contain
# object specific information)

/obj/ info lookup variables /pattern/

# "info variable" lists details about a
# single property or variable.

/obj/ info variable definition /handle/
/obj/ info variable name /handle/
/obj/ info variable parameter /handle/

# n.a.

# Return list of slots objects defined on the
# object or class
#
# -source might be all|application|baseclasses
# -type is the class of the slot object
# -closure includes slots of superclasses

/cls/ info slots \
   ?-type value? ?-closure? ?-source value? ?pattern?
/obj/ info object slots ?-type ...? ?pattern?

# List reachable slot objects defined for obj
# -source might be all|application|baseclasses
# -type is the class of the slot object
# Returns list of slot objects.

/obj/ info lookup slots \
   ?-type ...? ?-source ... ?pattern?

# Obtain definition, name or parameter from
# slot object

/slotobj/ definition
/slotobj/ name
/slotobj/ parameter

/obj/ info filter ?-guards? ?-order? ?pattern?
/obj/ info filterguard /name/

/obj/ info object filters \
   ?-guards? ?pattern?

/cls/ info instfilter \
   ?-guards? ?-order? ?pattern?
/cls/ info instfilterguard /name/

/cls/ info filters \
   ?-guards? ?pattern?

/obj/ info mixin ?-guards? ?-order ?pattern?
/obj/ info mixinguard /name/

/obj/ info object mixins \
   ?-guards? ?pattern?

/cls/ info instmixin \
   ?-guards? ?-order? ?pattern?
/cls/ info instmixinguard /name/

/cls/ info mixins \
   ?-closure? ?-guards? ?-heritage? ?pattern?

# n.a.

/cls/ info method definition /methodName/
/obj/ info object method definition /methodName/

# n.a.

#
# List the method handle of the specified method,
# can be used e.g. for aliases. "handle" is the short
# form of "definitionhandle".
#
/cls/ info method handle /methodName/
/obj/ info object method handle /methodName/
#
# For ensemble methods (method name contains
# spaces) one can query as well the registration
# handle, which is the handle to the root of the
# ensemble; the definiton handle points to the
# leaf of the ensemble.
#
/cls/ info method registrationhandle /methodName/
/obj/ info object method registrationhandle /methodName/
#
# For aliases, one can query the original
# definition via "info method origin"
#
/cls/ info method origin /methodName/
/obj/ info object method origin /methodName/

# n.a.

/cls/ info method type /methodName/
/obj/ info object method type /methodName/

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

/obj/ istype /sometype/

# Check if object is a subtype of some class
/obj/ info has type /sometype/

/obj/ ismixin /cls/

# Check if object has the specified mixin registered
/obj/ info has mixin /cls/

/obj/ isclass ?/cls/?

cd # Check if object is an NX class
/obj/ has type ::nx::Class

# Check if object is a class in one of the
# NSF object systems
::nsf::is class /obj/

/obj/ ismetaclass /cls/

# Check if class is an NX metaclass
expr {[/cls/ info heritage ::nx::Class] ne ""}

# Check if object is a metaclass in one of the
# NSF object systems
::nsf::is metaclass /obj/

# n.a.

# Check if object is a baseclass of an object system
::nsf::is baseclass /obj/

# n.a.

# Return name of object (without namespace prefix)
/obj/ info name

/obj/ object::exists /obj/

# Check for existence of object (nsf primitive)
::nsf::object::exists /obj/

self

self

current object

self class

current class

self args

current args

self proc

current method

self callingclass

current calledclass

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 of the
# method to be called via "next"
current next

self filterreg

# Returns method-handle of the
# filter method
current filterreg

self callinglevel

current callinglevel

self activelevel

current activelevel