Struct GFConcrete 

pub struct GFConcrete {
    pub flags: HashMap<String, String>,
    pub start_cats: HashMap<String, (i32, i32)>,
    pub total_fids: i32,
    pub pproductions: HashMap<i32, Vec<Production>>,
    /* private fields */
}

Concrete syntax for linearizing abstract trees.

Defines realizations (linearizations) of the abstract grammar, which can be natural language, images, etc.

A concrete grammar maps abstract functions to linearization rules, which produce output forms based on the arguments.

Example

concrete LangEng of Lang = {
  lincat Sentence = Str;
  lin MakeSentence n v = n ++ v;
}

Fields

flags: HashMap<String, String>

Flags for concrete-specific settings.

start_cats: HashMap<String, (i32, i32)>

Start category ranges.

total_fids: i32

Total number of FIds.

pproductions: HashMap<i32, Vec<Production>>

Parameter productions.

Implementations

impl GFConcrete

pub fn new( flags: HashMap<String, String>, functions: Vec<RuntimeCncFun>, productions: HashMap<i32, Vec<Production>>, start_cats: HashMap<String, (i32, i32)>, total_fids: i32, ) -> Self

Creates a new concrete grammar.

Arguments

• flags - Concrete-specific flags.
• functions - List of runtime concrete functions.
• productions - Map of productions by FId.
• start_cats - Start category ranges.
• total_fids - Total number of FIds.

Examples

use gf_core::{GFConcrete, RuntimeCncFun, LinType, Production};
use std::collections::HashMap;
let flags = HashMap::new();
let functions = vec![];
let productions = HashMap::new();
let start_cats = HashMap::new();
let total_fids = 0;
let concrete = GFConcrete::new(flags, functions, productions, start_cats, total_fids);

pub fn from_json(json: Concrete) -> Self

Converts from JSON concrete to GFConcrete.

This method deserializes a Concrete structure into a usable GFConcrete, resolving sequence indices to actual symbols.

Arguments

• json - The Concrete structure from JSON.

pub fn linearize_syms(&self, tree: &Fun, tag: &str) -> Vec<LinearizedSym>

Linearizes a tree into symbols with tags.

Produces a vector of linearized symbols for the tree, handling different types like metas, literals, and functions.

Arguments

• tree - The abstract tree to linearize.
• tag - The tag for tracking.

Returns

Vector of LinearizedSym.

pub fn syms2toks(&self, syms: &[Sym]) -> Vec<TaggedString>

Converts symbols to tagged tokens.

Processes a sequence of symbols into tagged strings, handling KS and KP symbols.

Arguments

• syms - Slice of symbols.

Returns

Vector of TaggedString.

pub fn linearize_all(&self, tree: &Fun) -> Vec<String>

Linearizes a tree to all possible strings.

Arguments

• tree - The tree to linearize.

Returns

Vector of all possible linearizations.

pub fn linearize(&self, tree: &Fun) -> String

Linearizes a tree to a single string (first variant).

Arguments

• tree - The tree to linearize.

Returns

The linearized string.

Examples found in repository

examples/basic_usage.rs (line 66)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Uncomment the line below to see debug output from GF-Core operations
    set_debug(true);
    
    // Load a PGF grammar from binary file and convert to JSON
    println!("LOG: Reading binary PGF file from disk...");
    let pgf_content = fs::read("grammars/Food/Food.pgf")?;
    
    println!("LOG: Attemp at parsing PGF file Food.pgf starting...");
    let pgf = pgf2json::parse_pgf(&Bytes::from(pgf_content))?;
    
    println!("LOG: Attemp at transforming pgf data to json...");
    let json_string = pgf2json::pgf_to_json(&pgf)?;
    
    println!("LOG: Result of parsing (json_string): {json_string}");
    println!("TODO: Verify that json_string is json formated!");
    
    // Parse JSON string back into PGF struct for runtime usage
    let json_value: serde_json::Value = serde_json::from_str(&json_string)?;
    println!("TODO: Understand purpose of (json_value): {json_string}" );
    
    let pgf_struct: PGF = serde_json::from_value(json_value)?;
    println!("TODO: Understand content of (pgf_struct): {:?}", pgf_struct);
    
    // Convert to runtime grammar
    println!("TODO: Purpose of GFGrammar::from_json(pgf_struct)");
    let grammar: GFGrammar = GFGrammar::from_json(pgf_struct);
    
    
    // Test our fixed abstract syntax parsing
    println!("LOG: Testing fixed abstract syntax parsing");
    
    let test_cases = [
        "Fish",
        "This(Fish)", 
        "Is(This(Fish), Delicious)",
        "MakeS (NP) (VP)",
    ];
    
    for test_case in test_cases {
        println!("\nTesting abstract syntax: '{}'", test_case);
        match grammar.abstract_grammar.parse_tree(test_case, None) {
            Some(tree) => {
                println!("✓ Parsed successfully: {}", tree.print());
                
                // Try to linearize this tree
                if let Some(eng_concrete) = grammar.concretes.get("FoodEng") {
                    println!("LOG: Attempting linearization with FoodEng concrete grammar");
                    let english_output = eng_concrete.linearize(&tree);
                    println!("  English: '{}'", english_output);
                }
            }
            None => {
                println!("✗ Failed to parse");
            }
        }
    }
    
    // Also test the natural language parsing for comparison
    println!("\n=== Natural Language Parsing (for comparison) ===");
    if let Some(eng_concrete) = grammar.concretes.get("FoodEng") {
        let trees = eng_concrete.parse_string("this fish is delicious", &grammar.abstract_grammar.startcat);
        
        if trees.is_empty() {
            println!("No valid parse found for 'this fish is delicious'");
        } else {
            println!("Found {} parse tree(s):", trees.len());
            for (i, tree) in trees.iter().enumerate() {
                println!("  Tree {}: {}", i + 1, tree.print());
                
                // Linearize back to English
                let english_output = eng_concrete.linearize(tree);
                println!("  English: {}", english_output);
            }
        }
    }

    // Note: FoodIta concrete grammar not available in this PGF file
    println!("Available concrete grammars: {:?}", grammar.concretes.keys().collect::<Vec<_>>());

    Ok(())
}

