[−]Crate sigma

Sigma: Simple, Safe and Fast Template language.

Simple:

sigma is a very simple template language, it only tries to solve only one problem. it also extendable, but with simple idea too (Pure Functions).

Safe:

sigma is also typed, that means that it has the idea of built-in validators for your input. and for those how wanna play, it also could be untyped. also it has a good error checking at parse time of your template. the only error that could happen in runtime is that the input data fails to be parsed to your data types in your templates. Here is some error examples:

ⓘThis example is not tested
--> 1:49
  |
1 | my username is {{ username: str |> UPPERCASE |> NO_FUN }} WOW!
  |                                                 ^----^
  |
  = undefined function: NO_FUN

what if you forgot to bind for some variable in your template ?

ⓘThis example is not tested
 --> 1:19
  |
1 | my username is {{ username: str |> UPPERCASE |> NO_FUN }} WOW!
  |                   ^------^
  |
  = unbinded variable: username consider adding a bind for it

do you need extra help ? we got your back ;)

ⓘThis example is not tested
--> 1:35
  |
1 | my username is {{ username: u32 | UPPERCAS }} WOW!
  |                                   ^------^
  |
  = undefined function: UPPERCAS did you mean: UPPERCASE ?
Fast:

sigma uses pest, The Elegant Parser under the hood to write it's grammar. that means it will be exteramly fast in parsing your templete, also it uses regex crate to replace your data in the template.

Examples

here is a simple examples of how it works

  • Simple:
ⓘThis example is not tested
use sigma::Sigma;

let result = Sigma::new("Hello {{ username }}") // using {{ ... }} for the template.
 .bind("username", "someone") // bind the vars with values
 .parse() // you must parse your template first
 .map_err(|e| eprintln!("{}", e))? // for pretty printing the error..
 .compile()?;
assert_eq!("Hello someone", result);
  • with optinal variables
ⓘThis example is not tested
use sigma::Sigma;
   
let result = Sigma::new("Hello {{ username? }}") // using `?` to tell the parser it maybe `null`.
 .parse()
 .map_err(|e| eprintln!("{}", e))? // for pretty printing the error..
 .compile()?;
assert_eq!("Hello ", result);
  • what about types ?
ⓘThis example is not tested
use sigma::Sigma;
   
let result = Sigma::new("Hello {{ username: str }}") // u8, u32 ? a bool ?.
 .bind("username", "someone")
 .parse()
 .map_err(|e| eprintln!("{}", e))? // for pretty printing the error..
 .compile()?;
assert_eq!("Hello someone", result);
  • how about functions ?
ⓘThis example is not tested
use sigma::Sigma;
   
let result = Sigma::new("Hello {{ username: str | UPPERCASE }}") // functions uses the `|` operator or if you love `|>` you can use it too.
 .bind("username", "someone")
 .parse()
 .map_err(|e| eprintln!("{}", e))? // for pretty printing the error..
 .compile()?;
assert_eq!("Hello SOMEONE", result);
  • love macros ?
ⓘThis example is not tested
use sigma::sigma;
let username = "someone";
let result = sigma!("Hello {{ username }}", username); // the macro return the result so you can check for compile erros.
assert_eq!("Hello someone", result.unwrap());

Macros

sigma

A helper macro to create a sigma with multi key-value

Structs

Sigma

Sigma, Template Language made simple !

Enums

DataType

Primitive Data Types