overload-strings 0.1.0

Haskell OverloadedStrings for Rust (using Into)
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

#![feature(plugin, type_ascription)]
#![plugin(overload_strings)]
#![allow(dead_code)]

pub mod fns {
    use std::borrow::Cow;

    pub fn takes_string(s: String) -> String {
        s
    }

    pub fn takes_str(s: &str) -> String {
        s.to_owned()
    }

    pub fn takes_cow(s: Cow<str>) -> String {
        s.into_owned()
    }

    pub fn takes_into_string<I: Into<String>>(s: I) -> String {
        s.into()
    }
}

#[overload_strings]
mod foo {
    use fns::*;

    static DONT_TOUCH: &'static str = "foo";
    const DONT_TOUCH_EITHER: &'static str = "foo";

    #[overload_strings] // the duplicate annotation is ignored
    pub fn concat_it() -> String {
        takes_str("Hello") +
        &takes_string(", ") +
        &takes_cow("World") +
        // this one can't be inferred, so use ascription
        &takes_into_string("!\n": &str)
    }
}

#[overload_strings]
mod bar {
    mod sub {
        use fns::*;

        fn bar() {
            // this compiles because we don't recurse overloading into submodules
            takes_into_string("...");
        }
    }
}

#[test]
fn test_main() {
    assert_eq!(foo::concat_it(), "Hello, World!\n");
}