 }
 
 
-@infix func | <T> (left: @auto_closure () -> Language<T>, right: @auto_closure () -> Language<T>) -> Language<T> {
-	return Language<T>.Alternation(left, right)
+@infix func | <T where T : Equatable, T : Printable> (left: @auto_closure () -> Language<T>, right: @auto_closure () -> Language<T>) -> Language<T> {
+	return Language.Alternation(delay(left), delay(right))
 }
 
 
 operator infix ++ {}
 
 @infix func ++ <T> (first: @auto_closure () -> Language<T>, second: @auto_closure () -> Language<T>) -> Language<T> {
-	return Language<T>.Concatenation(first, second)
+	return Language.Concatenation(delay(first), delay(second))
 }
 
 @infix func & <T> (left: @auto_closure () -> Language<T>, right: @auto_closure () -> Language<T>) -> Language<T> {
-	return Language<T>.Intersection(left, right)
+	return Language.Intersection(delay(left), delay(right))
 }
 
 operator postfix * {}
 
 @postfix func * <T> (language: @auto_closure () -> Language<T>) -> Language<T> {
-	return Language<T>.Repeat(language)
+	return Language.Repeat(delay(language))
 }
 
 

	
	case Literal(T)
	
	case Alternation(LazyLanguage, LazyLanguage)
	case Concatenation(LazyLanguage, LazyLanguage)
	case Intersection(LazyLanguage, LazyLanguage)
	
	case Repeat(LazyLanguage)
	
	case Reduce(LazyLanguage, (T) -> Any)
}

extension Language : Printable {

operator infix --> {}

@infix func --> <T> (language: @auto_closure () -> Language<T>, f: (T) -> Any) -> Language<T> {
	return Language.Reduce(delay(language), f)
}
