view myView(de.algorythm.sth.MyEntity e) {
		for a : e.children {
			text a.name

			for b : e.childrenB
				button action=b.doSth() label="do"
		}
	}

To realise it I've build the following grammar extract:
CtrlLoop:
	(name=ValidID ':')? 'for' (variable=JvmFormalParameter ':' iterable=XExpression)
		(=>each=ViewElement);

	def protected dispatch void inferBoundaryMethods(CtrlLoop expr, JvmGenericType jvmType) {
		if (expr.iterable != null && expr.variable != null) {
			val varType = expr.variable.parameterType
			
			val returnType = if (varType == null || varType.type == null)
					expr.newTypeRef(typeof(Iterable))
				else
					expr.newTypeRef(typeof(Iterable), varType)
			
			expr.inferBoundaryMethod(jvmType, "retrieve" + expr.name.toFirstUpper + "Iterable", returnType, expr.iterable, scope)
		}
		
		expr.proceedInferViewElements(jvmType)
	}

class CrudslScopeProvider extends XbaseScopeProvider {
	
	@Inject extension IJvmModelAssociations
		
	override protected IScope createLocalVarScopeForJvmOperation(JvmOperation context, IScope parentScope) {
		val scope = super.createLocalVarScopeForJvmOperation(context, parentScope)
		val crudslCtx = context.primarySourceElement

		if (crudslCtx instanceof ENamedElement)
			return createLoopVarScope(crudslCtx as ENamedElement, scope)
		
		return scope
	}
	
	/** returns a JvmFeatureScope of the loop variables of all parent loops */
	def private createLoopVarScope(ENamedElement element, IScope parentScope) {
		val Collection<IValidatedEObjectDescription> descriptions = newLinkedList()
		var ENamedElement e = element
		
		while ((e = e.parentLoop) != null) {
			val loop = e as CtrlLoop
			val v = loop.variable
			
			if (v.name != null)
				descriptions.add(v.createVarDescription(loop.iterable))
		}
		
		return if (descriptions.empty)
			parentScope
		else
			new JvmFeatureScope(parentScope, "JvmFormalParameter", descriptions)
	}
	
	def private parentLoop(ENamedElement expr) {
		EcoreUtil2::getContainerOfType(expr.eContainer, typeof(CtrlLoop))
	}
	
	def private createVarDescription(JvmFormalParameter variable, XExpression expr) {
		if (variable.parameterType == null) {
			val exprType = typeProvider.getType(expr, true)
			
			if (exprType != null)
				try {
					val pExprType = exprType as JvmParameterizedTypeReference
			
					variable.parameterType = pExprType.arguments.head
				} catch(ClassCastException e) {}
		}
		
		variable.createLocalVarDescription
	}
}

View:
	'view' name=ValidID '(' (args+=JvmFormalParameter (',' args+=JvmFormalParameter)*)? ')' '{'
		elements+=ViewElement*
	'}';

ViewElement returns ecore::ENamedElement:
	CtrlBlock | Button | ...

CtrlLoop:
	(name=ValidID ':')? 'for' declaredParam=JvmFormalParameter ':' iterable=XExpression
		eachElement=ViewElement;

class CrudslJvmModelInferrer implements IJvmModelInferrer {

	@Inject extension JvmTypesBuilder typeBuilder
	
	@Inject extension TypeReferences typeReferences
	
	@Inject extension ITypeProvider typeProvider
	
	@Inject extension IQualifiedNameProvider


	def infer ...

	def protected initView(View view) {
		val jvmType = view.toClass(view.fullyQualifiedName, null)
		val inferredViewData = new InferredViewData(jvmType, typeBuilder, typeProvider, typeReferences)
		
		jvmType.members += view.toConstructor(view.name) [
			for (a : view.args)
				parameters += a.toParameter(a.name, a.parameterType)
		]
		
		for (a : view.args)
			jvmType.members += view.toField(a.name, a.parameterType)
		
		view.elements.inferBoundaryMethods(inferredViewData)
	}
	
	def protected dispatch void inferBoundaryMethods(CtrlLoop loop, InferredViewData view) {
		val param = loop.declaredParam
		val isParamTypeDeclared = 
		
		if (loop.iterable != null) {
			// define iterable expression's expected type as detailed as possible
			val expectedType = if (param == null || param.parameterType == null || param.parameterType.type == null)
					// enforce some iterable return type
					loop.newTypeRef(typeof(Iterable))
				else
					// use declared loop var type
					loop.newTypeRef(typeof(Iterable), param.parameterType)
			
			// create JvmOperation of view: has to run before getType() call to be able to access view properties
			view.createMethod(loop, "Iterable", loop.iterable, expectedType)
			
			// evaluate iterable expression's type
			val exprType = loop.iterable.getType(true)
			
			// declare local loop var type inferred from interable expression type
			if (exprType != null)
				try {
					val pExprType = exprType as JvmParameterizedTypeReference
					
					if (param != null && (param.parameterType == null || param.parameterType.type == null))
						param.parameterType = EcoreUtil2::cloneWithProxies(pExprType.arguments.head)
				} catch(ClassCastException e) { }
		}

		if (param != null)
			view.pushLocalVar(param)

		loop.eachElement.inferBoundaryMethods(view)
		
		if (param != null)
			view.popLocalVar()
	}

	// ... {more dispatched methods}
}

public class InferredViewData {
	
	final private JvmGenericType type;
	final private Stack<JvmFormalParameter> localVarScope;
	final private JvmTypesBuilder typeBuilder;
	final private ITypeProvider typeProvider;
	final private TypeReferences typeReferences;
	private int count;
	
	public InferredViewData(final JvmGenericType type, 
			final JvmTypesBuilder typeBuilder, final ITypeProvider typeProvider,
			final TypeReferences typeReferences) {
		this.type = type;
		this.localVarScope = new Stack<JvmFormalParameter>();
		this.typeBuilder = typeBuilder;
		this.typeProvider = typeProvider;
		this.typeReferences = typeReferences;
	}
	
	public void pushLocalVar(final JvmFormalParameter localVar) {
		localVarScope.push(localVar);
	}
	
	public void popLocalVar() {
		localVarScope.pop();
	}
	
	public void createMethod(final ENamedElement viewElement, String suffix, final XExpression expr, final JvmTypeReference returnType) {
		final Set<String> uniqueVarNames = new HashSet<String>(); 
		final Collection<JvmFormalParameter> currentLocalVarScope = new LinkedList<JvmFormalParameter>();
		
		for (JvmFormalParameter a : localVarScope)
			if (uniqueVarNames.add(a.getName()))
				currentLocalVarScope.add(a);
		
		final Procedure1<JvmOperation> initializer = new Procedure1<JvmOperation>() {
			public void apply(final JvmOperation op) {
				typeBuilder.setBody(op, expr);
				
				for (JvmFormalParameter p : currentLocalVarScope)
					op.getParameters().add(EcoreUtil2.cloneWithProxies(p));
			}
		};
		
		String elementName = viewElement.getName();
		elementName = elementName == null ? "Expr" + count++ : elementName.substring(0, 1).toUpperCase() + elementName.substring(1); 
		
		JvmOperation exprFunction = typeBuilder.toMethod(viewElement, "retrieve" + elementName + suffix, returnType, initializer);

		type.getMembers().add(exprFunction);
	}
}

view testView(de.algorythm.test.MyEntity e) {
	text e.name
	
	for a : e.children {
		text a.name
		
		for b : e.childrenB {
			text b.name.substring(0, 2)
		}
	}
	
	button "click me!" action = e.testMethode("asdf")
}