Jon Purdy evincarofautumn

Crafting a Compiler from Scratch: Implementation Notes

For the past two weeks or so, I've been working on a little compiler project in C, mostly for educational purposes, i.e. to understand how a compiler really works. I'm not using any libraries, other than the C runtime library.

Introduction

I have a hand-written lexer and parser, and a simple code generator targetting

Comparison of configuration file languages

We need to PEPify a static format for writing down bootstrap information in Python source trees. The initial target is a list of PEP 508 package requirement strings. It's possible that in the future we might want to add more features like a build system backend specification (as in PEPs 516, 517), or an extension namespace feature to allow third-party developer tools (flit, pytest, coverage, flake8, etc.) to consolidate their configuration in this file in a systematic

These links no longer work. Springer have pulled the free plug.

Graduate texts in mathematics

duplicates = multiple editions

A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen

	import Numeric.Natural (Natural)

	import qualified Data.Semigroup

	-- \| @fibonacci n@ computes the @nth@ fibonacci number efficiently using infinite
	-- precision integer arithmetic
	--
	-- Try @fibonacci 1000000@
	fibonacci :: Natural -> Natural
	fibonacci n = x01 (Data.Semigroup.mtimesDefault n m)

	{-# LANGUAGE FunctionalDependencies #-}
	{-# LANGUAGE FlexibleInstances #-}
	{-# LANGUAGE MultiParamTypeClasses #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE FlexibleContexts #-}
	import Control.Monad
	import Control.Monad.Trans.Free
	import Control.Monad.Trans.Class

	--------------------------------------------------

	open Printf


	module Syntax = struct
	type t =
	\| Unit
	\| Boolean of bool
	\| Number of int
	\| Name of string
	\| Divide of t * t

	{-# LANGUAGE StandaloneDeriving, DataKinds, PolyKinds, GADTs, RankNTypes, TypeOperators, FlexibleContexts, TypeFamilies, KindSignatures #-}

	-- http://www.timphilipwilliams.com/posts/2013-01-16-fixing-gadts.html

	module HRecursionSchemes where

	import Control.Applicative
	import Data.Functor.Identity
	import Data.Functor.Const
	import Text.PrettyPrint.Leijen hiding ((<>))

	{-# LANGUAGE
	UndecidableInstances, RankNTypes, TypeOperators, TypeFamilies,
	StandaloneDeriving, DataKinds, PolyKinds, DeriveFunctor, DeriveFoldable,
	DeriveTraversable, LambdaCase, PatternSynonyms, TemplateHaskell #-}

	import Control.Monad
	import Control.Applicative
	import Data.Singletons.TH

	module type CELL = sig
	type 'a cell
	type 'a exp

	val return : 'a -> 'a exp
	val (>>=) : 'a exp -> ('a -> 'b exp) -> 'b exp

	val cell : 'a exp -> 'a cell exp
	val get : 'a cell -> 'a exp