pub fn tag_and_linearize(&self, tree: &Fun) -> Vec<TaggedString>

Linearizes a tree with tags.

Arguments

• tree - The tree to linearize.

Returns

Vector of tagged strings.

pub fn parse_string(&self, input: &str, cat: &str) -> Vec<Fun>

Parses a string into trees using the given start category.

Arguments

• input - The input string.
• cat - The start category.

Returns

Vector of parsed trees.

Examples found in repository

examples/basic_usage.rs (line 79)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Uncomment the line below to see debug output from GF-Core operations
    set_debug(true);
    
    // Load a PGF grammar from binary file and convert to JSON
    println!("LOG: Reading binary PGF file from disk...");
    let pgf_content = fs::read("grammars/Food/Food.pgf")?;
    
    println!("LOG: Attemp at parsing PGF file Food.pgf starting...");
    let pgf = pgf2json::parse_pgf(&Bytes::from(pgf_content))?;
    
    println!("LOG: Attemp at transforming pgf data to json...");
    let json_string = pgf2json::pgf_to_json(&pgf)?;
    
    println!("LOG: Result of parsing (json_string): {json_string}");
    println!("TODO: Verify that json_string is json formated!");
    
    // Parse JSON string back into PGF struct for runtime usage
    let json_value: serde_json::Value = serde_json::from_str(&json_string)?;
    println!("TODO: Understand purpose of (json_value): {json_string}" );
    
    let pgf_struct: PGF = serde_json::from_value(json_value)?;
    println!("TODO: Understand content of (pgf_struct): {:?}", pgf_struct);
    
    // Convert to runtime grammar
    println!("TODO: Purpose of GFGrammar::from_json(pgf_struct)");
    let grammar: GFGrammar = GFGrammar::from_json(pgf_struct);
    
    
    // Test our fixed abstract syntax parsing
    println!("LOG: Testing fixed abstract syntax parsing");
    
    let test_cases = [
        "Fish",
        "This(Fish)", 
        "Is(This(Fish), Delicious)",
        "MakeS (NP) (VP)",
    ];
    
    for test_case in test_cases {
        println!("\nTesting abstract syntax: '{}'", test_case);
        match grammar.abstract_grammar.parse_tree(test_case, None) {
            Some(tree) => {
                println!("✓ Parsed successfully: {}", tree.print());
                
                // Try to linearize this tree
                if let Some(eng_concrete) = grammar.concretes.get("FoodEng") {
                    println!("LOG: Attempting linearization with FoodEng concrete grammar");
                    let english_output = eng_concrete.linearize(&tree);
                    println!("  English: '{}'", english_output);
                }
            }
            None => {
                println!("✗ Failed to parse");
            }
        }
    }
    
    // Also test the natural language parsing for comparison
    println!("\n=== Natural Language Parsing (for comparison) ===");
    if let Some(eng_concrete) = grammar.concretes.get("FoodEng") {
        let trees = eng_concrete.parse_string("this fish is delicious", &grammar.abstract_grammar.startcat);
        
        if trees.is_empty() {
            println!("No valid parse found for 'this fish is delicious'");
        } else {
            println!("Found {} parse tree(s):", trees.len());
            for (i, tree) in trees.iter().enumerate() {
                println!("  Tree {}: {}", i + 1, tree.print());
                
                // Linearize back to English
                let english_output = eng_concrete.linearize(tree);
                println!("  English: {}", english_output);
            }
        }
    }

    // Note: FoodIta concrete grammar not available in this PGF file
    println!("Available concrete grammars: {:?}", grammar.concretes.keys().collect::<Vec<_>>());

    Ok(())
}

pub fn complete(&self, input: &str, cat: &str) -> CompletionResult

Provides completions for partial input.

Arguments

• input - The partial input string.
• cat - The start category.

Returns

CompletionResult with consumed tokens and suggestions.

Trait Implementations

impl Clone for GFConcrete

fn clone(&self) -> GFConcrete

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GFConcrete

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.