siraben

import Control.Monad

-- Replace T and S with any types that have monad instances.
type T a = [a]
type S a = Maybe a

-- But you must provide the l function (with the following type) to
-- make the rest of the code work.
l :: T (S a) -> S (T a)
l x = etaS (do {Just v <- x; return v})

siraben

{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}

data Term
  = Con Integer
  | Div Term Term
  deriving (Show, Eq)

data Exc e a

siraben

{-# LANGUAGE FlexibleInstances, OverlappingInstances #-}
{-# LANGUAGE UndecidableInstances, MultiParamTypeClasses #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DeriveFunctor #-}

module ALaCarte where
import qualified Prelude (getChar, getLine, putChar, readFile, writeFile)
import Prelude hiding (getChar, getLine, putChar, readFile, writeFile)

siraben

{-# LANGUAGE FlexibleContexts #-}

--  Karplus-Strong using infinite lists
import Control.Monad
import Data.Array.IO
import Data.List
import Foreign.C.Types
import System.Environment
import System.Exit
import System.IO

siraben

------------------------------------------------------------------------
-- A mini Haskell compiler with typeclasses.
-- Originally written by Ben Lynn, modified by Ben Siraphob
------------------------------------------------------------------------
{-
Ideas for improvements (listed rough order of difficulty for each
section)

C runtime
=========

siraben

{-# LANGUAGE OverloadedStrings #-}
import Data.Function
import Data.List hiding (delete)
import Data.Set
import qualified Data.Text as T

data Direction = U | R | D | L deriving (Show, Read)
type Wire = [Move]
type Pos = (Int, Int)
data Move = Move Direction Int deriving (Show, Read)

siraben

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE OverloadedLists #-}
-- Friday, April 10, 2020 at 17:25
-- Algebra of Programming in Haskell, an attempt.

-- Unlike other approaches, we will not use polytyping, which requires
-- elaborate use of generics, type families, functional dependencies,
-- and more.  Thus, we will be able to reason equationally about our

siraben

;; Virtual machine that runs SKI combinators

(subroutine $)
(subroutine arg)
(subroutine num)
(subroutine lazy)
(subroutine $arg)
(subroutine run)
(subroutine init)
(subroutine sp!)

siraben

{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleInstances #-}
-- Tuesday, June 02, 2020
-- Monoidial functors and Applicatives
import Prelude hiding (Applicative(..), (**))

-- Lax monoidial functors
-- Laws:
-- Identity:      unit ** x     ~= x ** unit ~= unit
-- Associativity: u ** (v ** w) ~= (u ** v) ** w

siraben

use std::rc::Rc;
// Environment-passing lambda calculus interpreter in Rust
#[derive(Debug, Clone, PartialEq)]
enum LC {
    Var(String),
    App(Box<LC>, Box<LC>),
    Abs(String, Box<LC>),
    Lit(u32),
    Incr(Box<LC>),
}