chaiscript::ChaiScript chai; // инициализирует ChaiScript, добавляя стандартные типы ChaiScript (map, string и т. д.)

chai.add(chaiscript::fun(&function_name), "function_name");
chai.add(chaiscript::fun(&Class::method_name), "method_name");
chai.add(chaiscript::fun(&Class::member_name), "member_name");

chai.add(chaiscript::fun(&Class::method_name, Class_instance_ptr), "method_name");
chai.add(chaiscript::fun(&Class::member_name, Class_instance_ptr), "member_name");

chai.add(chaiscript::fun<ReturnType (ParamType1, ParamType2)>(&function_with_overloads), "function_name");

chai.add(chaiscript::fun(static_cast<ReturnType (*)(ParamType1, ParamType2)>(&function_with_overloads)), "function_name");

struct Base
{
  int data;
};

struct Derived : public Base
{};

chai.add(chaiscript::fun(static_cast<int(Derived::*)>(&Derived::data)), "data");

chai.add(
  chaiscript::fun<std::function<std::string (bool)>>(
    [](bool type) {
      if (type) { return "x"; }
      else { return "y"; }
    }), "function_name");

chai.add(chaiscript::constructor<MyType ()>(), "MyType");
chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType");

chai.add(chaiscript::user_type<MyClass>(), "MyClass");

add_type_conversion(type("string"), type("Type_Info"), fun(s) { return type(s); });

chai.add(chaiscript::type_conversion<T, bool>());

chai.add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { /* return converted thing */ }));

chai.add(chaiscript::base_class<Base, Derived>());

chai.add(chaiscript::base_class<Base, Derived>());
chai.add(chaiscript::base_class<Derived, MoreDerived>());
chai.add(chaiscript::base_class<Base, MoreDerived>());

chai.add(chaiscript::vector_conversion<std::vector<int>>());

chai.add(chaiscript::map_conversion<std::map<std::string, int>>());

chai.add(chaiscript::var(somevar), "somevar"); // копируется
chai.add(chaiscript::var(std::ref(somevar)), "somevar"); // по ссылке, совместно используется C++ и chai
auto shareddouble = std::make_shared<double>(4.3);
chai.add(chaiscript::var(shareddouble), "shareddouble"); // через shared_ptr
``` **Добавление имён пространств имён**

Имена пространств имён не будут заполняться до тех пор, пока не будет вызван `import`. Это экономит память и вычислительные затраты, если пространство имён не импортируется в каждый экземпляр ChaiScript.

```cpp
chai.register_namespace([](chaiscript::Namespace& math) {
    math["pi"] = chaiscript::const_var(3.14159);
    math["sin"] = chaiscript::var(chaiscript::fun([](const double x) { return sin(x); })); },
    "math");

import("math")
print(math.pi) // печатает 3.14159

typedef std::vector<std::pair<int, std::string>> data_list;
data_list my_list{ make_pair(0, "Hello"), make_pair(1, "World") };
chai.add(chaiscript::bootstrap::standard_library::vector_type<data_list>("DataList"));
chai.add(chaiscript::bootstrap::standard_library::pair_type<data_list::value_type>("DataElement"));
chai::add(chaiscript::var(&my_list), "data_list");
chai.eval(R"_(
    for(var i=0; i<data_list.size(); ++i)
    {
      print(to_string(data_list[i].first) + " " + data_list[i].second)
    }
  )_");

chai.eval("print(\"Hello World\")");
chai.eval(R"(print("Hello World"))");

chai.eval<double>("5.3 + 2.1"); // возвращает 7.4 как C++ double

auto v = chai.eval("5.3 + 2.1");
chai.boxed_cast<double>(v); // извлекает значение double из boxed_value и применяет известные преобразования
chaiscript::boxed_cast<double>(v); // бесплатная версия функции, не знает о преобразованиях

chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // работает с любым числовым типом
// что эквивалентно, но гораздо более автоматизировано, чем:
static_cast<int>(chai.eval<double>("5.3+2.1")); // эта версия работает только в том случае, если мы знаем, что это double

// ok, это поддерживается, вы можете зарегистрировать его в движке chaiscript
void nullify_shared_ptr(std::shared_ptr<int> &t) {
  t = nullptr
}

int main()
{
  // делаем некоторые вещи и создаём экземпляр chaiscript
  std::shared_ptr<int> &ptr = chai.eval<std::shared_ptr<int> &>(somevalue);
  // НЕ делайте этого. Взятие неконстантной ссылки на shared_ptr не поддерживается и вызывает неопределённое поведение в механизме chaiscript.
}

double &d = chai.eval("var i = 5.2; i"); // d теперь является ссылкой на i в скрипте
std::shared_ptr<double> d = chai.eval("var i = 5.2; i"); // тот же результат, но счётчик ссылок

d = 3;
chai.eval("print(i)"); // выводит 3

