layered-nlp 0.1.1

Highly-flexible data-oriented NLP framework
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

use super::{LLLine, ToIdx, XDirection, XMatch};

pub trait AnyOf {
    type Out;

    fn into_any(self) -> Self::Out;
}

impl<A, B> AnyOf for (A, B) {
    type Out = AnyOf2Matcher<A, B>;

    fn into_any(self) -> Self::Out {
        AnyOf2Matcher(self.0, self.1)
    }
}

impl<A, B, C> AnyOf for (A, B, C) {
    type Out = AnyOf3Matcher<A, B, C>;

    fn into_any(self) -> Self::Out {
        AnyOf3Matcher(self.0, self.1, self.2)
    }
}

pub struct AnyOf2Matcher<A, B>(pub A, pub B);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AnyOf2<A, B> {
    A(A),
    B(B),
}

impl<'l, A: XMatch<'l>, B: XMatch<'l>> XMatch<'l> for AnyOf2Matcher<A, B> {
    type Out = AnyOf2<A::Out, B::Out>;

    fn go<M>(&self, direction: &M, ll_line: &'l LLLine) -> Vec<(Self::Out, ToIdx)>
    where
        M: XDirection<'l>,
    {
        let a = self.0.go(direction, ll_line);

        if !a.is_empty() {
            a.into_iter().map(|(a, idx)| (AnyOf2::A(a), idx)).collect()
        } else {
            self.1
                .go(direction, ll_line)
                .into_iter()
                .map(|(b, idx)| (AnyOf2::B(b), idx))
                .collect()
        }
    }
}

pub struct AnyOf3Matcher<A, B, C>(pub A, pub B, pub C);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AnyOf3<A, B, C> {
    A(A),
    B(B),
    C(C),
}

impl<'l, A: XMatch<'l>, B: XMatch<'l>, C: XMatch<'l>> XMatch<'l> for AnyOf3Matcher<A, B, C> {
    type Out = AnyOf3<A::Out, B::Out, C::Out>;

    fn go<M>(&self, direction: &M, ll_line: &'l LLLine) -> Vec<(Self::Out, ToIdx)>
    where
        M: XDirection<'l>,
    {
        let a = self.0.go(direction, ll_line);

        if !a.is_empty() {
            a.into_iter().map(|(a, idx)| (AnyOf3::A(a), idx)).collect()
        } else {
            let b = self.1.go(direction, ll_line);

            if !b.is_empty() {
                b.into_iter().map(|(b, idx)| (AnyOf3::B(b), idx)).collect()
            } else {
                self.2
                    .go(direction, ll_line)
                    .into_iter()
                    .map(|(c, idx)| (AnyOf3::C(c), idx))
                    .collect()
            }
        }
    }
}