gpt3_rs 0.3.0

An API wrapper for OpenAi's gpt-3
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

use std::ops::Deref;

use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
/// Convenience type to allow using `&[&str]` instead of `Vec<String>` on the builder methods.
///
/// # Example
/// allows:
/// ```ignore
/// &["some", "thing"]
/// ```
/// instead of: 
/// ```ignore
/// vec!["some".into(), "thing".into()]
/// ```
pub struct IntoVec<T>(Vec<T>);

impl From<&[&str]> for IntoVec<String> {
    fn from(from: &[&str]) -> Self {
        IntoVec(from.iter().cloned().map(ToOwned::to_owned).collect())
    }
}
impl From<&&[&str]> for IntoVec<String> {
    fn from(from: &&[&str]) -> Self {
        IntoVec(from.iter().cloned().map(ToOwned::to_owned).collect())
    }
}
impl<const N: usize> From<&[&str; N]> for IntoVec<String> {
    fn from(from: &[&str; N]) -> Self {
        IntoVec(from.iter().cloned().map(ToOwned::to_owned).collect())
    }
}
impl From<Vec<&str>> for IntoVec<String> {
    fn from(from: Vec<&str>) -> Self {
        IntoVec(from.into_iter().map(ToOwned::to_owned).collect())
    }
}
impl From<&[&[&str]]> for IntoVec<Vec<String>> {
    fn from(from: &[&[&str]]) -> Self {
        IntoVec(
            from.iter()
                .cloned()
                .map(|rest| rest.iter().cloned().map(ToOwned::to_owned).collect())
                .collect(),
        )
    }
}
impl<const N1: usize, const N2: usize> From<&[&[&str; N1]; N2]> for IntoVec<Vec<String>> {
    fn from(from: &[&[&str; N1]; N2]) -> Self {
        IntoVec(
            from.iter()
                .cloned()
                .map(|rest| rest.iter().cloned().map(ToOwned::to_owned).collect())
                .collect(),
        )
    }
}
impl From<&&[&&[&str]]> for IntoVec<Vec<String>> {
    fn from(from: &&[&&[&str]]) -> Self {
        IntoVec(
            from.iter()
                .cloned()
                .map(|rest| rest.iter().cloned().map(ToOwned::to_owned).collect())
                .collect(),
        )
    }
}
impl From<Vec<Vec<&str>>> for IntoVec<Vec<String>> {
    fn from(from: Vec<Vec<&str>>) -> Self {
        IntoVec(
            from.into_iter()
                .map(|rest| rest.into_iter().map(ToOwned::to_owned).collect())
                .collect(),
        )
    }
}
impl<T> Deref for IntoVec<T> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}