i21012/JavaPatternMatching
1
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

adapt Rule

Browse Source
This commit is contained in:
Florian Steurer 2015-11-13 23:24:22 +01:00
parent 8a40acb73e
commit 82c0736fee
5 changed files with 84 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
notizen/stf/Notes
View File

@ -34,6 +34,10 @@ Gilt reduce f
+++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++++
HashCode implementierungen testen (type paramerte mit einbeziehen, hashcodes cachen -> da immutable)
+++++++++++++++++++++++++++++++++++++++++++++++
- Typen sind anhand ihres identifiers durchgängig identifizierbar - Typen sind anhand ihres identifiers durchgängig identifizierbar
- ReduceEq nur auf SimpleTypes oder auf alles anwenden? (Momentan alles) - ReduceEq nur auf SimpleTypes oder auf alles anwenden? (Momentan alles)
@ -42,4 +46,5 @@ Gilt reduce f
EED UP EED UP
- Anwendungsreihenfolge der Regeln (wahrscheinlichste zuerst, evtl ist nach regel 1 regel 2 nie möglich etc...) - Anwendungsreihenfolge der Regeln (wahrscheinlichste zuerst, evtl ist nach regel 1 regel 2 nie möglich etc...)
- Erase vor Reduce - Erase vor Reduce
- Rechenarm vor rechenintensiv - Rechenarm vor rechenintensiv

9
src/de/dhbwstuttgart/typeinference/unify/interfaces/IRuleSet.java
View File

