hypercpu 0.0.2

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
65
66

use crate::Moment;
use async_trait::async_trait;

/// 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.
#[derive(Clone)]
pub struct If<C: Moment<Value = bool>, T: Moment, F: Moment> {
  pub(crate) condition: C,
  pub(crate) then: T,
  pub(crate) 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,
    }
  }

  /// Tries to get the `then` calculation.
  pub async fn to_then(self) -> Option<T> {
    if self.condition.resolve().await {
      Some(self.then)
    } else {
      None
    }
  }

  /// Tries to get the `otherwise` calculation.
  pub async fn to_otherwise(self) -> Option<F> {
    if !self.condition.resolve().await {
      Some(self.otherwise)
    } else {
      None
    }
  }
}

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

  async fn resolve(self) -> Self::Value {
    If::new(
      self.condition,
      self.then.resolve().await,
      self.otherwise.resolve().await,
    )
  }
}