Struct GFGrammar 

pub struct GFGrammar {
    pub abstract_grammar: GFAbstract,
    pub concretes: HashMap<String, GFConcrete>,
}

A Grammatical Framework grammar consisting of one abstract and multiple concretes.

The GFGrammar type encapsulates an abstract grammar (logical structure) and one or more concrete grammars (linearizations). The abstract defines categories and functions independently of form, while concretes provide manifestations (e.g., natural language strings).

Examples

use gf_core::{GFGrammar, GFAbstract};
use std::collections::HashMap;
let abstract_ = GFAbstract::new("S".to_string(), HashMap::new());
let concretes = HashMap::new();
let grammar = GFGrammar::new(abstract_, concretes);
assert_eq!(grammar.abstract_grammar.startcat, "S");

Fields

abstract_grammar: GFAbstract

The abstract grammar (only one per GFGrammar).

concretes: HashMap<String, GFConcrete>

Map of language codes to concrete grammars.

Implementations

impl GFGrammar

pub fn new( abstract_: GFAbstract, concretes: HashMap<String, GFConcrete>, ) -> Self

Creates a new GFGrammar from an abstract and concretes.

Arguments

• abstract_ - The abstract grammar.
• concretes - A map of language codes to concrete grammars.

Examples

use gf_core::{GFGrammar, GFAbstract};
use std::collections::HashMap;
let abstract_ = GFAbstract::new("S".to_string(), HashMap::new());
let concretes = HashMap::new();
let grammar = GFGrammar::new(abstract_, concretes);
assert_eq!(grammar.abstract_grammar.startcat, "S");

pub fn from_json(json: PGF) -> Self

Converts from PGF JSON format to GFGrammar.

This method deserializes a PGF structure (typically from JSON) into a usable GFGrammar.

Arguments

• json - The PGF structure to convert.

Examples

Assuming a valid PGF instance, this creates a grammar:

// Note: This doctest is illustrative; actual PGF creation may require deserialization.
use gf_core::{GFGrammar, PGF, Abstract, Concrete};
use std::collections::HashMap;
let abstract_ = Abstract { name: "TestGrammar".to_string(), startcat: "S".to_string(), funs: HashMap::new() };
let concretes = HashMap::new();
let pgf = PGF { abstract_, concretes };
let grammar = GFGrammar::from_json(pgf);
assert_eq!(grammar.abstract_grammar.startcat, "S");

Examples found in repository

examples/basic_usage.rs (line 44)

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 translate( &self, input: &str, from_lang: Option<&str>, to_lang: Option<&str>, ) -> Vec<HashMap<String, HashMap<String, String>>>

Translates input from one language to another (or all if unspecified).

Parses the input in the source language(s) and linearizes to target language(s).

Arguments

• input - The string to translate.
• from_lang - Optional source language code.
• to_lang - Optional target language code.

Returns

Vector of translation maps (source -> tree -> target -> output).