kyleheadley

use std::fmt::Display;

trait Monadic {}
#[derive(Debug)]
struct Monad<M:Monadic,T>(M,T);

#[derive(Debug)]
struct Opt(bool);
impl Monadic for Opt {}
impl<T:Default> Monad<Opt,T> {

kyleheadley

CSCI 7000 -- Course Project Proposal

Student name: Kyle Headley

Project Description:

• Project kind: IC library implementation
• Project details: Extend the rust implementation of the RAZ with additional incremental features.

kyleheadley

#![allow(unused)]

use std::fmt::Debug;

#[derive(Debug)]
struct Door<S: DoorState> {
    state: S,
}

trait DoorState {}

kyleheadley

trait F<V,X> {}

struct D;

trait TheV2 {
    type IsThis;
}

impl<V1,V2> TheV2 for F<V1,V2> {
    type IsThis = V2;

kyleheadley

// emulates the type of a function from types 'E' to sequence-like types
pub trait SeqTypeFn<E> { type Result : SeqLike<E>; }

// sequence-like interface
pub trait SeqLike<E>{
    fn new() -> Self;
    fn push(self,e:E) -> Self;
    fn first(&self) -> Option<&E>;
}

kyleheadley

#![allow(dead_code)]
struct True;
struct False;
impl IsEqual<False> for True {type Out=False;}
impl IsEqual<False> for False {type Out=True;}
impl IsEqual<True> for True {type Out=True;}
impl IsEqual<True> for False {type Out=False;}

trait Nat {fn inst()->usize;}
struct Zero;

kyleheadley

#![allow(unused)]
#![feature(non_ascii_idents)]
// #![feature(conservative_impl_trait)]

// basic nats, my knowledge
mod nat {
  pub trait Nat { fn to_usize() -> usize; }
  pub struct Zero;
  impl Nat for Zero { fn to_usize() -> usize { 0 } }
  pub struct Succ<N>(pub N);

kyleheadley

#![allow(unused)]
//#![feature(optin_builtin_traits)]

// Booleans
struct True;
struct False;
trait BoolOr<B> {type BoolOr;}
impl<B> BoolOr<B> for True {type BoolOr=True;}
impl BoolOr<True> for False {type BoolOr=True;}
impl BoolOr<False> for False {type BoolOr=False;}

kyleheadley

/// Higher-order macro fold function for pre-parsing comma separated lists
///
/// The commas on KEYWORD lines can be changed to parse lists with any
/// separator. 

/// run a macro on a list of lists after splitting the input at commas
macro_rules! split_comma {
    // no defaults
    {$fun:ident <= $($item:tt)*} => {
        split_comma![$fun () () () <= $($item)*]

kyleheadley

#![allow(unused)]
use std::error::Error;
use std::io::prelude::*;
use std::process::{Command, Stdio};
use std::str;

fn main() {
    let process = match Command::new("z3")
    // use any z3 language with another .arg() here
    .arg("-in")