yshui

//fun(T)(ref immutable T a){
// //If T is a struct, and I only use immutable fields of T
// //then it should be ok to call fun with a partially mutable type
//}


void f(T: class)(immutable T a) {
    return a.x+1;
}

yshui

xc = di.xorg.connect()
o = get_output("eDP1") 
xc.key.new(nil, "xf86monbrightnessup", false).on("pressed", function()
    o.backlight = math.min(math.ceil(o.backlight+o.max_backlight/10),o.max_backlight)
    print("up", o.backlight)
end)
xc.key.new(nil, "xf86monbrightnessdown", false).on("pressed", function()
    o.backlight = math.max(math.floor(o.backlight-o.max_backlight/10),0)
    print("down",o.backlight)
end)

yshui

struct applyRange(T, ElemType) {
	import core.thread;
	private {
		class rangeFiber : Fiber {
			ElemType *tmp = null;
			T r;
			this(T r) {
				this.r = r;
				super(&work);
			}

yshui

struct R(T...) {
	T data;
	auto opDispatch(string str)() {
		import std.conv;
		return data[to!int(str[1..$])];
	}
}
int main() {
	import std.stdio;
	auto tmp = R!(int, float)(1,2.0);

yshui

template<typename First, typename ...Rest>
struct Int{
        using Next = Int<Int<First, Rest...>, First, Rest...>;
        using Prev = First;
};
struct Zero{
        using Next = Int<Zero, Int<Zero>>;
};
template<typename A, typename B>
struct Plus{

yshui

// Cut from bigint.rs
pub struct MontyReducer<'a> {
    p: &'a BigUint,
    n: Vec<u32>,
    n0inv: u64
}
fn inv_mod_u32(num: u32) -> u64 {
    assert!( num % 2 != 0 );
    let mut x = 0;
    let mut y = 1;

yshui

//template<typename T>
//bool Foo(T a, T b) {
//  T c = a + b;
//  return a == c;
//}
//
//Expands to:

//------------- begin -------------
#include <iostream>

yshui

#!/usr/bin/dmd -run

import std.stdio, std.file, std.path, std.string, std.conv, std.math, std.container, std.algorithm, std.parallelism, std.range;

string filesize(double size){
    string units = "KMGT";
    double left = cast(double)size.abs();
    int unit = -1;

    while(left > 1100 && unit < 3){

yshui

int k(int a) {
	int b = a;
	switch(a) {
	case 1:
		b+=1;break;
	case 2:
		b+=2;break;
	case 3:
		b+=3;break;
	case 4:

yshui

#![feature(plugin)]
#![feature(collections)]
#![feature(str_char)]
#![feature(convert)]
#![plugin(peg_syntax_ext)]
use std::io;
peg! pynum(r#"
digit -> i64
      = digit_nozero
      / "ling" {0i64}