holmes 0.1.0

Holmes Inference System
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

#[macro_use]
extern crate holmes;
use holmes::simple::*;

#[test]
pub fn register_where_rule() {
    single(&|holmes: &mut Engine, core: &mut Core| {
        holmes_exec!(holmes, {
      predicate!(test_pred(string, bytes, uint64));
      rule!(test_pred(("bar"), (vec![2u8,2u8]), x) <= test_pred(("foo"), [_], x), {
        let (42) = (42)})
    })?;
        core.run(holmes.quiesce()).unwrap();
        Ok(())
    })
}

#[test]
pub fn where_const() {
    single(&|holmes: &mut Engine, core: &mut Core| {
        try!(holmes_exec!(holmes, {
      predicate!(test_pred(string, bytes, uint64));
      rule!(test_pred(("bar"), (vec![2u8,2u8]), x) <= test_pred(("foo"), [_], [_]), {
          let x = (42)
      });
      fact!(test_pred("foo", vec![0u8,1u8], 16))
    }));
        core.run(holmes.quiesce()).unwrap();
        assert_eq!(query!(holmes, test_pred(("bar"), x, y)).unwrap(),
               vec![vec![vec![2u8,2u8].to_value(), 42.to_value()]]);
        Ok(())
    })
}

#[test]
pub fn where_plus_two() {
    single(&|holmes: &mut Engine, core: &mut Core| {
        try!(holmes_exec!(holmes, {
      predicate!(test_pred(string, bytes, uint64));
      func!(let plus_two : uint64 -> uint64 = |v : &u64| {v + 2});
      rule!(test_pred(("bar"), (vec![2u8,2u8]), y) <= test_pred(("foo"), [_], x), {
        let y = {plus_two([x])}
      });
      fact!(test_pred("foo", vec![0u8,1u8], 16))
    }));
        core.run(holmes.quiesce()).unwrap();
        assert_eq!(query!(holmes, test_pred(("bar"), x, y)).unwrap(),
               vec![vec![vec![2u8,2u8].to_value(), 18.to_value()]]);
        let res: Result<()> = Ok(());
        res
    })
}

#[test]
pub fn where_destructure() {
    single(&|holmes: &mut Engine, core: &mut Core| {
        try!(holmes_exec!(holmes, {
      predicate!(test_pred(uint64, bytes, uint64));
      func!(let succs : uint64 -> (uint64, uint64) = |n : &u64| {
        (n + 1, n + 2)
      });
      rule!(test_pred(y, (vec![2u8,2u8]), z) <= test_pred((3), [_], x), {
        let {y, z} = {succs([x])}
      });
      fact!(test_pred(3, vec![0u8,1u8], 16))
    }));
        core.run(holmes.quiesce()).unwrap();
        assert_eq!(query!(holmes, test_pred(y, (vec![2u8,2u8]), z)).unwrap(),
               vec![vec![17.to_value(), 18.to_value()]]);
        Ok(())
    })
}

#[test]
pub fn where_iter() {
    single(&|holmes: &mut Engine, core: &mut Core| {
        try!(holmes_exec!(holmes, {
      predicate!(test_pred(uint64, bytes, uint64));
      func!(let succs : uint64 -> [uint64] = |n : &u64| {
        vec![n + 1, n + 2]
      });
      rule!(test_pred((4), (vec![2u8,2u8]), y) <= test_pred((3), [_], x), {
        let [y] = {succs([x])}
      });
      fact!(test_pred(3, vec![0u8,1u8], 16))
    }));
        core.run(holmes.quiesce()).unwrap();
        assert_eq!(query!(holmes, test_pred([_], (vec![2u8,2u8]), x)).unwrap(),
               vec![vec![17.to_value()], vec![18.to_value()]]);
        Ok(())
    })
}