aisil 0.3.2

A lightweight framework to define APIs as types
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

//! Map errors of APIs with [`Into`].

use crate::{HasMethod, ImplsMethod, IsApi};
use core::marker::PhantomData;
use documented::DocumentedOpt;

/// Combinator to cast errors with [`Into`]
///
/// Both **API** combinator and **implementor** combinator.
#[repr(transparent)]
pub struct ErrInto<ErrO, B>(pub B, PhantomData<ErrO>);

impl<ErrO, B> ErrInto<ErrO, B> {
  pub fn new(b: B) -> Self {
    Self(b, PhantomData)
  }
}

impl<API: IsApi, ErrO> IsApi for ErrInto<ErrO, API> {
  type Methods = API::Methods;
  const API_NAME: &str = API::API_NAME;
  const API_VERSION: &str = API::API_VERSION;
}

impl<ErrO, API: DocumentedOpt> DocumentedOpt for ErrInto<ErrO, API> {
  const DOCS: Option<&str> = API::DOCS;
}

impl<M, R, ErrI, ErrO, API> HasMethod<M> for ErrInto<ErrO, API>
where
  API: HasMethod<M, Res = Result<R, ErrI>>,
{
  type Res = Result<R, ErrO>;
  const METHOD_NAME: &str = API::METHOD_NAME;
  const METHOD_DOCS: Option<&str> = API::METHOD_DOCS;
}

impl<API, M, B, R, ErrO, ErrI> ImplsMethod<ErrInto<ErrO, API>, M> for ErrInto<ErrO, B>
where
  ErrO: From<ErrI> + Send + Sync,
  B: ImplsMethod<API, M> + Send + Sync,
  API: HasMethod<M, Res = Result<R, ErrI>>,
  M: Send + Sync,
{
  async fn call_api(&self, req: M) -> Result<R, ErrO> {
    self.0.call_api(req).await.map_err(Into::into)
  }
}

#[cfg(test)]
mod test {
  #![allow(dead_code)]
  use super::*;
  struct SomeApi;
  crate::define_api! {SomeApi => {
    "foo", Foo => Result<(), ErrI>;
    "bar", Bar => Result<(), ErrI>;
  }}

  struct Foo;
  struct Bar;
  struct ErrI;
  struct ErrO;

  impl From<ErrI> for ErrO {
    fn from(_: ErrI) -> ErrO {
      ErrO
    }
  }

  struct SomeImpl;
  impl ImplsMethod<SomeApi, Foo> for SomeImpl {
    async fn call_api(&self, _: Foo) -> Result<(), ErrI> {
      Err(ErrI)
    }
  }

  impl ImplsMethod<SomeApi, Bar> for SomeImpl {
    async fn call_api(&self, _: Bar) -> Result<(), ErrI> {
      Err(ErrI)
    }
  }

  async fn test() {
    let _: Result<_, ErrI> = SomeImpl.call_api(Foo).await;
    let _: Result<_, ErrO> = ErrInto::<ErrO, _>::new(SomeImpl).call_api(Foo).await;
    type WSomeApi = ErrInto<ErrO, SomeApi>;
  }
}