coffee/ChaiScript
1
0
Fork 0
mirror of https://github.com/ChaiScript/ChaiScript.git synced 2025-12-06 16:57:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #523 from tankorsmash/patch-1

Browse Source 
fix typo in cheatsheet; add cpp highlighting
This commit is contained in:
Rob Loach 2020-05-22 17:50:48 -04:00 committed by GitHub
commit 6abbd9dd1b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 26 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
cheatsheet.md
View File

@ -22,7 +22,7 @@ Note that ChaiScript cannot be used as a global / static object unless it is bei
### General ### General
``` ```cpp
chai.add(chaiscript::fun(&function_name), "function_name"); chai.add(chaiscript::fun(&function_name), "function_name");
chai.add(chaiscript::fun(&Class::method_name), "method_name"); chai.add(chaiscript::fun(&Class::method_name), "method_name");
chai.add(chaiscript::fun(&Class::member_name), "member_name"); chai.add(chaiscript::fun(&Class::member_name), "member_name");
@ -30,7 +30,7 @@ chai.add(chaiscript::fun(&Class::member_name), "member_name");
### Bound Member Functions ### Bound Member Functions
``` ```cpp
chai.add(chaiscript::fun(&Class::method_name, Class_instance_ptr), "method_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(&Class::member_name, Class_instance_ptr), "member_name");
``` ```
@ -39,18 +39,18 @@ chai.add(chaiscript::fun(&Class::member_name, Class_instance_ptr), "member_name"
#### Preferred #### Preferred
``` ```cpp
chai.add(chaiscript::fun<ReturnType (ParamType1, ParamType2)>(&function_with_overloads), "function_name"); chai.add(chaiscript::fun<ReturnType (ParamType1, ParamType2)>(&function_with_overloads), "function_name");
``` ```
#### Alternative #### Alternative
``` ```cpp
chai.add(chaiscript::fun(std::static_cast<ReturnType (*)(ParamType1, ParamType2)>(&function_with_overloads)), "function_name"); chai.add(chaiscript::fun(std::static_cast<ReturnType (*)(ParamType1, ParamType2)>(&function_with_overloads)), "function_name");
``` ```
This overload technique is also used when exposing base member using derived type This overload technique is also used when exposing base member using derived type
``` ```cpp
struct Base struct Base
{ {
int data; int data;
@ -64,7 +64,7 @@ chai.add(chaiscript::fun(static_cast<int(Derived::*)>(&Derived::data)), "data");
### Lambda ### Lambda
``` ```cpp
chai.add( chai.add(
chaiscript::fun<std::function<std::string (bool)>>( chaiscript::fun<std::function<std::string (bool)>>(
[](bool type) { [](bool type) {
@ -75,7 +75,7 @@ chai.add(
### Constructors ### Constructors
``` ```cpp
chai.add(chaiscript::constructor<MyType ()>(), "MyType"); chai.add(chaiscript::constructor<MyType ()>(), "MyType");
chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType"); chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType");
``` ```
@ -84,7 +84,7 @@ chai.add(chaiscript::constructor<MyType (const MyType &)>(), "MyType");
It's not strictly necessary to add types, but it helps with many things. Cloning, better errors, etc. It's not strictly necessary to add types, but it helps with many things. Cloning, better errors, etc.
``` ```cpp
chai.add(chaiscript::user_type<MyClass>(), "MyClass"); chai.add(chaiscript::user_type<MyClass>(), "MyClass");
``` ```
@ -107,27 +107,27 @@ add_type_conversion(type("string"), type("Type_Info"), fun(s) { return type(s);
Invoking a C++ type conversion possible with `static_cast` Invoking a C++ type conversion possible with `static_cast`
``` ```cpp
chai.add(chaiscript::type_conversion<T, bool>()); chai.add(chaiscript::type_conversion<T, bool>());
``` ```
Calling a user defined type conversion that takes a lambda Calling a user defined type conversion that takes a lambda
``` ```cpp
chai.add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { /* return converted thing */ })); chai.add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { /* return converted thing */ }));
``` ```
### Class Hierarchies ### Class Hierarchies
If you want objects to be convertable between base and derived classes, you must tell ChaiScritp about the relationship. If you want objects to be convertable between base and derived classes, you must tell ChaiScript about the relationship.
``` ```cpp
chai.add(chaiscript::base_class<Base, Derived>()); chai.add(chaiscript::base_class<Base, Derived>());
``` ```
If you have multiple classes in your inheritance graph, you will probably want to tell ChaiScript about all relationships. If you have multiple classes in your inheritance graph, you will probably want to tell ChaiScript about all relationships.
``` ```cpp
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<Derived, MoreDerived>());
chai.add(chaiscript::base_class<Base, MoreDerived>()); chai.add(chaiscript::base_class<Base, MoreDerived>());
@ -168,7 +168,8 @@ chai.set_global(chaiscript::var(somevar), "somevar"); // global non-const, overw
Namespaces will not be populated until `import` is called. Namespaces will not be populated until `import` is called.
This saves memory and computing costs if a namespace is not imported into every ChaiScript instance. This saves memory and computing costs if a namespace is not imported into every ChaiScript instance.
```
```cpp
chai.register_namespace([](chaiscript::Namespace& math) { chai.register_namespace([](chaiscript::Namespace& math) {
math["pi"] = chaiscript::const_var(3.14159); math["pi"] = chaiscript::const_var(3.14159);
math["sin"] = chaiscript::var(chaiscript::fun([](const double x) { return sin(x); })); }, math["sin"] = chaiscript::var(chaiscript::fun([](const double x) { return sin(x); })); },
@ -184,7 +185,7 @@ print(math.pi) // prints 3.14159
# Using STL # Using STL
ChaiScript recognize many types from STL, but you have to add specific instantiation yourself. ChaiScript recognize many types from STL, but you have to add specific instantiation yourself.
``` ```cpp
typedef std::vector<std::pair<int, std::string>> data_list; typedef std::vector<std::pair<int, std::string>> data_list;
data_list my_list{ make_pair(0, "Hello"), make_pair(1, "World") }; 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::vector_type<data_list>("DataList"));
@ -202,7 +203,7 @@ chai.eval(R"_(
## General ## General
``` ```cpp
chai.eval("print(\"Hello World\")"); chai.eval("print(\"Hello World\")");
chai.eval(R"(print("Hello World"))"); chai.eval(R"(print("Hello World"))");
``` ```
@ -213,13 +214,13 @@ Returns values are of the type `Boxed_Value` which is meant to be opaque to the
### Prefered ### Prefered
``` ```cpp
chai.eval<double>("5.3 + 2.1"); // returns 7.4 as a C++ double chai.eval<double>("5.3 + 2.1"); // returns 7.4 as a C++ double
``` ```
### Alternative ### Alternative
``` ```cpp
auto v = chai.eval("5.3 + 2.1"); auto v = chai.eval("5.3 + 2.1");
chai.boxed_cast<double>(v); // extracts double value from boxed_value and applies known conversions chai.boxed_cast<double>(v); // extracts double value from boxed_value and applies known conversions
chaiscript::boxed_cast<double>(v); // free function version, does not know about conversions chaiscript::boxed_cast<double>(v); // free function version, does not know about conversions
@ -227,7 +228,7 @@ chaiscript::boxed_cast<double>(v); // free function version, does not know about
### Converting Between Algebraic Types ### Converting Between Algebraic Types
``` ```cpp
chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // works with any number type chaiscript::Boxed_Number(chai.eval("5.3 + 2.1")).get_as<int>(); // works with any number type
// which is equivalent to, but much more automatic than: // which is equivalent to, but much more automatic than:
static_cast<int>(chai.eval<double>("5.3+2.1")); // this version only works if we know that it's a double static_cast<int>(chai.eval<double>("5.3+2.1")); // this version only works if we know that it's a double
@ -257,7 +258,7 @@ int main()
## Sharing Values ## Sharing Values
``` ```cpp
double &d = chai.eval("var i = 5.2; i"); // d is now a reference to i in the script double &d = chai.eval("var i = 5.2; i"); // d is now a reference to i in the script
std::shared_ptr<double> d = chai.eval("var i = 5.2; i"); // same result but reference counted std::shared_ptr<double> d = chai.eval("var i = 5.2; i"); // same result but reference counted
@ -267,7 +268,7 @@ chai.eval("print(i)"); // prints 3
## Catching Eval Errors ## Catching Eval Errors
``` ```cpp
try { try {
chai.eval("2.3 + \"String\""); chai.eval("2.3 + \"String\"");
} catch (const chaiscript::exception::eval_error &e) { } catch (const chaiscript::exception::eval_error &e) {
@ -277,7 +278,7 @@ try {
## Catching Errors Thrown From Script ## Catching Errors Thrown From Script
``` ```cpp
try { try {
chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>()); chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
} catch (const double e) { } catch (const double e) {
@ -292,19 +293,19 @@ try {
## Sharing Functions ## Sharing Functions
``` ```cpp
auto p = chai.eval<std::function<std::string (double)>>("to_string"); auto p = chai.eval<std::function<std::string (double)>>("to_string");
p(5); // calls chaiscript's 'to_string' function, returning std::string("5") p(5); // calls chaiscript's 'to_string' function, returning std::string("5")
``` ```
Note: backtick treats operators as normal functions Note: backtick treats operators as normal functions
``` ```cpp
auto p = chai.eval<std::function<int (int, int)>>(`+`); auto p = chai.eval<std::function<int (int, int)>>(`+`);
p(5, 6); // calls chaiscript's '+' function, returning 11 p(5, 6); // calls chaiscript's '+' function, returning 11
``` ```
``` ```cpp
auto p = chai.eval<std::function<std::string (int, double)>>("fun(x,y) { to_string(x) + to_string(y); }"); 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++ p(3,4.2); // evaluates the lambda function, returning the string "34.2" to C++
``` ```