I've taken a look at how namespaces could be handled in ChaiScript.
@lefticus I started with your Dynamic_Object example in the comments above and will present my thoughts on this approach.

In General

I strongly believe that namespaces should be objects. I think this approach will be intuitive to the user, flexible, and straightforward to implement with the existing code base.

A Simple Importer

This importer makes it possible to import specific namespaces per instance of ChaiScript.
If multiple instances of ChaiScript were to be handled in an application, this could be used to only load the specific functions needed per instance.

using namespace chaiscript;
std::shared_ptr<ChaiScript> chai = makeChaiScript();

// Create a map of namespace names with a Dynamic_Object for each namespace
std::shared_ptr<std::map<std::string, dispatch::Dynamic_Object>> chai_namespaces = std::make_shared<std::map<std::string, dispatch::Dynamic_Object>>();

// Add a "math" namespace with a constant and a function
dispatch::Dynamic_Object& math = (*chai_namespaces)["math"]; // The access ["math"] will instantiate a Dynamic_Object within the chai_namespaces
constexpr double pi = 3.14159265358979;
math["pi"] = const_var(pi);
math["sin"] = var(fun([](const double x) { return sin(x); }));

// Add a function for importing namespaces
chai->add(fun([=](const std::string& namespace_name) { chai->add_global(var((*chai_namespaces)[namespace_name]), namespace_name); }), "import");

Using The Importer (ChaiScript)

import("math")

print(math.pi) // prints 3.14159
print(math.sin(math.pi / 2.0)) // prints 1

I really like how clean this syntax is. So, the handling of namespaces from the C++ side is nearly already available. It may be useful to create some helper classes. However, the syntax for handling namespaces from the C++ side should integrate well with creating and using namespaces within ChaiScript.
An improvement to this importer would be to add a generic way of importing just a single function or a variable from a namespace:
import("math.pi") // only imports the "pi" constant from the math namespace
This improvement should be straightforward to implement.
Another significant improvement would be to build the chai_namespaces map at compile time. This would reduce application load time. But, I'm not sure if this could be done in a straightforward and clean way. I'm really looking forward to constexpr lambda functions in C++17.

Namespace Generation in ChaiScript

Let's add a function called "namespace" that can create new namespaces and will register an "add" function with that namespace for adding objects/functions to the new namespace.

Ideally this namespace function would add namespaces to the chai_namespaces map. But, for simplicity this code is just registering the namespace with the current instance of ChaiScript.

chai->add(fun([=](const std::string& namespace_name)
{
   std::shared_ptr<dispatch::Dynamic_Object> namespace_object = std::make_shared<dispatch::Dynamic_Object>();

   (*namespace_object)["add"] = var(fun([=](const std::string& func_name, const Boxed_Value& boxed_value) { (*namespace_object)[func_name] = boxed_value; }));

   chai->add_global(var(namespace_object), namespace_name); return namespace_object; }) // We are returning the namespace_object so that we can immediately append to it. For example: namespace("new_namespace_name").add("x", 5.0)
      , "namespace");

Using The "namespace" Function (ChaiScript)

import("math")

namespace("trig") // define a new namespace called "trig"
trig.add("pi", math.pi) // add a variable to the trig namespace, in this case we're using pi from the math namespace
print(trig.pi)

trig.add("x", 5.0)
print(trig.x)

def myfun(x) { math.sin(x) } // create a new function that uses the math.sin function
trig.add("sin", myfun) // add myfun to the trig namespace, but call it "sin"
print(trig.sin(math.pi / 2.0))

This all works just fine. But, I don't like the syntax for adding new variables and functions to the ChaiScript generated namespace.

Issues With ChaiScript Generated Namespace Syntax

I don't like having to declare my function before I define its namespace.
I don't like having to define the name of the function or variable when it already has a name. Though this could be useful for calling the same function something else in a different namespace (e.g. changing "myfun" to "sin" for the trig namespace).
I don't like using parenthesis as it looks too much like an ordinary function call.

Ideal Syntax and Recommendations

Defining namespace for a variable: var math.tau = 5.0
Defining namespace for a function: def math.squared(x) { x*x }

These ideal examples would require changes to ChaiScript, but I feel they conform best with the semantics of ChaiScript.
math as a namespace would probably need to be a special namespace structure so that the scripting engine could know when the access operator (.) is being called on a namespace and not trying to access a missing parameter. For namespaces the access operator (.) would create a new object if an object of that name doesn't exist. If an object of the same name already exists, then ChaiScript would throw an already defined error.
I'm not sure how I feel about a "using namespace" mechanism. I think it could be handled when import is called, but I am wary about allowing namespaces to be removed in the middle of code or within specific scopes.

My last thought is that ChaiScript should reserve the word "namespace" and perhaps the word "import", as I would recommend these terms for adding namespaces and importing namespaces/modules.

Add namespacing #113

Description

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions