# rust-mdo

**Repository Path**: mirrors_TeXitoi/rust-mdo

## Basic Information

- **Project Name**: rust-mdo
- **Description**: Monadic do notation for rust using macro and duck typing
- **Primary Language**: Unknown
- **License**: WTFPL
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-18
- **Last Updated**: 2025-12-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Rust mdo [![Build Status](https://travis-ci.org/TeXitoi/rust-mdo.svg?branch=master)](https://travis-ci.org/TeXitoi/rust-mdo)

## Presentation

Rust mdo is a monadic do notation using macros and duck typing.  It
provides a syntax extension providing something that looks like the
Haskell do notation, and rewrites it using a `bind` function.  Some
functions are provided for a number of common monadic structures.

## Example

Add to your `Cargo.toml`:
```toml
[dependencies]
mdo = "*"
```

```rust
#[macro_use] extern crate mdo;

fn main() {
    // exporting the monadic functions for the Iterator monad (similar
    // to list comprehension)
    use mdo::iter::{bind, ret, mzero};

    // getting the list of (x, y, z) such that
    //  - 1 <= x <= y < z < 11
    //  - x^2 + y^2 == z^2
    let l = bind(1i32..11, move |z|
                 bind(1..z, move |x|
                      bind(x..z, move |y|
                           bind(if x * x + y * y == z * z { ret(()) }
                                else { mzero() },
                                move |_|
                                ret((x, y, z))
                                )))).collect::<Vec<_>>();
    println!("{:?}", l);

    // the same thing, using the mdo! macro
    let l = mdo! {
        z =<< 1i32..11;
        x =<< 1..z;
        y =<< x..z;
        when x * x + y * y == z * z;
        ret ret((x, y, z))
    }.collect::<Vec<_>>();
    println!("{:?}", l);
}
```

## Documentation

You can find the rustdoc [here](https://texitoi.eu/rust/mdo/).

## Supported monads

This library provides definitions for the following monads:
  - `Option`
  - `Iterator`
  - `Result` (without error conversion)
  
Other implementations in external crates:
  - `Future` in [mdo-future](https://crates.io/crates/mdo-future)

## License

This work is free. You can redistribute it and/or modify it under the
terms of the Do What The Fuck You Want To Public License, Version 2,
as published by Sam Hocevar. See the COPYING file for more details.