@Override protected String visitLambdaExpression(LambdaExpression node, Void context) { StringBuilder builder = new StringBuilder(); builder.append('('); Joiner.on(", ").appendTo(builder, node.getArguments()); builder.append(") -> "); builder.append(process(node.getBody(), context)); return builder.toString(); }
@Override protected Void visitLambdaExpression(LambdaExpression node, Set<String> lambdaArgumentNames) { return process(node.getBody(), ImmutableSet.<String>builder() .addAll(lambdaArgumentNames) .addAll(node.getArguments().stream() .map(LambdaArgumentDeclaration::getName) .map(Identifier::getValue) .collect(toImmutableSet())) .build()); } }
@Override protected RowExpression visitLambdaExpression(LambdaExpression node, Void context) { RowExpression body = process(node.getBody(), context); Type type = getType(node); List<Type> typeParameters = type.getTypeParameters(); List<Type> argumentTypes = typeParameters.subList(0, typeParameters.size() - 1); List<String> argumentNames = node.getArguments().stream() .map(LambdaArgumentDeclaration::getName) .map(Identifier::getValue) .collect(toImmutableList()); return new LambdaDefinitionExpression(argumentTypes, argumentNames, body); }
@Override public Expression rewriteLambdaExpression(LambdaExpression node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { for (LambdaArgumentDeclaration argument : node.getArguments()) { String argumentName = argument.getName().getValue(); // Symbol names are unique. As a result, a symbol should never be excluded multiple times. checkArgument(!excludedNames.contains(argumentName)); excludedNames.add(argumentName); } Expression result = treeRewriter.defaultRewrite(node, context); for (LambdaArgumentDeclaration argument : node.getArguments()) { excludedNames.remove(argument.getName().getValue()); } return result; } }
@Override public Expression rewriteLambdaExpression(LambdaExpression node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { return new LambdaExpression(node.getArguments(), treeRewriter.rewrite(node.getBody(), context)); } }, expression);
@Override public Expression rewriteLambdaExpression(LambdaExpression node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { checkState(analysis.getCoercion(node) == null, "cannot coerce a lambda expression"); ImmutableList.Builder<LambdaArgumentDeclaration> newArguments = ImmutableList.builder(); for (LambdaArgumentDeclaration argument : node.getArguments()) { Symbol symbol = lambdaDeclarationToSymbolMap.get(NodeRef.of(argument)); newArguments.add(new LambdaArgumentDeclaration(new Identifier(symbol.getName()))); } Expression rewrittenBody = treeRewriter.rewrite(node.getBody(), null); return new LambdaExpression(newArguments.build(), rewrittenBody); }
@Override protected Object visitLambdaExpression(LambdaExpression node, Object context) { if (optimize) { // TODO: enable optimization related to lambda expression // A mechanism to convert function type back into lambda expression need to exist to enable optimization return node; } Expression body = node.getBody(); List<String> argumentNames = node.getArguments().stream() .map(LambdaArgumentDeclaration::getName) .map(Identifier::getValue) .collect(toImmutableList()); FunctionType functionType = (FunctionType) expressionTypes.get(NodeRef.<Expression>of(node)); checkArgument(argumentNames.size() == functionType.getArgumentTypes().size()); return generateVarArgsToMapAdapter( Primitives.wrap(functionType.getReturnType().getJavaType()), functionType.getArgumentTypes().stream() .map(Type::getJavaType) .map(Primitives::wrap) .collect(toImmutableList()), argumentNames, map -> process(body, new LambdaSymbolResolver(map))); }
Expression rewrittenBody = treeRewriter.rewrite(node.getBody(), context.withReferencedSymbols(referencedSymbols)); List<Symbol> lambdaArguments = node.getArguments().stream() .map(LambdaArgumentDeclaration::getName) .map(Identifier::getValue) newLambdaArguments.add(new LambdaArgumentDeclaration(new Identifier(extraSymbol.getName()))); newLambdaArguments.addAll(node.getArguments());
verify(lambdaExpression.getArguments().size() == functionType.getArgumentTypes().size()); Map<NodeRef<Expression>, Type> lambdaArgumentExpressionTypes = new HashMap<>(); Map<Symbol, Type> lambdaArgumentSymbolTypes = new HashMap<>(); for (int j = 0; j < lambdaExpression.getArguments().size(); j++) { LambdaArgumentDeclaration argument = lambdaExpression.getArguments().get(j); Type type = functionType.getArgumentTypes().get(j); lambdaArgumentExpressionTypes.put(NodeRef.of(argument), type);
List<LambdaArgumentDeclaration> lambdaArguments = node.getArguments();
@Override protected String visitLambdaExpression(LambdaExpression node, Void context) { StringBuilder builder = new StringBuilder(); builder.append('('); Joiner.on(", ").appendTo(builder, node.getArguments()); builder.append(") -> "); builder.append(process(node.getBody(), context)); return builder.toString(); }
@Override protected String visitLambdaExpression(LambdaExpression node, Boolean unmangleNames) { StringBuilder builder = new StringBuilder(); builder.append('('); Joiner.on(", ").appendTo(builder, node.getArguments()); builder.append(") -> "); builder.append(process(node.getBody(), unmangleNames)); return builder.toString(); }
@Override protected String visitLambdaExpression(LambdaExpression node, Void context) { StringBuilder builder = new StringBuilder(); builder.append('('); Joiner.on(", ").appendTo(builder, node.getArguments()); builder.append(") -> "); builder.append(process(node.getBody(), context)); return builder.toString(); }
@Override protected String visitLambdaExpression(LambdaExpression node, Boolean unmangleNames) { StringBuilder builder = new StringBuilder(); builder.append('('); Joiner.on(", ").appendTo(builder, node.getArguments()); builder.append(") -> "); builder.append(process(node.getBody(), unmangleNames)); return builder.toString(); }