# SOD: Service-Oriented Design

## Overview

This crate provides `Service`, `MutService`, and `AsyncService` traits and associated utilities to facilitiate [service-oriented design](https://en.wikipedia.org/wiki/Service-orientation_design_principles).
These traits and tools in this library provide concrete guidelines to help make a service-oriented design successful.

In the context of this crate, a service is simply a trait that accepts an input and produces a result.
Traits can be composed or chained together using the `ServiceChain` found in this crate.

This crate in and of itself does not provide mechanisms to expose services on a network or facilitiate service discovery.
Those implementation details are to be provided in `sod-*` crates, which will often simply encapsulate other open source libraries to expose them as services.
Instead, this crate provides the core mechanisms to define services and in a way that helps guarantee they will be interoperable with one another at a library level.

## Example

```rust
use sod::{Service, ServiceChain};

// define a service, which adds a constant number to the input, producing the result as output
struct AddService {
    n: usize,
}
impl AddService {
    pub fn new(n: usize) -> Self {
        Self { n }
    }
}
impl Service for AddService {
    type Input = usize;
    type Output = usize;
    type Error = ();
    fn process(&self, input: usize) -> Result<usize, ()> {
        Ok(input + self.n)
    }
}

// chain together multiple add services, where each service's output is processed as the next service's input
let chain = ServiceChain::start(AddService::new(1))
    .next(AddService::new(2))
    .next(AddService::new(4))
    .end();

// pass 100 to the service chain, which should result in `100 + 1 + 2 + 4 = 107`
let result = chain.process(100).unwrap();
assert_eq!(107, result);
```