Take a look at the Example.hs to see how generated types are used, namely how they are constructed with pcon and deconstructed with pmatch (or pmatchC).
pcon
pmatch
pmatchC
Let's take a look at how LambdaBuffers modules map into Rust modules and how +LambdaBuffers type definitions map into Rust type definitions.
We'll use the lbf-prelude-to-rust CLI tool which is just a convenient wrapper over +the raw lbf CLI. We can get this tool by either loading the LambdaBuffers Nix +environment that comes packaged with all the CLI tools:
lbf-prelude-to-rust
lbf
$ nix develop github:mlabs-haskell/lambda-buffers#lb +$ lbf<tab> +lbf lbf-plutus-to-purescript lbf-prelude-to-haskell lbf-prelude-to-rust +lbf-plutus-to-haskell lbf-plutus-to-rust lbf-prelude-to-purescript +
Or we can simply just refer directly to the lbf-prelude-to-rust CLI by nix run github:mlabs-haskell/lambda-buffers#lbf-prelude-to-rust.
nix run github:mlabs-haskell/lambda-buffers#lbf-prelude-to-rust
In this chapter, we're going to use the latter option.
Let's now use lbf-prelude-to-rust to process the Document.lbf schema.
module Document + +-- Importing types +import Prelude (Text, List, Set, Bytes) + +-- Author +sum Author = Ivan | Jovan | Savo + +-- Reviewer +sum Reviewer = Bob | Alice + +-- Document +record Document a = { + author : Author, + reviewers : Set Reviewer, + content : Chapter a + } + +-- Chapter +record Chapter a = { + content : a, + subChapters : List (Chapter a) + } + +-- Some actual content +sum RichContent = Image Bytes | Gif Bytes | Text Text + +-- Rich document +prod RichDocument = (Document RichContent) +
$ nix run github:mlabs-haskell/lambda-buffers#lbf-prelude-to-rust -- Document.lbf +$ find autogen/ +autogen/ +autogen/LambdaBuffers +autogen/LambdaBuffers/Document.hs +autogen/build.json +
As we can see the autogen directory has been created that contains the generated Rust modules. +Note the autogen/build.json file as it contains all the necessary Cargo dependencies the generated module needs in order to be properly compiled by Rust.
autogen
autogen/build.json
The outputted Rust module in autogen/document.rs:
autogen/document.rs
#![allow(unused)] +#![no_implicit_prelude] +#![allow(warnings)] +fn main() { +extern crate lbf_prelude; +extern crate std; + + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub enum Author{Ivan, Jovan, Savo} + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub struct Chapter<A>{pub content: A, + pub sub_chapters: std::boxed::Box<lbf_prelude::prelude::List<Chapter<A>>>} + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub struct Document<A>{pub author: Author, + pub reviewers: lbf_prelude::prelude::Set<Reviewer>, + pub content: Chapter<A>} + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub enum Reviewer{Bob, Alice} + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub enum RichContent{Image(lbf_prelude::prelude::Bytes), + Gif(lbf_prelude::prelude::Bytes), + Text(lbf_prelude::prelude::Text)} + +#[derive(std::fmt::Debug, std::clone::Clone)] +pub struct RichDocument(pub Document<RichContent>); + +}
The types Author, Reviewer, and RichContent have been declared as sum types in the LambdaBuffers schema using the sum keyword.
Author
Reviewer
RichContent
sum
As we can see, nothing too surprising here, all the sum types become enum +in Rust.
enum
The type RichDocument have been declared as a product type in the +LambdaBuffers schema using the prod keyword.
RichDocument
prod
They become Rust tuple struct (or named tuple)
struct
The types Document and Chapter have been declared as record types in the +LambdaBuffers schema using the record keyword.
Document
Chapter
record
Like with product types, they become Rust struct with named fields.
All types and their fields are public, allowing to manipulate them without accessors.
The goal of the LambdaBuffers project is to enable software developers to specify their application types in a common format that can be conveniently @@ -2393,14 +2492,14 @@
Types of the form Time = Present | Past | Future, which allow a type do be constructed by one of many variants. Think Rust's enums.
Time = Present | Past | Future
enums
Types of the form Person = MkPerson Age Name, where MkPerson is of Kind Type->Type->Type. Product types combine multiple elements into one data type without tagging the elements.
Person = MkPerson Age Name
MkPerson
Type->Type->Type
Types of the form Person = MkPerson { age :: Age, name :: Name }. Record types are similar to structs in most programming languages.
Person = MkPerson { age :: Age, name :: Name }
structs