Struct LazyKProgram

pub struct LazyKProgram { /* private fields */ }

Implementations

impl LazyKProgram

Compiled LazyK program, ready to be executed.

pub fn compile(source: &str) -> Result<Self>

Compiles LazyK source to a runnable program.

use lazyk_rust::LazyKProgram;
let source = "I";
let mut program = LazyKProgram::compile(source).unwrap();
assert_eq!(program.run_string("abcd").unwrap(), "abcd");

pub fn set_output_limit(&mut self, value: Option<usize>)

Sets maximal number of cbytes in output, after which program halts. Useful for running programs that produce infinite ouput.

pub fn run_vec(&mut self, input: Vec<u8>) -> Result<Vec<u8>>

Runs program as Vec -> Vec function.

pub fn run_string(&mut self, input: &str) -> Result<String>

Runs program as String -> String function.

pub fn run_console(&mut self) -> Result<()>

Runs program, reading from standard input and writing to standard output.

pub fn to_source(&self, style: Style) -> String

Produces source code for this program.

There are four supported styles: combinator-calculus, Unlambda, Jot and Iota.

use lazyk_rust::{LazyKProgram, Style};
let prog = LazyKProgram::compile("S(SI(K(KI)))(K(KI))").unwrap();
assert_eq!(prog.to_source(Style::CombCalculus), "S(SI(K(KI)))(K(KI))");
assert_eq!(prog.to_source(Style::Unlambda), "``s``si`k`ki`k`ki");                                         
assert_eq!(prog.to_source(Style::Jot), "11111110001111111000111111111000001111001111001111111110000011110011110011111111100000");
assert_eq!(prog.to_source(Style::Iota), "***i*i*i*ii***i*i*i*ii*ii**i*i*ii**i*i*ii*ii**i*i*ii**i*i*ii*ii");

pub fn make_printer(bytes: &[u8]) -> LazyKProgram

Produces LazyK program that prints given byte sequence to output.

use lazyk_rust::LazyKProgram;
let mut prog = LazyKProgram::make_printer("Hi!".as_bytes());
assert_eq!(prog.run_string("").unwrap(), "Hi!");