hypercpu 0.0.1

Distributed symbolic computation
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

use crate::Moment;
use async_trait::async_trait;
use either::Either;

/// A conditional calculation.
/// 
/// This struct allows you to branch calculations based
/// on a condition. Both sides are still optimized, but
/// only one side will be fully resolved.
pub struct If<C: Moment<Value = bool>, T: Moment, F: Moment> {
  condition: C,
  then: T,
  otherwise: F,
}

impl<C: Moment<Value = bool>, T: Moment, F: Moment> If<C, T, F> {
  /// Create a new `If` struct.
  /// 
  /// This will branch the calculation based on the
  /// condition. If the condition is true, the `then`
  /// calculation will be resolved. Otherwise, the
  /// `otherwise` calculation will be resolved.
  pub fn new(condition: C, then: T, otherwise: F) -> Self {
    Self {
      condition,
      then,
      otherwise,
    }
  }
}

#[async_trait]
impl<C, T, F> Moment for If<C, T, F>
where
  C: Moment<Value = bool>,
  T: Moment,
  F: Moment
{
  type Value = Either<T, F>;

  async fn resolve(self) -> Self::Value {
    if self.condition.resolve().await {
      Either::Left(self.then)
    } else {
      Either::Right(self.otherwise)
    }
  }
}

#[async_trait]
impl<L, R> Moment for Either<L, R>
where
  L: Moment,
  R: Moment
{
  type Value = Either<L::Value, R::Value>;

  async fn resolve(self) -> Self::Value {
    match self {
      Either::Left(l) => Either::Left(l.resolve().await),
      Either::Right(r) => Either::Right(r.resolve().await),
    }
  }
}