Bike Math!

## io.hs
{-# LANGUAGE RankNTypes #-}

import Prelude hiding (IO, getLine)
import qualified Prelude as P
import System.IO.Unsafe

-- * The Foreign Function Interface

-- | FFI values permit interfacing with foreign functions, such as low-level IO
-- operations, memory management operations, or bindings to other user-level

## install-arch-linux-rpi-zero-w.sh
#!/bin/sh -exu
dev=$1
cd $(mktemp -d)

function umountboot {
    umount boot || true
    umount root || true
}

# RPi1/Zero (armv6h):

## free-compiler.hs
{-|
 - Example of using free constructions to build a flexible little compiler.
 -
 - The goal here is not necessarily efficiency but readability and flexibility.
 -
 - The language grammar is represented by an ADT; however, instead of
 - recursively referring to itself it instead references a type variable.
 -
 - We derive instances of 'Functor' and 'Traversable' for this type.
 -

## index.html
<!DOCTYPE html>
<html>
    <head>
        <title>Large Type</title>
        <link rel="stylesheet/less" type="text/css" href="style.less">
        <script type="text/javascript" src="lib/jquery-2.1.4.min.js"></script>
        <script type="text/javascript" src="lib/less.min.js"></script>
    </head>
    <body>
        <div class="out"><span contenteditable autofocus>*hello*</span></div>

## yet-another-conway.hs
{-# LANGUAGE DeriveFunctor #-}

import Control.Applicative
import Control.Comonad

import Control.Monad (forM_)

-- These two typeclasses probably make some people groan.
class LeftRight t where
    left :: t a -> t a

## markov.py
###
# Markov models!
#
# A Markov model of some process is a model of different states you can be in,
# where each state links to other states. These links are weighted by some
# probability score. Markov models are designed to model systems where future
# states depend only on the present state.
#
# In the case of words you may define "present state" to be "the current word,"
# or perhaps "the last 3 words."

## audio
#!/bin/bash

###
# Script to launch jackd and reroute PulseAudio through it. And optionally
# start fluidsynth.
#
# READ THE NOTES PLEASE

###
# Usage (assuming this script is named `audio`, is in your PATH, and is

## output.txt
Code: (+ 5 5)
Free (AApp (Free (ASymbol "+")) [Free (ANumber 5),Free (ANumber 5)])
---
Code: (lambda (x) (* x x))
Free (ALambda [Free (ASymbol "x")] (Free (AApp (Free (ASymbol "*")) [Free (ASymbol "x"),Free (ASymbol "x")])))
---
Code: ((\ (x) (* x x)) 5 (+ 10 2))
Free (AApp (Free (ALambda [Free (ASymbol "x")] (Free (AApp (Free (ASymbol "*")) [Free (ASymbol "x"),Free (ASymbol "x")])))) [Free (ANumber 5),Free (AApp (Free (ASymbol "+")) [Free (ANumber 10),Free (ANumber 2)])])
---
Code: '(1 2 3)

## pid.lhs
PID controller in Haskell
===

A major project I want to embark on at some point in the future is making a
quadrotor. I've made one before but I was at the mercy of a lot of off-the-shelf
software that I'm not altogether sure was entirely correct, either.

So I want to eventually program a quadrotor (or similarly awesome robot thing)
and I would really enjoy doing it in Haskell. It has a low footprint and is
already used in other real time settings.

## bikemath.md

      
        
          
            
              
              1 file
            
          
          
            
              
              0 forks
            
          
          
            
              
              2 comments
            
          
          
            
              
              0 stars
            
          
        

        
          
              
              gatlin
            / bikemath.md
          
          
            Last active Apr 21, 2018
          
        
      
        
    
      View bikemath.md
  
    
  
    Bike Math!
Note: For the sake of clarity I'll probably write things you already know.
It's just as much to eliminate communication errors as it is for me to keep
track of what the fuck I'm even talking about. It does not imply any kind of
judgment of what I assume about you :)
Here's the math behind gears and how they are used to efficiently rotate
wheels. The same principles underlie how cars work but the mechanisms are