gatlin

"Church-encoded" lists and their interesting properties
===

*This is a literate Haskell program which you can run in ghci.*
*Also, I already corrected a glaring problem. Let us speak no more of it.*

One of the beautiful things about computer science is that, fundamentally,
**data is code** and **code is data**. But what does that mean? And how is it
useful?

gatlin

What is a Church encoded data type?
===

I wrote a [post][listpost] about a really cool concept in computer science and
programming languages, but I fear that I may have gotten ahead of myself. It
turns out, Haskell is not so well known and notation was proving to be a
problem.

That and the concept is kind of a mind-bender.

gatlin

/*
 * Simple coroutine mechanism in C
 *
 * Inspired by / stolen from:
 *
 *     http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
 *
 * I found this very educational and wanted to publish a simple demonstration.
 *
 * Usage:

gatlin

Recursion

For more information, see also [this enlightening post on recursion][fuckyou]

It's fucking weird. It's also the crucial property of a language that makes it Turing-complete (that is, powerful enough to compute anything which can be computed). [^1] It's often baked into a language and while it works it makes no sense intuitively.

gatlin

#lang typed/racket

(provide None
         Just
         Opt
         maybe
         neq?
         Parser
         lit
         try-parse

gatlin

#!/usr/bin/env perl

use v5.20;
use Gtk3 -init;
use Image::PNG::QRCode qw(qrpng);
use File::Temp qw(tempfile);

my $sample_data = $ARGV[0] // "gatlin is so handsome";
my $scale       = 9;

gatlin

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}

import Prelude hiding (map)
import Pipes
import Pipes.Prelude (stdoutLn, map)
import Pipes.Interleave
import Network.Wreq
import qualified Data.ByteString.Lazy.Char8 as C
import qualified Data.ByteString.Char8 as SC

gatlin

{-# LANGUAGE DeriveFunctor #-}

module Main where

import Data.Char (toUpper)
import Prelude hiding (map, take, takeWhile, print, filter)
import Pipes
import Pipes.Prelude (map, fromHandle, toHandle, stdoutLn, filter, take, fold)
import Pipes.Lift
import System.Directory (getHomeDirectory, doesFileExist)

gatlin

withfeelingfn() {
    PREV_WITH_SUDO=$(history | tail -n2 | head -n1 | tr -s ' ' | cut -d' ' -f3- | awk '{print "sudo " $0}')
    command $PREV_WITH_SUDO
}
alias withfeeling=withfeelingfn

gatlin

{-# LANGUAGE DeriveFunctor #-}

import Control.Applicative hiding (many,optional)
import Data.Char
import Control.Monad.Free

newtype Parser s t = P {
    runParser :: [s] -> [(t, [s])]
}