rampion

z^z'

z^ω = ω
z^(ω ^(1 + α) * z') = z^(ω * ω^α * z') = (z^ω)^(ω^α * z') = ω^(ω^α * z')
(ω^α)^α' = ω^(α*α')

(ω * ω^α * x) ^ (ω * ω^β * y) = ω^((1+α) * ω^(1+β) * y)
x ^ (ω * ω^β * y) = (x^ω)^(ω^β * y) = ω^(ω^β * y)
(ω * ω^α * x) ^ y = ω * ω^α * ω * ω^α * ... ω * ω^α * x
                  = ω^((1+α)*y) * x

rampion

#include <iostream>
int main() {
  auto s = "Hello World\n";
  std::cout << s << s << s;
}

rampion

It's occasionally useful to consider a slightly richer function definition than ->, one where you can reason about the preimage of the function's codomain.

One approach is to bundle each -> with another function describing the preimage:

data Bidirectional p q a b = Bidirectional
  { forwards :: p a b
  , backwards :: q b a
  }

rampion

A couple months ago, I had an idea for a monad transformer, and sunk a good deal of time into figuring out how to make it work. I started getting it ready for Hackage before I realized I didn't have an immediate use case for it, and so I didn't have a good sense for what sensible defaults would be. I put the project aside to work on other things and let my brain churn on it.

What I'm going to do here is describe the idea and some implementation notes to get a sense of how useful it'd be as a package, so I know whether it's worth my time.

rampion

// !debit [field] [action] decrements [field] and runs [action] if [field] > 0
//
// examples (note the '\' to prevent the &{...} from running immediately)
//
//  !debit classactionresource1 %\{Coll|classaction1}
//
//  !debit repeating_classresources_-KBB1UHdMK0ygfFM3AtV_ClassResourceTotal %\{Coll|classaction2}
//
// (I don't know a better way to get repeating classaction ids than inspecting the page)
var DebitModule = DebitModule || (function(){ "use strict"; 

rampion

{-# LANGUAGE GADTs #-}                                                                                             
{-# LANGUAGE TypeFamilies #-}                                                                                      
{-# LANGUAGE DataKinds #-}                                                                                         
module Temp where                                                                                                  
                                                                                                                   
data A = A1 | A2                                                                                                   
data B = B1 | B2                                                                                                   
                                                                                                                   
data C (a :: A) (b :: B)where                                                                   

rampion

require 'set'

def ContextFreeGrammar(&blk)
  ContextFreeGrammar.new(&blk)
end

class ContextFreeGrammar
  attr_reader :rules
  def initialize(&blk)
    @rules = instance_eval(&blk)

rampion

" adapted from https://github.com/aaronjensen/vimfiles/blob/2a88ef0b92f5a628e898189e612eb0feb34b1419/vimrc#L449-483
" save as ~/.vim/plugin/bracketed_paste.vim to use

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Tmux wrapping borrowed from vitality.vim: https://github.com/sjl/vitality.vim
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
function WrapForTmux(s)
  if !exists('$TMUX')
    return a:s
  endif

rampion

dist
*.hi
*.o

rampion

{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE RankNTypes #-}
module Temp where

type Point f = forall a. a -> f a
data Nat = Z | S Nat