Skip to content

Instantly share code, notes, and snippets.

@kyleheadley
kyleheadley / hkt_tree.rs
Last active Mar 18, 2020
demo a struct that can be used with Rc or Arc pointer types
View hkt_tree.rs
use std::ops::Deref;
use std::rc::Rc;
use std::sync::Arc;
trait PtrFunc<A> {type Ptr:Sized+Clone+Deref+From<A>;}
struct RcPtr;
impl<A> PtrFunc<A> for RcPtr {type Ptr = Rc<A>;}
struct ArcPtr;
impl<A> PtrFunc<A> for ArcPtr {type Ptr = Arc<A>;}
@kyleheadley
kyleheadley / inherit.rs
Created Jan 4, 2018
A model for trait-based inheritance in Rust
View inherit.rs
//! Demo of static "inheritance"
//!
//! Use trait objects to get dynamic inheritance,
//! but casting to a subtype is not explored here
////////////////////////////////////////////////////////
// Define Base type, interface, and what is overloadable
////////////////////////////////////////////////////////
/// The main type that will be extended
@kyleheadley
kyleheadley / untyped_lambda.rs
Created Aug 2, 2017
Implement the untyped lambda calculus in the Rust type system.
View untyped_lambda.rs
#![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
kyleheadley / trati-dsl.rs
Created Nov 14, 2018
A lambda DSL embedded in Rust
View trati-dsl.rs
#![allow(unused)]
// Meta values and functions
// -------------------------
// Bool values
struct False;
struct True;
// Option values
@kyleheadley
kyleheadley / traitlang.rs
Created Nov 14, 2018
Example of typed functional programming in Rust's type-level language
View traitlang.rs
trait Nat {}
struct Zero;
impl Nat for Zero {}
struct Succ<N>(N);
impl<N:Nat> Nat for Succ<N> {}
type One = Succ <Zero >;
trait AddOne : Nat { type Result:Nat; }
impl<N:Nat> AddOne for N { type Result = Succ<N>; }
@kyleheadley
kyleheadley / as_trait.rs
Last active Apr 1, 2018
Demonstration of casting to multiple trait objects
View as_trait.rs
use std::thread;
use std::sync::Arc;
use std::sync::RwLock;
struct Wrap{one:usize,zero:usize}
trait WriteIt {
fn write1(&mut self,w:usize);
fn read1(&self) -> usize;
}
@kyleheadley
kyleheadley / functor.rs
Last active Feb 21, 2018
An implementation in Rust of the examples from the OCaml manual chapter on modules and funtors
View functor.rs
//! This file is a translation of the example code in the OCaml manual
//! chapter two,"The module system", into Rust code.
//!
//! The intent is to translate as directly as possible, to show OCaml
//! users a way to implement their functionality. This means that
//! later, more complex sections are neither idiomatic Rust nor a
//! perfect translation of the OCaml. Further study would be required,
//! but hopefully this helps explain some of the concepts.
//!
//! There are two constructs in Rust that might match OCaml modules,
@kyleheadley
kyleheadley / split_comma.rs
Last active Jan 2, 2018
Higher-order rust macro that assists in parsing by macro
View split_comma.rs
/// 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
kyleheadley / usez3.rs
Created Nov 11, 2017
Use pipes to communicate with z3 in rust
View usez3.rs
#![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")
@kyleheadley
kyleheadley / typeops.rs
Created Aug 1, 2017
Playing around with type-level operations in rust
View typeops.rs
#![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);
You can’t perform that action at this time.