duckling 0.4.0

A Rust port of Facebook's Duckling library for parsing natural language into structured data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::dimensions::numeral::helpers::{is_natural, is_positive, numeral_data};
use crate::pattern::{predicate, regex};
use crate::types::{Rule, TokenData};

use super::{AmountOfMoneyData, Currency};

fn money_data(td: &TokenData) -> Option<&AmountOfMoneyData> {
    if let TokenData::AmountOfMoney(d) = td {
        Some(d)
    } else {
        None
    }
}
fn is_currency_only(td: &TokenData) -> bool {
    matches!(td,TokenData::AmountOfMoney(d) if d.value.is_none()&&d.min_value.is_none()&&d.max_value.is_none())
}
fn is_money_with_value(td: &TokenData) -> bool {
    matches!(td,TokenData::AmountOfMoney(d) if d.value.is_some()||d.min_value.is_some()||d.max_value.is_some())
}
fn is_without_cents(td: &TokenData) -> bool {
    match td {
        TokenData::AmountOfMoney(d) => {
            d.currency != Currency::Cent && d.value.map(|v| v == v.floor()).unwrap_or(false)
        }
        _ => false,
    }
}
fn is_cents(td: &TokenData) -> bool {
    matches!(td,TokenData::AmountOfMoney(d) if d.currency==Currency::Cent&&d.value.is_some())
}

pub fn rules() -> Vec<Rule> {
    vec![
        Rule {
            name: "<unit> <amount>".to_string(),
            pattern: vec![predicate(is_currency_only), predicate(is_positive)],
            production: Box::new(|n| {
                let c = money_data(&n[0].token_data)?.currency;
                let v = numeral_data(&n[1].token_data)?.value;
                Some(TokenData::AmountOfMoney(
                    AmountOfMoneyData::currency_only(c).with_value(v),
                ))
            }),
        },
        Rule {
            name: "intersect (and number)".to_string(),
            pattern: vec![
                predicate(is_without_cents),
                regex("och"),
                predicate(is_natural),
            ],
            production: Box::new(|n| {
                let d = money_data(&n[0].token_data)?;
                let c = numeral_data(&n[2].token_data)?.value;
                Some(TokenData::AmountOfMoney(d.clone().with_cents(c)))
            }),
        },
        Rule {
            name: "about <amount-of-money>".to_string(),
            pattern: vec![
                regex("omkring|cirka|runt|ca"),
                predicate(is_money_with_value),
            ],
            production: Box::new(|n| Some(n[1].token_data.clone())),
        },
        Rule {
            name: "cent".to_string(),
            pattern: vec![regex("cents?|penn(y|ies)|öre")],
            production: Box::new(|_| {
                Some(TokenData::AmountOfMoney(AmountOfMoneyData::currency_only(
                    Currency::Cent,
                )))
            }),
        },
        Rule {
            name: "exactly <amount-of-money>".to_string(),
            pattern: vec![regex("exakt|precis"), predicate(is_money_with_value)],
            production: Box::new(|n| Some(n[1].token_data.clone())),
        },
        Rule {
            name: "intersect (X cents)".to_string(),
            pattern: vec![predicate(is_without_cents), predicate(is_cents)],
            production: Box::new(|n| {
                let d = money_data(&n[0].token_data)?;
                let c = money_data(&n[1].token_data)?.value?;
                Some(TokenData::AmountOfMoney(d.clone().with_cents(c)))
            }),
        },
        Rule {
            name: "NOK".to_string(),
            pattern: vec![regex("norska kronor|nkr")],
            production: Box::new(|_| {
                Some(TokenData::AmountOfMoney(AmountOfMoneyData::currency_only(
                    Currency::NOK,
                )))
            }),
        },
        Rule {
            name: "£".to_string(),
            pattern: vec![regex("pund?")],
            production: Box::new(|_| {
                Some(TokenData::AmountOfMoney(AmountOfMoneyData::currency_only(
                    Currency::Pound,
                )))
            }),
        },
        Rule {
            name: "intersect (and X cents)".to_string(),
            pattern: vec![
                predicate(is_without_cents),
                regex("och"),
                predicate(is_cents),
            ],
            production: Box::new(|n| {
                let d = money_data(&n[0].token_data)?;
                let c = money_data(&n[2].token_data)?.value?;
                Some(TokenData::AmountOfMoney(d.clone().with_cents(c)))
            }),
        },
        Rule {
            name: "intersect".to_string(),
            pattern: vec![predicate(is_without_cents), predicate(is_natural)],
            production: Box::new(|n| {
                let d = money_data(&n[0].token_data)?;
                let c = numeral_data(&n[1].token_data)?.value;
                Some(TokenData::AmountOfMoney(d.clone().with_cents(c)))
            }),
        },
        Rule {
            name: "SEK".to_string(),
            pattern: vec![regex("kr(onor)?")],
            production: Box::new(|_| {
                Some(TokenData::AmountOfMoney(AmountOfMoneyData::currency_only(
                    Currency::SEK,
                )))
            }),
        },
        Rule {
            name: "AED".to_string(),
            pattern: vec![regex("dirhams?")],
            production: Box::new(|_| {
                Some(TokenData::AmountOfMoney(AmountOfMoneyData::currency_only(
                    Currency::AED,
                )))
            }),
        },
    ]
}