Static Type-Checking and Inference
The main advantage of this is that type-safety can be known by the
programmer before actually injecting the packet into the network. The user
provides types for the services to be used by the type-checker via
service declarations (declarations for the core services are not
necessary, however). The types of chunks have also changed to be
parameterized by a return type, i.e. intchunk. Type
inference permits the programmer to omit the type annotations and allow them
to be determined automatically.
Polymorphism
PLAN type expressions may now include type variables, thus permitting
polymorphic functions, as in:
fun cons(x:'a,xs:'a list):'a list = x::xs
Changes:
All example programs and services have been changed to use the type
inference system rather than using explicit type annotations.
Security Services
We have expanded the security services introduced in PLAN 3.1 as described
in our IWAN paper.
In particular, rather than allowing for access-control on a per-service
basis, we provide access control at authentication time via
namespace-adjustment. Additionally, services for parameterized usage of
services are provided. We provide examples of the usage of both sets of
services, including code for an active firewall, and for controlled access
to soft-state.
Implementation
Altered the core routing structure to be more modular. Since
pland may now function as either a router or a firewall, the
respective processing cores are in separate files. Also, changed the
implementation of the symbol table to be functional, to allow sharing (but
at a performance hit).
Both kinds of right shift are now supported: arithmetic
(>>) and logical (>>>).
Marshalling format extended to permit both types of right shift.
Wire format for chunks changed to support security features.
Java stubs updated for new marshalling format; the java stubs support
polymorphism but not type inference.
Eliminated redundant typechecking in the PLAN interpreter, so type
errors are only raised when an operator is applied to an incorrect type. So
if a PLAN program came in with a wire representation corresponding to:
fun main():int =
let val x:int = true in
1 + x
end
The type error gets raised at the addition, rather than at the binding of
x.