mnemnion

local Sparse = {}

local function new(dimension)
   local sparse = {}
   sparse._dimension = dimension
   return setmetatable(sparse, Sparse)
end

function Sparse.__index(sparse, key)
   if sparse._dimension == 1 then

mnemnion

#! /bin/bash
# Usage:
# ./git-move.sh path1/ path2/...  path/to/destination/repo
args=("$@")

# All but last argument:
paths=("${args[@]::${#args[@]}-1}")
# Last argument:
dest="${args[${#args[@]}-1]}"

mnemnion

Keybase proof

I hereby claim:

• I am mnemnion on github.
• I am atman (https://keybase.io/atman) on keybase.
• I have a public key ASAWKn9EMHtlfAZz2a4lbuFStIGWdm56UzfAcl7--TsUwwo

To claim this, I am signing this object:

mnemnion

// instead of having to do this all the time:

let maybe_utf8 = match stream.fill_buf() {
        Ok(filehandle) => filehandle,
        Err(_) => return captures,
    };
let phrase = match from_utf8(maybe_utf8) {
        Ok(utf8) => String::from(utf8),
        Err(_) => return captures,
    };

mnemnion

#Essential jump code
export MARKPATH=$HOME/.marks

#jump to a directory
function jump {
    cd -P "$MARKPATH/$1" 2>/dev/null || echo "No such mark: $1"
}

#mark the current directory as a jump destination
function mark {

mnemnion

#lazyfuncs for dotting and undotting stuff
function dt {
	for file in "$@"; do
		if [[ ${file:0:1} != "." ]]
			then mv $file ".$file"
			else echo "$file is already dotted"
		fi
	done
}

mnemnion

package main

import "fmt"
import "github.com/pointlander/peg"

type pegger peg.Peg {
	fmt.Printf("hi")
}

func main() {

mnemnion

function advise (adviceFn, ogFn) 
	return function (...) adviceFn(unpack(arg)) ogFn(unpack(arg)) end
end

function foo (x) 
	print ("foo") 
	print (x)
end

mnemnion

use std::fmt;

const FORMATTER: &'static str = "{}" ;

fn main() {

    let x = 5i;
    println! (FORMATTER, x);

}

mnemnion

type Cell = u32 ;

type Kilo = u32 ;
fn main() {
    let x: Cell = 5 ;
    let y: Kilo = 10 ;
    let z = x + y ;
    println!("Cell is {}, Kilo is {}, Nonsense is {}", x, y, z);

}