ven vendethiel

Meta-Programming

Towards a fully-reflective meta-programming language (G. Neverov, P. Roe)
D-Expressions: Lisp Power, Dylan Style (J. Bachrach, K. Playford)
The Java Syntactic Extender (J. Bachrach, K. Playford)
Template Meta-Programming for Haskell (T. Sheard, S.P. Jones)
First-class macros have types (A. Bawden)
Macros that work (W. Clinger, J. Rees)
Macros as multi-stage computations: type-safe, generative, binding macros in MacroML (S.E. Ganz, A. Sabry, W. Taha)
Hygienic macro expansion (E. Kohlbecker, D. Friedman, M. felleisen, B. Duba)

https://github.com/vendethiel/read/issues

To Read

(gwydiondylan)

First and foremost, let's take a look at the following pieces of code. The first one is something you should be rather familiar with, and the second one is also a somewhat familiar idiom these days (at least in languages with higher-order functions):

// Example 1:
30 + 12

// Example 2:
xs.map(f)

	trait Functorial[F[_], B] {
	def map[A](m: F[A])(f: A => B): F[B]
	}

	trait Monadic[M[_], B] extends Functorial[F, B] {
	def point(b: B): M[B]
	def flatMap[A](m: M[A])(f: A => M[B]): M[B]
	}

	trait Traversial[F[_], B] {

	{-# LANGUAGE ExistentialQuantification, RankNTypes #-}
	{-# LANGUAGE InstanceSigs #-}
	module CoYoneda where

	import Data.IORef
	import Data.Set (Set, map)
	import Control.Monad (liftM)

	--------------------------------------------------------------------------------
	-- Yoneda

	#!/usr/bin/env ruby
	gem "parser", "~> 1.4"
	require "parser"
	require "parser/ruby19"
	require "set"

	class ConstantDeclarationAndUseProcessor < Parser::AST::Processor
	attr_reader :declared, :used

	def initialize

	defmodule ApplicationRouter do
	use Dynamo.Router

	prepare do
	# Pick which parts of the request you want to fetch
	# You can comment the line below if you don't need
	# any of them or move them to a forwarded router
	conn.fetch([:cookies, :params])
	end

	require 'addressable/uri'

	# Source: http://gist.github.com/bf4/5320847
	# Accepts options[:message] and options[:allowed_protocols]
	# spec/validators/uri_validator_spec.rb
	class UriValidator < ActiveModel::EachValidator

	def validate_each(record, attribute, value)
	uri = parse_uri(value)
	if !uri

	<dmanderson> Oh Domo :)
	<dmanderson> Nice templater
	<Sorella> Oh.
	<dmanderson> I've been using an underscore to JST compiler as of late, but
	this looks really nice.
	<Sorella> I don't quite like Domo, but sure.
	<Sorella> Oh Lord, don't use Underscore's templating. Like,
	really. Don't. Just. Don't.
	<dmanderson> No I'm using JST
	<dmanderson> writing the templates in underscore

	#!/usr/bin/env ruby

	class Module
	private

	def delegate(*args)
	dest, prefix = _extract_valid_delegation_options(args.pop)
	_define_delegators(caller_locations.first, prefix, dest, args)
	end