@ -3,6 +3,7 @@ package de.dhbwstuttgart.typeinference.unify.interfaces;
import java.util.Optional; import java.util.Optional;
import java.util.Set; import java.util.Set;
import de.dhbwstuttgart.typeinference.unifynew.Unifier;
import de.dhbwstuttgart.typinference.unify.model.MPair; import de.dhbwstuttgart.typinference.unify.model.MPair;
public interface IRuleSet { public interface IRuleSet {
@ -22,9 +23,9 @@ public interface IRuleSet {
public Optional<MPair> swap(MPair pair); public Optional<MPair> swap(MPair pair);
public MPair adapt(MPair pair); public Optional<MPair> adapt(MPair pair);
public MPair adaptExt(MPair pair); public Optional<MPair> adaptExt(MPair pair);
public MPair adaptSup(MPair pair); public Optional<MPair> adaptSup(MPair pair);
public Optional<IUnifier> subst(MPair pair); public Optional<Unifier> subst(MPair pair);
} }

9
src/de/dhbwstuttgart/typeinference/unify/interfaces/IUnifier.java
View File

@ -1,9 +0,0 @@
package de.dhbwstuttgart.typeinference.unify.interfaces;
import java.util.function.Function;
import de.dhbwstuttgart.typinference.unify.model.MPair;
public interface IUnifier extends Function<MPair, MPair>{
}

110
src/de/dhbwstuttgart/typeinference/unifynew/RuleSet.java
View File

@ -1,13 +1,14 @@
package de.dhbwstuttgart.typeinference.unifynew; package de.dhbwstuttgart.typeinference.unifynew;
import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.Set; import java.util.Set;
import junit.framework.Assert; import junit.framework.Assert;
import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure; import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet; import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
import de.dhbwstuttgart.typeinference.unify.interfaces.IUnifier;
import de.dhbwstuttgart.typinference.unify.model.ExtendsType; import de.dhbwstuttgart.typinference.unify.model.ExtendsType;
import de.dhbwstuttgart.typinference.unify.model.MPair; import de.dhbwstuttgart.typinference.unify.model.MPair;
import de.dhbwstuttgart.typinference.unify.model.MPair.PairOperator; import de.dhbwstuttgart.typinference.unify.model.MPair.PairOperator;
@ -15,6 +16,7 @@ import de.dhbwstuttgart.typinference.unify.model.PlaceholderType;
import de.dhbwstuttgart.typinference.unify.model.SimpleType; import de.dhbwstuttgart.typinference.unify.model.SimpleType;
import de.dhbwstuttgart.typinference.unify.model.SuperType; import de.dhbwstuttgart.typinference.unify.model.SuperType;
import de.dhbwstuttgart.typinference.unify.model.Type; import de.dhbwstuttgart.typinference.unify.model.Type;
import de.dhbwstuttgart.typinference.unify.model.TypeParams;
public class RuleSet implements IRuleSet{ public class RuleSet implements IRuleSet{
@ -95,12 +97,12 @@ public class RuleSet implements IRuleSet{
if(pi.length == 0) if(pi.length == 0)
return Optional.empty(); return Optional.empty();
Type[] rhsTypeParams = rhsType.getTypeParams().asArray(); TypeParams rhsTypeParams = rhsType.getTypeParams();
Type[] lhsTypeParams = lhsType.getTypeParams().asArray(); TypeParams lhsTypeParams = lhsType.getTypeParams();
Set<MPair> result = new HashSet<>(); Set<MPair> result = new HashSet<>();
for(int rhsIdx = 0; rhsIdx < rhsTypeParams.length; rhsIdx++) for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
result.add(new MPair(lhsTypeParams[pi[rhsIdx]], rhsTypeParams[rhsIdx], PairOperator.SMALLERDOTWC)); result.add(new MPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
return Optional.of(result); return Optional.of(result);
} }
@ -128,12 +130,12 @@ public class RuleSet implements IRuleSet{
if(pi.length == 0) if(pi.length == 0)
return Optional.empty(); return Optional.empty();
Type[] rhsTypeParams = rhsType.getTypeParams().asArray(); TypeParams rhsTypeParams = rhsType.getTypeParams();
Type[] lhsTypeParams = lhsType.getTypeParams().asArray(); TypeParams lhsTypeParams = lhsType.getTypeParams();
Set<MPair> result = new HashSet<>(); Set<MPair> result = new HashSet<>();
for(int rhsIdx = 0; rhsIdx < rhsTypeParams.length; rhsIdx++) for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
result.add(new MPair(lhsTypeParams[pi[rhsIdx]], rhsTypeParams[rhsIdx], PairOperator.SMALLERDOTWC)); result.add(new MPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
return Optional.of(result); return Optional.of(result);
} }
@ -160,11 +162,11 @@ public class RuleSet implements IRuleSet{
// TODO Permutation? // TODO Permutation?
Set<MPair> result = new HashSet<>(); Set<MPair> result = new HashSet<>();
Type[] lhsTypeParams = lhsType.getTypeParams().asArray(); TypeParams lhsTypeParams = lhsType.getTypeParams();
Type[] rhsTypeParams = rhsType.getTypeParams().asArray(); TypeParams rhsTypeParams = rhsType.getTypeParams();
for(int i = 0; i < lhsTypeParams.length; i++) for(int i = 0; i < lhsTypeParams.size(); i++)
result.add(new MPair(lhsTypeParams[i], rhsTypeParams[i], PairOperator.EQUALSDOT)); result.add(new MPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
return Optional.of(result); return Optional.of(result);
} }
@ -193,12 +195,12 @@ public class RuleSet implements IRuleSet{
if(pi.length == 0) if(pi.length == 0)
return Optional.empty(); return Optional.empty();
Type[] rhsTypeParams = rhsType.getTypeParams().asArray(); TypeParams rhsTypeParams = rhsType.getTypeParams();
Type[] lhsTypeParams = lhsType.getTypeParams().asArray(); TypeParams lhsTypeParams = lhsType.getTypeParams();
Set<MPair> result = new HashSet<>(); Set<MPair> result = new HashSet<>();
for(int rhsIdx = 0; rhsIdx < rhsTypeParams.length; rhsIdx++) for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
result.add(new MPair(lhsTypeParams[pi[rhsIdx]], rhsTypeParams[rhsIdx], PairOperator.SMALLERDOTWC)); result.add(new MPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
return Optional.of(result); return Optional.of(result);
} }
@ -244,10 +246,10 @@ public class RuleSet implements IRuleSet{
Set<MPair> result = new HashSet<>(); Set<MPair> result = new HashSet<>();
Type[] rhsTypeParams = rhsSType.getTypeParams().asArray(); TypeParams rhsTypeParams = rhsSType.getTypeParams();
Type[] lhsTypeParams = lhsSType.getTypeParams().asArray(); TypeParams lhsTypeParams = lhsSType.getTypeParams();
for(int i = 0; i < rhsTypeParams.length; i++) for(int i = 0; i < rhsTypeParams.size(); i++)
result.add(new MPair(lhsTypeParams[i], rhsTypeParams[i], PairOperator.EQUALSDOT)); result.add(new MPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
return Optional.of(result); return Optional.of(result);
} }
@ -302,19 +304,53 @@ public class RuleSet implements IRuleSet{
} }
@Override @Override
public MPair adapt(MPair pair) { public Optional<MPair> adapt(MPair pair) {
if(pair.getPairOp() != PairOperator.SMALLERDOT)
return Optional.empty();
Type lhsType = pair.getLhsType();
if(!(lhsType instanceof SimpleType))
return Optional.empty();
Type rhsType = pair.getRhsType();
if(!(rhsType instanceof SimpleType))
return Optional.empty();
if(lhsType.getTypeParams().size() == 0 || rhsType.getTypeParams().size() == 0)
return Optional.empty();
Type lhsFromFc = finiteClosure.getType(lhsType.getName());
if(lhsFromFc == null)
return Optional.empty();
Set<Type> greater = finiteClosure.greater(lhsFromFc);
Optional<Type> opt = greater.stream().filter(x -> x.getName().equals(rhsType.getName())).findAny();
if(!opt.isPresent())
return Optional.empty();
Type newLhs = opt.get();
TypeParams lhsTypeParams = lhsType.getTypeParams();
TypeParams lhsFromFcTypeParams = lhsFromFc.getTypeParams();
Unifier unif = new Unifier(lhsFromFcTypeParams.get(0), lhsTypeParams.get(0));
for(int i = 0; i < lhsTypeParams.size(); i++)
unif.andThen(new Unifier(lhsFromFcTypeParams.get(i), lhsTypeParams.get(i)));
return Optional.of(new MPair(newLhs.applyToTypeParams(unif), rhsType, PairOperator.SMALLERDOT));
}
@Override
public Optional<MPair> adaptExt(MPair pair) {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null; return null;
} }
@Override @Override
public MPair adaptExt(MPair pair) { public Optional<MPair> adaptSup(MPair pair) {
// TODO Auto-generated method stub
return null;
}
@Override
public MPair adaptSup(MPair pair) {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null; return null;
} }
@ -362,17 +398,17 @@ public class RuleSet implements IRuleSet{
Assert.assertEquals(cFromFc.getTypeParams().size(), dFromFc.getTypeParams().size()); Assert.assertEquals(cFromFc.getTypeParams().size(), dFromFc.getTypeParams().size());
Assert.assertTrue(dFromFc.getTypeParams().size() > 0); Assert.assertTrue(dFromFc.getTypeParams().size() > 0);
Type[] cArgs = cFromFc.getTypeParams().asArray(); TypeParams cArgs = cFromFc.getTypeParams();
Type[] dArgs = dFromFc.getTypeParams().asArray(); TypeParams dArgs = dFromFc.getTypeParams();
int[] permutation = new int[dArgs.length]; int[] permutation = new int[dArgs.size()];
boolean succ = true; boolean succ = true;
for (int dArgIdx = 0; dArgIdx < dArgs.length && succ; dArgIdx++) { for (int dArgIdx = 0; dArgIdx < dArgs.size() && succ; dArgIdx++) {
Type dArg = dArgs[dArgIdx]; Type dArg = dArgs.get(dArgIdx);
succ = false; succ = false;
for (int pi = 0; pi < cArgs.length; pi++) for (int pi = 0; pi < cArgs.size(); pi++)
if (cArgs[pi].getName().equals(dArg.getName())) { if (cArgs.get(pi).getName().equals(dArg.getName())) {
permutation[dArgIdx] = pi; permutation[dArgIdx] = pi;
succ = true; succ = true;
break; break;
@ -384,7 +420,7 @@ public class RuleSet implements IRuleSet{
} }
@Override @Override
public Optional<IUnifier> subst(MPair pair) { public Optional<Unifier> subst(MPair pair) {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null; return null;
} }

11
src/de/dhbwstuttgart/typeinference/unifynew/Unify.java
View File

@ -1,6 +1,5 @@
package de.dhbwstuttgart.typeinference.unifynew; package de.dhbwstuttgart.typeinference.unifynew;
import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.HashSet; import java.util.HashSet;
import java.util.LinkedHashSet; import java.util.LinkedHashSet;
@ -13,11 +12,8 @@ import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException; import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure; import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet; import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
import de.dhbwstuttgart.typeinference.unify.interfaces.IUnifier;
import de.dhbwstuttgart.typinference.unify.model.MPair; import de.dhbwstuttgart.typinference.unify.model.MPair;
import de.dhbwstuttgart.typinference.unify.model.PlaceholderType; import de.dhbwstuttgart.typinference.unify.model.PlaceholderType;
import de.dhbwstuttgart.typinference.unify.model.SimpleType;
import de.dhbwstuttgart.typinference.unify.model.Type;
/** /**
* Implementierung des Unifikationsalgorithmus. * Implementierung des Unifikationsalgorithmus.
@ -145,11 +141,4 @@ public class Unify {
collection.add(pair2); collection.add(pair2);
} }
private void test() {
Type t = new PlaceholderType("T");
Type subst = new SimpleType("Subst");
IUnifier u = x -> x.substitute(t, subst);
}
} }