Skip to content

Instantly share code, notes, and snippets.

Kyle Headley kyleheadley

Block or report user

Report or block kyleheadley

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
@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 / hkt_tree.rs
Last active Feb 10, 2019
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 / 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 / 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 / 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 / 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 / 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 / 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.