Struct GFAbstract 

pub struct GFAbstract {
    pub startcat: String,
    /* private fields */
}

Abstract grammar defining logical structure via functions, categories, and types.

The abstract grammar specifies the semantic structure without tying it to specific forms. It defines functions (fun) that combine categories (cat) into new categories.

Example

abstract Lang = {
  cat Sentence;
  fun MakeSentence : Noun -> Verb -> Sentence;
}

Fields

startcat: String

Starting category for parsing/linearization.

Implementations

impl GFAbstract

pub fn new(startcat: String, types: HashMap<String, Type>) -> Self

Creates a new abstract grammar.

Arguments

• startcat - The starting category.
• types - Map of function names to types.

Examples

use gf_core::GFAbstract;
use std::collections::HashMap;
let abs = GFAbstract::new("S".to_string(), HashMap::new());
assert_eq!(abs.startcat, "S");

pub fn from_json(json: Abstract) -> Self

Converts from JSON abstract to GFAbstract.

Arguments

• json - The Abstract structure from JSON.

Examples

use gf_core::{GFAbstract, Abstract};
use std::collections::HashMap;
let json = Abstract { name: "TestGrammar".to_string(), startcat: "S".to_string(), funs: HashMap::new() };
let abs = GFAbstract::from_json(json);
assert_eq!(abs.startcat, "S");

pub fn add_type(&mut self, fun: String, args: Vec<String>, cat: String)

Adds a new function type to the abstract.

Arguments

• fun - Function name.
• args - Argument categories.
• cat - Result category.

Examples

use gf_core::GFAbstract;
use std::collections::HashMap;
let mut abs = GFAbstract::new("S".to_string(), HashMap::new());
abs.add_type("MakeS".to_string(), vec!["NP".to_string(), "VP".to_string()], "S".to_string());
assert_eq!(abs.get_cat("MakeS").unwrap(), "S");

pub fn get_args(&self, fun: &str) -> Option<&Vec<String>>

Gets arguments for a function.

Arguments

• fun - Function name.

Returns

Optional reference to vector of argument categories.

Examples

use gf_core::GFAbstract;
use std::collections::HashMap;
let mut abs = GFAbstract::new("S".to_string(), HashMap::new());
abs.add_type("MakeS".to_string(), vec!["NP".to_string(), "VP".to_string()], "S".to_string());
assert_eq!(abs.get_args("MakeS").unwrap(), &vec!["NP".to_string(), "VP".to_string()]);

pub fn get_cat(&self, fun: &str) -> Option<&String>

Gets category for a function.

Arguments

• fun - Function name.

Returns

Optional reference to result category.

Examples

use gf_core::GFAbstract;
use std::collections::HashMap;
let mut abs = GFAbstract::new("S".to_string(), HashMap::new());
abs.add_type("MakeS".to_string(), vec!["NP".to_string(), "VP".to_string()], "S".to_string());
assert_eq!(abs.get_cat("MakeS").unwrap(), "S");

pub fn handle_literals(&self, tree: Fun, type: &str) -> Fun

Handles literal wrapping for strings, ints, floats.

Modifies tree nodes representing literals to wrap them in appropriate literal functions.

Arguments

• tree - The tree to process.
• type_ - The type of the current node.

Returns

Processed tree.

Examples

use gf_core::{GFAbstract, Fun};
use std::collections::HashMap;
let abs = GFAbstract::new("S".to_string(), HashMap::new());
let tree = Fun::new("\"hello\"".to_string(), vec![]);
let handled = abs.handle_literals(tree, "String");
assert_eq!(handled.name, "String_Literal_\"hello\"");

pub fn copy_tree(&self, x: &Fun) -> Fun

Deep copies a tree.

Arguments

• x - The tree to copy.

Returns

A deep clone of the tree.

Examples

use gf_core::{GFAbstract, Fun};
use std::collections::HashMap;
let abs = GFAbstract::new("S".to_string(), HashMap::new());
let tree = Fun::new("Test".to_string(), vec![Fun::new("Arg".to_string(), vec![])]);
let copy = abs.copy_tree(&tree);
assert_eq!(tree.name, copy.name);
assert_eq!(tree.args.len(), copy.args.len());

pub fn parse_tree(&self, str: &str, type: Option<&String>) -> Option<Fun>

Parses a string into a tree.

Arguments

• str - The string representation of the tree.
• type_ - Optional type for annotation.

Returns

Optional parsed and annotated tree.

Examples

use gf_core::GFAbstract;
use std::collections::HashMap;
let abs = GFAbstract::new("S".to_string(), HashMap::new());
let tree = abs.parse_tree("Test (Arg)", None);
assert!(tree.is_some());
let tree = tree.unwrap();
assert_eq!(tree.name, "Test");
assert_eq!(tree.args.len(), 1);
assert_eq!(tree.args[0].name, "Arg");

Examples found in repository

examples/basic_usage.rs (line 59)

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(())
}

Trait Implementations

impl Clone for GFAbstract

fn clone(&self) -> GFAbstract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GFAbstract

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

Formats the value using the given formatter.