Changeset 3537

Timestamp:

05/20/05 23:16:21 (4 years ago)

Author:

putter

svk:copy_cache_prev:

5107

Message:

Edited quickref/namespace.

Files:

• docs/quickref/namespace (modified) (5 diffs)

docs/quickref/namespace

@@ +1 @@
+THIS IS VERY VERY DRAFTY (so lots of bugs flew in)
+
 Package-like things (they are namespaces)
+
+[todo - rationalize when to say "namespace" vs "package"]
 
 Where's the beef:
@@ -7 +11 @@
    module    export/import, version
     role     methods, attributes, inheritance, parameterized
-     class   instantiation, _not_ parameterized
-      enum   weird methods
+    class    methods, attributes, composition, instantiation
+     enum    weird methods
+
 
 Name and duration:
+
                    Name:   Name-Visibility: Package Duration:
      package P   top-level     global      until exit or deletion
-  my package P   top-level     lexical        dynamic
+  my package P   top-level     lexical        dynamic?
  our package P   relative to   same as        same as  ...current package.
      package     anonymous       n/a          dynamic
@@ -26 +32 @@
 But grammars and rules have a separate system.
 
-Hierarchical naming:
 
- symbol example meaning
-  ::*    ::*A    root; begins absolute names.
-  ::     ::A     begins relative names
-  ::  ...::A     separator
-  ($expr)        a subpath expanded at runtime.
-                  ..::($expr)::.. but not ..::($expr)baz::..
-  ::*Main        The user's default namespace.
+Names
+
+Names are hierarchical, like filesystem path names.
+They start with :: . The separator is also :: .  Just like / in unix.
+Strings can be interpolated into names by ($expr) , but must begin and
+end at separator boundaries.
+
+Some notable namespaces are:
+  ::*        global (root)
+  ::MY       current lexical
+  ::*::Main  the user default
+
+A name N can be used:
+  N              by itself
+  %N::           as a hash (symbol table)
+  $N @N %N &N    to name variables
+
+The beginning of a name can be abbreviated, to make short names even simpler.
+  example shorter  rule
+  %::A     %A    the starting :: can be dropped if it's not at the word beginning
+  ::*::A   ::*A  root doesn't need a separator
+  ::A      A     a declared name doesn't need the starting ::
+  ::*A     *A    root's starting :: can be dropped where there is no confusion
+                  with unary * (such as declarations).
+
+There are a bunch of examples below.
 
 A single hierarchy is shared by modules, classes, roles, enums, and
@@ -42 +66 @@
 separate system.
 
-Names are searched for from innermost scopes to outermost.
-# Which names?  relative names?  names without separators?
+Relative package names are searched for
+  from inner lexical scopes to outer, then
+  from inner packages to outer, then
+  in the global namespace.
 
-Symbol table:
+[this deserves elaboration]
 
-  %Name      symbol table
-  %Name<$x>  lookup
-  %::*       global symbol table
-  %::*P      symbol table of top-level P
-  %P::       symbol table of some P
+
+Autoloading:
+
+The presense of names in a namespace can be faked.  Or implemented
+lazily.  If a user inquires about (defined(...)), or tries to use a
+variable, which is not in the symbol table, hooks are called.
+
+For SCALAR ARRAY HASH SUB METH ...:
+
+AUTO...    predicates test the existance of a variable,
+             returning undef or _any_ ref of the right type.
+AUTO...DEF accessors actually fetch the requested variable.
+
+[Can a package or role AUTOMETH?]
+
+
+Binding:
+
+:= ::=
+# todo
+
+
+
+Here are assorted examples of names:
+
+ ::A               namespace name, relative
+ ::A::B
+ ::A::B::C
+ ::*               namespace name, absolute (::* is root)
+ ::*A                (root doesn't need a separator)
+ ::*A::B
+ ::*A::B::C
+ %A::              namespace as hash; relative name
+ %A::B::
+ %*::              namespace as hash; absolute name
+ %*A::
+ %*A::B::
+ %x                variable name, lexical   ("%" could be any sigil $@%& etc)
+ %A::x             variable name, relative  ("%" could be any sigil $@%& etc)
+ %A::B::x                                   ("%" could be any sigil $@%& etc)
+ %*x               variable name, absolute  ("%" could be any sigil $@%& etc)
+ %*A::x                                     ("%" could be any sigil $@%& etc)
+ %*A::B::x                                  ("%" could be any sigil $@%& etc)
+Abbreviations used above:
+ ::*::A            ::*A   (root doesn't need a separator)
+ %::A::            %A::   (the leading :: is only needed if it starts the word)
+                              (::A::B could NOT be abbreviated A::B)
+ %::A::x           %A::x
+ %::*::x           %*x    (using both)
+ %::*::A::         %*A::
+Notable namespaces:
+ ::MY              current lexical namespace
+ %MY::                 as hash
+ %MY::x                a variable in        ("%" could be any sigil $@%& etc)
+ ::*Main           default user namespace
+ %*Main::              as hash
+ %*Main::x             a variable in        ("%" could be any sigil $@%& etc)
+Runtime interpolation:
+ ::("A")           ::A
+ ::("A::B")        ::A::B
+ ::("A::")B   # ILLEGAL
+ ::("A")::B        ::A::B
+ ::A::("B")        ::A::B
+ ::A::("B")::C     ::A::B::C
+ ::("*")           ::*
+ ::("*A")          ::*A
+ ::("*::A")        ::*A
+ %::("A")::        %A::
+ %::("A::")   # ILLEGAL
+ %::("A::x")       %A::x                    ("%" could be any sigil $@%& etc)
+ ::($expr)         a namespace name
+ ::($e1)::($e2)    a namespace name
+ %::($expr)::      a namespace used as a hash
+ %::($expr)        a variable name          ("%" could be any sigil $@%& etc)
+Using a namespace hash (a symbol table):
+  %P::       namespace P as a hash (a symbol table)
   %P::<$s>   lookup $s
   %P::<@a>   lookup @a
@@ -57 +154 @@
   %P::{$sym} lookup some symbol specified at runtime
 
-Traits/properties:
 
-Autoloading:
 
-Version:
-
-Export/import/inheritance(is/does):
-
-Types:
-
-Parameterization:
-
-Dispatch:
-
-Instantiation/Objects: