Examples with LambdaImplementation suite.jdk.lambda.LambdaImplementation used on opensource projects

Example 1 with LambdaImplementation

use of suite.jdk.lambda.LambdaImplementation in project suite by stupidsing.

the class FunExpand method expand_.

private FunExpr expand_(FunExpr e0, int depth) {
    return // 
    e0.<// 
    FunExpr>switch_().applyIf(ApplyFunExpr.class, e1 -> {
        FunExpr object0 = e1.object;
        FunExpr object1 = object0 instanceof CastFunExpr ? ((CastFunExpr) object0).expr : object0;
        if (object1 instanceof Declare0ParameterFunExpr) {
            Declare0ParameterFunExpr object_ = (Declare0ParameterFunExpr) object1;
            return expand(object_.do_, depth);
        } else if (object1 instanceof Declare1ParameterFunExpr) {
            Declare1ParameterFunExpr object_ = (Declare1ParameterFunExpr) object1;
            return expand(replace(object_.do_, object_.parameter, e1.parameters.get(0)), depth);
        } else if (object1 instanceof Declare2ParameterFunExpr) {
            Declare2ParameterFunExpr object_ = (Declare2ParameterFunExpr) object1;
            FunExpr do0 = object_.do_;
            FunExpr do1 = replace(do0, object_.p0, e1.parameters.get(0));
            FunExpr do2 = replace(do1, object_.p1, e1.parameters.get(1));
            return expand(do2, depth);
        } else
            return null;
    }).applyIf(DeclareLocalFunExpr.class, e1 -> {
        return expand(replace(e1.do_, e1.var, e1.value), depth);
    }).applyIf(InvokeLambdaFunExpr.class, e1 -> {
        if (Boolean.FALSE) {
            LambdaInstance<?> l_inst = e1.lambda;
            LambdaImplementation<?> l_impl = l_inst.lambdaImplementation;
            if (e1.isExpand || weight(l_impl.expr) <= 5) {
                LambdaInterface<?> l_iface = l_impl.lambdaInterface;
                FunExpr fe = l_impl.expr;
                for (String fieldName : l_impl.fieldTypes.keySet()) fe = replaceFieldInject(fe, fieldName, object(l_inst.fieldValues.get(fieldName), l_impl.fieldTypes.get(fieldName)));
                return expand(fe.cast_(l_iface.interfaceClass).apply(e1.parameters), depth - 1);
            } else
                return null;
        } else
            return null;
    }).applyIf(If1FunExpr.class, e1 -> {
        FunExpr if_ = e1.if_;
        if (if_ instanceof ConstantFunExpr) {
            ConstantFunExpr e2 = (ConstantFunExpr) if_;
            if (e2.type == Type.INT)
                return ((Integer) e2.constant).intValue() != 0 ? e1.then : e1.else_;
            else
                return null;
        } else
            return null;
    }).result();
}

Example 2 with LambdaImplementation

use of suite.jdk.lambda.LambdaImplementation in project suite by stupidsing.

the class FunRewrite method rewrite_.

