https://github.com/TeXitoi/rust-mdo

Monadic do notation for rust using macro and duck typing
https://github.com/TeXitoi/rust-mdo

Last synced: 2 months ago
JSON representation

Monadic do notation for rust using macro and duck typing

• Host: GitHub
• URL: https://github.com/TeXitoi/rust-mdo
• Owner: TeXitoi
• License: wtfpl
• Created: 2014-08-03T22:34:45.000Z (over 10 years ago)
• Default Branch: master
• Last Pushed: 2019-05-30T13:57:48.000Z (over 5 years ago)
• Last Synced: 2024-04-20T06:39:53.940Z (9 months ago)
• Language: Rust
• Homepage:
• Size: 32.2 KB
• Stars: 223
• Watchers: 6
• Forks: 9
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • License: COPYING

Awesome Lists containing this project

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::>();

    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::>();

    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.