tonymorris

using System;
using System.Collections;
using System.Collections.Generic;

/*
A basic lens library for the purpose of demonstration.
Implements a lens as the costate comonad coalgebra.

This library is not complete.
A more complete lens library would take from

jestan

Systems Thinking

• "The Fifth Discipline", by Peter Senge (http://amzn.to/H7R4fp)
• "Lean Thinking", by James Womack (http://amzn.to/H7R9zK)
• "The Logic of Failure", by Dietrich Dorner (http://amzn.to/HyheLM)
• "Drift Into Failure", by Sidney Dekker (http://amzn.to/HpB8Fe)

Software Architecture & Methods

• "Documenting Software Architecture", by Paul Clements (http://amzn.to/H7RtOP)

puffnfresh

// Compiles fine even though the code is broken.
// This is because arrays are covariant and mutable.
//
// TypeScript team: Please fix either of those things. Preferably mutability :)

class Animal {}

class Snake extends Animal {
    slither() {
        alert("Slithering!")

ekmett

-- e
> let z a b c d w@(x:y)=let t=a`div`c in if all(>0)[a,b,c,d]&&t==b`div`d then t:z(10*(a-c*t))(10*(b-d*t))c d w else z(x*a+b)a(x*c+d)c y;f n=1:1:n:f(n+2)in z 1 0 0 1(2:1:2:f 4)>>=show
> let z a b c d w@(x:y)|t<-a`div`c=if all(>0)[a,b,c,d]&&t==b`div`d then t:z(10*(a-c*t))(10*(b-d*t))c d w else z(x*a+b)a(x*c+d)c y;f n=1:1:n:f(n+2)in z 1 0 0 1(2:1:2:f 4)>>=show
> let z a b c d w@(x:y)|all(>0)[a,b,c,d]&&t==b`div`d|True=t:z(10*(a-c*t))(10*(b-d*t))c d w else z(x*a+b)a(x*c+d)c y where t=a`div`c;f n=1:1:n:f(n+2)in z 1 0 0 1(2:1:2:f 4)>>=show
> let z a b c d w@(x:y)|all(>0)[a,b,c,d]&&t==b`div`d=t:z(10*(a-c*t))(10*(b-d*t))c d w|True=z(x*a+b)a(x*c+d)c y where{t=a`div`c};f n=1:1:n:f(n+2)in z 1 0 0 1(2:1:2:f 4)>>=show
> let f n=1:1:n:f(n+2);z a b c d w@(x:y)|t<-a`div`c,all(>0)[a,b,c,d]&&t==b`div`d=t:z(10*(a-c*t))(10*(b-d*t))c d w|True=z(x*a+b)a(x*c+d)c y in z 1 0 0 1(2:1:2:f 4)>>=show
> let f n=1:1:n:f(n+2);z a b c d w@(x:y)|any(<=0)[a,b,c,d]||t/=b`div`d=z(x*a+b)a(x*c+d)c y|t<-a`div`c=t:z(10*(a-c*t))(10*(b-d*t))c d w 

ymasory

Please help compile a list of all Scala-related IRC rooms.

All of these channels are on Freenode.

#akka              | concurrency & distribution framework
#argonaut          | json library
#fp-in-scala       | the book Functional Programming in Scala
#geotrellis        | geoprocessing library
#indyscala         | regional scala group
#json4s            | json library

t0yv0

Require Import Utf8.

Inductive subtype (a b : Set) : Set :=
| ST : (a -> b) -> subtype a b.

Infix ":>" := subtype (at level 50).

Definition st {x y} f := ST x y f.

Definition unpack {a b : Set} (st : a :> b) :=

dkhenry

[Unit]
Description=Play2 Server for <site>
After=network.target
 
[Service]
Type=simple
PIDFile=<path>/RUNNING_PID
 
ExecStartPre=/bin/sh -c 'cd <path> ;/bin/rm RUNNING_PID ; sbt clean compile stage'
ExecStart=<path>/target/start

rodneyrehm

// ==UserScript==
// @name anti key-grabber
// @description Prevent web apps from capturing and muting vital keyboard shortcuts
// @grant none
// @version 1.1
// ==/UserScript==
(function(){
var isMac = unsafeWindow.navigator.oscpu.toLowerCase().contains("mac os x");
unsafeWindow.document.addEventListener('keydown', function(e) {
  if (e.keyCode === 116) {

twanvl

module Sorting where
-- See https://www.twanvl.nl/blog/agda/sorting

open import Level using () renaming (zero to ℓ₀;_⊔_ to lmax)
open import Data.List hiding (merge)
open import Data.List.Properties
open import Data.Nat hiding (_≟_;_≤?_)
open import Data.Nat.Properties hiding (_≟_;_≤?_;≤-refl;≤-trans)
open import Data.Nat.Logarithm
open import Data.Nat.Induction

tonymorris

sealed trait IOOperation[A] {
  def map[B](f: A => B): IOOperation[B] =
    this match {
      case PutChar(c, a) => 
        PutChar(c, f(a))
      case GetChar(g) =>
        GetChar(f compose g)
    }
}
case class PutChar[A](c: Char, a: A) extends IOOperation[A]