dustinknopoff

type OptionBranch = Option<Box<Tree>>;

#[derive(Debug)]
struct Tree {
    data: i32,
    branches: (OptionBranch, OptionBranch)
}

impl Tree {
    fn new(data: i32) -> Self {

dustinknopoff

fn is_sorted(input: &str) -> bool {
    let input_iter: Vec<_> = input.chars().collect();
    let initial = input_iter[0];
    input
        .chars()
        .fold(Some(initial), |acc, current| {
            if acc != None {
                if Some(current) >= acc {
                    return Some(current)
                } else {

dustinknopoff

fn main() {
    fn fibo_fancy(val: i32) -> i32 {
        if val == 0 {
            return 0
        }
        (1..=val)
            .fold((None, None), |acc, curr| {
                let (m1, m2) = acc;
                if curr <= 2 {
                    match (m1, m2) {

dustinknopoff

{{$w := sub termWidth 200 -}}
{{ range .issues }}{{color "green+bh"}}{{.fields.issuetype.name | printf "%-12s" }}{{color "reset"}} {{color "yellow+bh"}}{{ .key | append ":" | printf "%-12s"}}{{color "reset"}} {{ .fields.summary | abbrev (sub $w 2) | printf (printf "%%-%ds" (sub $w 18)) }} {{color "blue+bh"}}{{if .fields.assignee }}{{.fields.assignee.name | printf "%12s" }}{{else}}<unassigned>{{end}}{{color "reset"}}
{{ end }}

dustinknopoff

# /Users/dknopoff/.config/tmuxinator/portal.yml

name: def
root: ~/Documents

# Optional tmux socket
# socket_name: foo

# Note that the pre and post options have been deprecated and will be replaced by
# project hooks.

dustinknopoff

use std::convert::TryFrom;

#[derive(Debug, Copy, Clone)]
enum HttpMethod {
    GET,
    POST,
    PUT
}

impl TryFrom<String> for HttpMethod {

dustinknopoff

use syntect::highlighting::ThemeSet;
use syntect::html::highlighted_html_for_string;
use syntect::parsing::SyntaxSet;

use pulldown_cmark::{html, CodeBlockKind, CowStr, Event, Options, Parser, Tag};

fn main() {
    // Setup for pulldown_cmark to read (only) from stdin
    let opts = Options::all();
    let input = String::from(

dustinknopoff

fn main() {  
    let n = 8;
    let mut blank = Vec::with_capacity(8);
    hanoi(n, &mut (0..8).collect(), &mut blank.clone(), &mut blank);
}

//if n > 0
// Hanoi(n − 1, src, tmp, dst) 〈〈Recurse!〉〉 
// move disk n from src to dst
// Hanoi(n − 1, tmp, dst, src) 〈〈Recurse!〉〉

dustinknopoff

use core::hash::Hash;
use std::sync::Arc;
use core::any::Any;
use core::any::TypeId;
use std::collections::HashMap;
use async_trait::async_trait; // 0.1.36
use tokio; // 0.2.21
use tokio::sync::RwLock;

// Our trait. The async part is not necessary, I just wanted to see how it behaves :) 

dustinknopoff

type TypeState = Distribute<keyof FlowMachineSchema["states"], FlowMachineContext> // assuming same context
export type Send = Interpreter<FlowMachineContext, FlowMachineSchema, FlowEvents, TypeState>['send']

export type Context = [
    State<FlowMachineContext, FlowEvents, FlowMachineSchema, TypeState>,
    Send,
    Interpreter<FlowMachineContext, FlowMachineSchema, FlowEvents, TypeState>
];

type Distribute<U, C> = U extends any ? { value: U; context: C } : never // util