Function rule

org/src/cosql.rs:538–599

(input: &str)

}

fn rule(input: &str) -> IResult<&str, Rule> {
    println!("Starting to parse rule {}", input);

    let (input, name) = ws(identifier)(input)?;
    println!("Parsed rule name: {}", name);
    let (input, _) = ws(tag("as"))(input)?;
    println!("Parsed 'as'");
    let (input, _) = ws(tag("match"))(input)?;
    println!("Parsed 'match'");

    // Define a parser for either patterns or conditions
    let pattern_or_condition = alt((
        map(entity_pattern, |p| (p, None::<String>)),
        map(relationship_pattern, |p| (p, None::<String>)),
        map(condition, |c| (Pattern::Condition(c.clone()), Some(c))),
    ));

    // Parse a list of patterns and/or conditions
    let (input, patterns_and_conditions) =
        separated_list0(ws(char(',')), pattern_or_condition)(input)?;

    // Separate patterns and conditions from the combined list
    let mut patterns = Vec::new();
    let mut conditions = Vec::new();

    for (pattern, condition) in patterns_and_conditions {
        if let Some(cond) = condition {
            conditions.push(cond);
        } else {
            patterns.push(pattern);
        }
    }
    println!("Parsed patterns: {:?}", patterns);

    let (input, _) = ws(tag("infer"))(input)?;
    println!("Parsed 'infer'");
    let (input, inference_type) = inference_type(input)?;
    println!("Parsed inference type: {:?}", inference_type);
    let (input, inferences) = separated_list1(
        ws(char(',')),
        alt((
            entity_inference,
            relationship_inference,
            extend_entity_inference,
        )),
    )(input)?;
    println!("Parsed inferences: {:?}", inferences);
    let (input, _) = ws(char(';'))(input)?;
    println!("Parsed semicolon");

    println!("Constructing Rule struct");
    let rule = Rule {
        name: name.to_string(),
        patterns,
        compute_clauses: None,
        inference_type,
        inferences,
    };