try {
  chai.eval("2.3 + \"String\"");
} catch (const chaiscript::exception::eval_error &e) {
  std::cout << "Error\n" << e.pretty_print() << '\n';
}

try {
  chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
} catch (const double e) {
} catch (int) {
} catch (float) {
} catch (const std::string &) {
} catch (const std::exception &e) {
  // Это тот, который будет вызываться в конкретном throw() выше
}

Note: backtick treats operators as normal functions

```cpp
auto p = chai.eval<std::function<int (int, int)>>("`+`"); 
p(5, 6); // calls chaiscript's '+' function, returning 11

auto p = chai.eval<std::function<std::string (int, double)>>("fun(x,y) { to_string(x) + to_string(y); }");
p(3,4.2); // evaluates the lambda function, returning the string "34.2" to C++

var i; // uninitialized variable, can take any value on first assignment;
auto j; // equiv to var

var k = 5; // initialized to 5 (integer)
var l := k; // reference to k
auto &m = k; // reference to k

global g = 5; // creates a global variable. If global already exists, it is not re-added
global g = 2; // global 'g' now equals 2

global g2;
if (g2.is_var_undef()) { g2 = 4; } // only initialize g2 once, if global decl hit more than once

GLOBAL g3; // all upper case version also accepted

// c-style for loops
for (var i = 0; i < 100; ++i) { print(i); }

// while
while (some_condition()) { /* do something */ }

// ranged for
for (i : [1, 2, 3]) { print(i); }

while (some_condition()) {
  /* do something */
  if (another_condition()) { break; }
}

if (expression) { }

// C++17-style init-if blocks
// Value of 'statement' is scoped for entire `if` block
if (statement; expression) { }

var myvalue = 2
switch (myvalue) {
    case (1) {
        print("My Value is 1");
        break;
    }
    case (2) {
        print("My Value is 2");
        break;
    }
    default {
        print("My Value is something else.");
    }
}

var v = [1,2,3u,4ll,"16", `+`]; // creates vector of heterogenous values
var m = ["a":1, "b":2]; // map of string:value pairs

// Add a value to the vector by value.
v.push_back(123);

// Add an object to the vector by reference.
v.push_back_ref(m);

1.0 // double
1.0f // float
1.0l // long double
1 // int
1u // unsigned int
1ul // unsigned long
1ull // unsigned long long

def myfun(x, y) { x + y; } // last statement in body is the return value
def myfun(x, y) { return x + y; } // equiv 

def myfun(x, int y) { x + y; } // requires y to be an int

def myfun(x, int y) : y > 5 { x - y; } // only called if y > 5

def string::add(int y) { this + to_string(y); }
def add(string s, int y) { s + to_string(y); } //equiv functionality

// calling new function/method
"a".add(1); // returns a1
add("a", 1); // returns a1, either calling syntax works with either def above

var l = fun(x) { x * 15; }
l(2) // returns 30

var a = 13
var m = fun[a](x) { x * a; } 
m(3); // a was captured (by reference), returns 39

var n = bind(fun(x,y) { x * y; }, _, 10);
n(2); // returns 20 

class MyType {
  var value;
  def MyType() { this.value = "a"; }
  def get_value() { "Value Is: " + this.value; }
};

attr MyType::value;
def MyType::MyType() { this.value = "a"; }
def MyType::get_value() { "Value Is: " + this.value; } ### Использование

## Динамические объекты

Все типы, определённые в ChaiScript, и общий Dynamic_Object поддерживают динамические параметры.

Допускается неявное использование this:

## Пространства имён

Пространства имён в ChaiScript — это динамические объекты с глобальной областью видимости.

### Option Explicit

Если вы хотите отключить определения динамических параметров, вы можете использовать set_explicit.

## method_missing

Функция со сигнатурой `method_missing(object, name, param1, param2, param3)` будет вызвана, если соответствующий метод не может быть найден.

Сигнатура method_missing может содержать два или три параметра. Если сигнатура содержит два параметра, она рассматривается как свойство. Если свойство содержит функцию, дополнительные параметры передаются в содержащуюся функцию.

Если совпадают сигнатуры из двух и трёх параметров, всегда выигрывает функция с тремя параметрами.

## Контекст

 * `__LINE__` Текущий номер строки файла
 * `__FILE__` Полный путь текущего файла
 * `__CLASS__` Имя текущего класса
 * `__FUNC__` Имя текущей функции


# Встроенные функции

## Оценка

И use, и eval_file ищут пути usepaths, переданные конструктору ChaiScript.

## JSON

 * from_json преобразует строку JSON в её строго типизированные представления (map, vector, int, double, string)
 * to_json преобразует объект ChaiScript (либо Object, либо одно из map, vector, int, double, string) в его строковое представление JSON

## Дополнительно
ChaiScript сам по себе не предоставляет ссылку на математические функции, определённые в `<cmath>`. Вы можете либо добавить их самостоятельно, либо использовать вспомогательную библиотеку ChaiScript_Extras. (Которая также предоставляет некоторые дополнительные строковые функции.)