This project provides safe and easy to use API bindings to Tcl programming language.

Features

1. Convert between Rust values and Tcl objects.

2. Serde data format of Tcl objects.

3. Run Tcl scripts.

4. Register Rust functions/closures as tcl commands.

Quickstart

std::Convert between Rust values and Tcl objects.

```rust use std::convert::TryFrom; use tcl::*;

let obj = Obj::from( 0 ); asserteq!( obj.tostring(), "0" ); asserteq!( i32::tryfrom( obj )?, 0 );

let obj = Obj::from( 1 ); asserteq!( obj.asi32(), 1 ); asserteq!( obj.asf64(), 1.0 ); asserteq!( obj.asbool(), true );

let obj = Obj::from(( false, 42, "answer".toowned() )); asserteq!( obj.tostring(), "0 42 answer" ); asserteq!( <(bool,i32,String)>::tryfrom( obj )?, (false, 42, "answer".toowned() ) );

let v = vec![ "alpha".toowned(), "beta".toowned(), "gamma".toowned() ]; let obj: Obj = v.clone().into(); asserteq!( obj.tostring(), "alpha beta gamma" ); asserteq!( Vec::::try_from( obj )?, v );

use std::collections::HashMap;

let mut map = HashMap::new(); map.insert( "alpha".toowned(), 1 ); map.insert( "beta" .toowned(), 2 ); map.insert( "gamma".to_owned(), 3 );

let obj: Obj = map.clone().into(); asserteq!( HashMap::::tryfrom( obj )?, map );

Ok::<(),TclError>(())

```

User-defined types deserialized / try_from Tcl objects.

```rust use tcl::*;

[derive( Clone, PartialEq, Debug, serde::Deserialize )]

[derive( TryFromDe )]

struct Struct{ a: i32, b: bool, c: f64 }

let obj = Obj::from( "a 1 b false c 3.14" ); let v: Struct = fromobj( obj.clone() )?; asserteq!( v, Struct{ a: 1, b: false, c: 3.14 });

let v: Struct = obj.clone().tryinto()?; asserteq!( v, Struct{ a: 1, b: false, c: 3.14 });

Ok::<(),TclError>(())

```

Use Tcl<T> to store Rust values in Tcl Objs, an vice-vesa.

```rust use std::convert::TryFrom; use tcl::*;

let obj = Tcl::newobj( vec![ 1, 1, 2, 3, 5, 8 ]); let tclobj = Tcl::>::tryfrom( obj )?; asserteq!( tclobj.intoinner(), vec![ 1, 1, 2, 3, 5, 8 ]);

Ok::<(),TclError>(())

```

Run Tcl scripts

```rust use tcl::*;

let interpreter = Interpreter::new()?; let a = 3; let b = 7; let c = interpreter.eval(( "expr", a, "", b ))?; assert_eq!( ab, c.as_i32() );

Ok::<(),TclError>(())

```

Register Rust functions as tcl commands, the unsafe way

```rust use tcl::*;

[proc] fn mul( a: i32, b: i32 ) -> TclResult { Ok( a * b )}

let interpreter = Interpreter::new()?; unsafe { // it's safe for #[proc] fn. interpreter.defproc( "mul", mul ); } let c = interpreter.eval( "mul 3 7" )?; asserteq!( c.as_i32(), 21 );

Ok::<(),TclError>(())

```

Register Rust functions as tcl commands, the safe way

```rust use tcl::*;

let interpreter = Interpreter::new()?;

let cmd = tclfn!( &interpreter, /cmd: "mul", args: "",/ fn mul( a: i32, b: i32 ) -> TclResult { Ok( a * b )} );

let c = interpreter.eval( "mul 3 7" )?; asserteq!( c.asi32(), 21 );

Ok::<(),TclError>(())

```

Register Rust closures as tcl commands

```rust use tcl::*;

let offset = 0; let interpreter = Interpreter::new()?;

let cmd = tclosure!( &interpreter, /cmd: "mul", args: "",/ move |a: i32, b: i32| -> TclResult { Ok( a * b + offset )} );

let a = 3; let b = 7; let c = interpreter.eval(( "eval", cmd, a, b ))?; asserteq!( c.asi32(), 21 );

Ok::<(),TclError>(())

```

License

Under Apache License 2.0 or MIT License, at your will.