private FunExpr rewrite_(FunExpr e0) {
    return // 
    e0.<// 
    FunExpr>switch_().applyIf(ApplyFunExpr.class, e1 -> {
        FunExpr object = rewrite(e1.object);
        FunExpr[] parameters = Read.from(e1.parameters).map(this::rewrite).toArray(FunExpr.class);
        Method method = fti.methodOf(object);
        return object.invoke(method.getName(), parameters);
    }).applyIf(CastFunExpr.class, e1 -> {
        FunExpr e2 = e1.expr;
        if (e2 instanceof DeclareParameterFunExpr) {
            Class<?> interfaceClass = Type_.classOf(e1.type);
            Map<String, Type> fieldTypes = new HashMap<>();
            Map<String, FunExpr> fieldValues = new HashMap<>();
            FunExpr e3 = rewrite(e -> {
                FunExpr fieldValue;
                if (e instanceof FieldStaticFunExpr) {
                    FieldStaticFunExpr e_ = (FieldStaticFunExpr) e;
                    String fieldName = e_.fieldName;
                    Type fieldType = fieldTypes.get(fieldName);
                    fieldTypes.put(fieldName, fieldType);
                    fieldValues.put(fieldName, e_);
                    return e;
                } else if (e instanceof PlaceholderFunExpr && (fieldValue = placeholders.get(e)) != null) {
                    String fieldName = "e" + Util.temp();
                    Type fieldType = fti.typeOf(fieldValue);
                    fieldTypes.put(fieldName, fieldType);
                    fieldValues.put(fieldName, fieldValue);
                    return this_().field(fieldName, fieldType);
                } else
                    return null;
            }, e2);
            FunCreator<?>.CreateClass cc = FunCreator.of(LambdaInterface.of(interfaceClass), fieldTypes).create_(e3);
            Streamlet2<String, FunExpr> fieldValues0 = Read.from2(cc.fieldTypeValues).mapValue(tv -> objectField(tv.t1, tv.t0));
            Streamlet2<String, FunExpr> fieldValues1 = Read.from2(fieldValues);
            NewFunExpr e4 = new NewFunExpr();
            e4.className = cc.className;
            e4.fieldValues = Streamlet2.concat(fieldValues0, fieldValues1).toMap();
            e4.implementationClass = cc.clazz;
            e4.interfaceClass = interfaceClass;
            return e4;
        } else
            return null;
    }).applyIf(DeclareLocalFunExpr.class, e1 -> {
        FunExpr value = rewrite(e1.value);
        FunExpr lfe = local(localTypes.size());
        localTypes.add(fti.typeOf(value));
        AssignLocalFunExpr alfe = new AssignLocalFunExpr();
        alfe.var = lfe;
        alfe.value = value;
        placeholders.put(e1.var, lfe);
        return seq(alfe, rewrite(e1.do_));
    }).applyIf(FieldFunExpr_.class, e1 -> {
        FunExpr set = e1 instanceof FieldSetFunExpr ? ((FieldSetFunExpr) e1).value : null;
        FunExpr object0 = rewrite(e1.object);
        String fieldName = e1.fieldName;
        Class<?> clazz = fti.classOf(object0);
        Field field = Rethrow.ex(() -> clazz.getField(fieldName));
        FunExpr object1 = object0.cast_(field.getDeclaringClass());
        Type fieldType = Type.getType(field.getType());
        return set == null ? object1.field(fieldName, fieldType) : object1.fieldSet(fieldName, fieldType, set);
    }).applyIf(FieldInjectFunExpr.class, e1 -> {
        Type type = fieldTypes.get(e1.fieldName);
        if (type != null)
            return rewrite(this_().field(e1.fieldName, type));
        else
            return Fail.t(e1.fieldName);
    }).applyIf(InvokeLambdaFunExpr.class, e1 -> {
        LambdaInstance<?> l_inst = e1.lambda;
        LambdaImplementation<?> l_impl = l_inst.lambdaImplementation;
        LambdaInterface<?> l_iface = l_impl.lambdaInterface;
        FunExpr object = object_(l_impl.newFun(l_inst.fieldValues), l_iface.interfaceClass);
        return rewrite(object.invoke(l_iface.interfaceClass, l_iface.methodName, e1.parameters));
    }).applyIf(ObjectFunExpr.class, e1 -> {
        return objectField(e1.object, e1.type);
    }).applyIf(PlaceholderFunExpr.class, e1 -> {
        FunExpr e2 = placeholders.get(e1);
        if (e2 != null)
            return e2;
        else
            return Fail.t("cannot resolve placeholder");
    }).applyIf(ProfileFunExpr.class, e1 -> {
        fieldTypeValues.put(e1.counterFieldName, Pair.of(Type.INT, 0));
        return null;
    }).result();
}