Remove lombok

11 files changed, 333 insertions, 245 deletions

diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/BooleanInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/BooleanInterpreterValue.java
index 7bb108c..8245f87 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/BooleanInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/BooleanInterpreterValue.java
@@ -1,44 +1,61 @@
 package org.zwobble.couscous.interpreter.values;
 
 import java.util.Optional;
-
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
 
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Value;
-
-@Value
-public class BooleanInterpreterValue implements InterpreterValue {
-    private static final ConcreteType TYPE = ConcreteType.builder(BooleanInterpreterValue.class, "Boolean")
-        .build();
+public final class BooleanInterpreterValue implements InterpreterValue {
+    private static final ConcreteType TYPE = ConcreteType.builder(BooleanInterpreterValue.class, "Boolean").build();
+    private final boolean value;
     
-    @Getter(value = AccessLevel.NONE)
-    boolean value;
-
     public boolean getValue() {
         return value;
     }
-
+    
     @Override
     public ConcreteType getType() {
         return TYPE;
     }
-
+    
     @Override
     public Optional<PrimitiveValue> toPrimitiveValue() {
         return Optional.of(PrimitiveValues.value(value));
     }
-
+    
     @Override
     public InterpreterValue getField(String fieldName) {
         throw new NoSuchField(fieldName);
     }
-
+    
     @Override
     public void setField(String fieldName, InterpreterValue value) {
         throw new NoSuchField(fieldName);
     }
-}
+    
+    public BooleanInterpreterValue(final boolean value) {
+        this.value = value;
+    }
+    
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof BooleanInterpreterValue)) return false;
+        final BooleanInterpreterValue other = (BooleanInterpreterValue)o;
+        if (this.getValue() != other.getValue()) return false;
+        return true;
+    }
+    
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        result = result * PRIME + (this.getValue() ? 79 : 97);
+        return result;
+    }
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "BooleanInterpreterValue(value=" + this.getValue() + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/BoxedIntegerInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/BoxedIntegerInterpreterValue.java
index a6ba5e1..458eca7 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/BoxedIntegerInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/BoxedIntegerInterpreterValue.java
@@ -4,13 +4,11 @@ import org.zwobble.couscous.values.StringValue;
 
 import static java.util.Arrays.asList;
 
-import lombok.val;
-
 public class BoxedIntegerInterpreterValue {
     public static final ConcreteType TYPE = ConcreteType.classBuilder("java.lang.Integer")
         .staticMethod("parseInt", asList(StringValue.REF),
             (environment, arguments) -> {
-                val value = (StringInterpreterValue)arguments.get(0);
+                StringInterpreterValue value = (StringInterpreterValue)arguments.get(0);
                 return new IntegerInterpreterValue(Integer.parseInt(value.getValue()));
             })
         
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java b/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
index 2c64031..a61ec27 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
@@ -5,7 +5,6 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.stream.Collectors;
-
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.FormalArgumentNode;
 import org.zwobble.couscous.ast.TypeName;
@@ -16,32 +15,27 @@ import org.zwobble.couscous.interpreter.NoSuchMethod;
 import org.zwobble.couscous.interpreter.PositionalArguments;
 import org.zwobble.couscous.interpreter.WrongNumberOfArguments;
 import org.zwobble.couscous.util.Casts;
-
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-
 import static java.util.stream.Collectors.toMap;
 
-import lombok.val;
-
 public class ConcreteType {
+    
     public static <T> ConcreteType.Builder<T> builder(Class<T> interpreterValueType, TypeName reference) {
         return new Builder<>(interpreterValueType, reference);
     }
-
+    
     public static <T> ConcreteType.Builder<T> builder(Class<T> interpreterValueType, String name) {
         return builder(interpreterValueType, TypeName.of(name));
     }
-
+    
     public static ConcreteType.Builder<ObjectInterpreterValue> classBuilder(String name) {
         return builder(ObjectInterpreterValue.class, name);
     }
     
     public static class Builder<T> {
-        private final ImmutableMap.Builder<String, MethodValue> methods =
-            ImmutableMap.builder();
-        private final ImmutableMap.Builder<String, StaticMethodValue> staticMethods =
-            ImmutableMap.builder();
+        private final ImmutableMap.Builder<String, MethodValue> methods = ImmutableMap.builder();
+        private final ImmutableMap.Builder<String, StaticMethodValue> staticMethods = ImmutableMap.builder();
         private final Class<T> interpreterValueType;
         private final TypeName name;
         
@@ -50,112 +44,51 @@ public class ConcreteType {
             this.name = name;
         }
         
-        public Builder<T> method(
-                String name,
-                List<TypeName> argumentsTypes,
-                BiFunction<Environment, MethodCallArguments<T>, InterpreterValue> method) {
+        public Builder<T> method(String name, List<TypeName> argumentsTypes, BiFunction<Environment, MethodCallArguments<T>, InterpreterValue> method) {
             methods.put(name, new MethodValue(argumentsTypes, (environment, arguments) -> {
-                return Casts.tryCast(interpreterValueType, arguments.getReceiver())
-                    .map(typedReceiver ->
-                        method.apply(environment, MethodCallArguments.of(typedReceiver, arguments.getPositionalArguments())))
-                    .orElseThrow(() -> new RuntimeException("receiver is of wrong type"));
+                return Casts.tryCast(interpreterValueType, arguments.getReceiver()).map(typedReceiver -> method.apply(environment, MethodCallArguments.of(typedReceiver, arguments.getPositionalArguments()))).orElseThrow(() -> new RuntimeException("receiver is of wrong type"));
             }));
             return this;
         }
         
-        public Builder<T> staticMethod(
-                String name,
-                List<TypeName> argumentsTypes,
-                BiFunction<Environment, PositionalArguments, InterpreterValue> method) {
+        public Builder<T> staticMethod(String name, List<TypeName> argumentsTypes, BiFunction<Environment, PositionalArguments, InterpreterValue> method) {
             staticMethods.put(name, new StaticMethodValue(argumentsTypes, method));
             return this;
         }
         
         public ConcreteType build() {
-            return new ConcreteType(
-                name,
-                ImmutableMap.of(),
-                new MethodValue(
-                    ImmutableList.of(),
-                    (environment, arguments) -> InterpreterValues.UNIT),
-                methods.build(),
-                staticMethods.build());
+            return new ConcreteType(name, ImmutableMap.of(), new MethodValue(ImmutableList.of(), (environment, arguments) -> InterpreterValues.UNIT), methods.build(), staticMethods.build());
         }
     }
     
     public static ConcreteType fromNode(ClassNode classNode) {
-        val fields = classNode.getFields().stream()
-            .collect(toMap(
-                field -> field.getName(),
-                field -> new FieldValue(field.getName(), field.getType())));
-        
-        val constructor = new MethodValue(
-            getArgumentTypes(classNode.getConstructor().getArguments()),
-            (environment, arguments) -> Executor.callMethod(
-                environment,
-                classNode.getConstructor(),
-                Optional.of(arguments.getReceiver()),
-                arguments.getPositionalArguments()));
-        
-        val methods = classNode.getMethods().stream()
-            .filter(method -> !method.isStatic())
-            .collect(toMap(
-                method -> method.getName(),
-                method -> {
-                    val argumentTypes = getArgumentTypes(method.getArguments());
-                    
-                    return new MethodValue(argumentTypes, (environment, arguments) -> {
-                        return Executor.callMethod(
-                            environment,
-                            method,
-                            Optional.of(arguments.getReceiver()),
-                            arguments.getPositionalArguments());
-                    });
-                }));
-        
-        val staticMethods = classNode.getMethods()
-            .stream()
-            .filter(method -> method.isStatic())
-            .collect(toMap(
-                method -> method.getName(),
-                method -> {
-                    val argumentTypes = getArgumentTypes(method.getArguments());
-                    
-                    return new StaticMethodValue(argumentTypes, (environment, arguments) -> {
-                        return Executor.callMethod(
-                            environment,
-                            method,
-                            Optional.empty(),
-                            arguments);
-                    });
-                }));
-        return new ConcreteType(
-            classNode.getName(),
-            fields,
-            constructor,
-            methods,
-            staticMethods);
+        final java.util.Map<String, FieldValue> fields = classNode.getFields().stream().collect(toMap(field -> field.getName(), field -> new FieldValue(field.getName(), field.getType())));
+        final org.zwobble.couscous.interpreter.values.MethodValue constructor = new MethodValue(getArgumentTypes(classNode.getConstructor().getArguments()), (environment, arguments) -> Executor.callMethod(environment, classNode.getConstructor(), Optional.of(arguments.getReceiver()), arguments.getPositionalArguments()));
+        final java.util.Map<String, MethodValue> methods = classNode.getMethods().stream().filter(method -> !method.isStatic()).collect(toMap(method -> method.getName(), method -> {
+            List<TypeName> argumentTypes = getArgumentTypes(method.getArguments());
+            return new MethodValue(argumentTypes, (environment, arguments) -> {
+                return Executor.callMethod(environment, method, Optional.of(arguments.getReceiver()), arguments.getPositionalArguments());
+            });
+        }));
+        final java.util.Map<String, StaticMethodValue> staticMethods = classNode.getMethods().stream().filter(method -> method.isStatic()).collect(toMap(method -> method.getName(), method -> {
+            List<TypeName> argumentTypes = getArgumentTypes(method.getArguments());
+            return new StaticMethodValue(argumentTypes, (environment, arguments) -> {
+                return Executor.callMethod(environment, method, Optional.empty(), arguments);
+            });
+        }));
+        return new ConcreteType(classNode.getName(), fields, constructor, methods, staticMethods);
     }
     
     private static List<TypeName> getArgumentTypes(List<FormalArgumentNode> arguments) {
-        return arguments
-            .stream()
-            .map(arg -> arg.getType())
-            .collect(Collectors.toList());
+        return arguments.stream().map(arg -> arg.getType()).collect(Collectors.toList());
     }
-
     private final TypeName name;
     private final Map<String, FieldValue> fields;
     private final MethodValue constructor;
     private final Map<String, MethodValue> methods;
     private final Map<String, StaticMethodValue> staticMethods;
-
-    public ConcreteType(
-            TypeName name,
-            Map<String, FieldValue> fields,
-            MethodValue constructor,
-            Map<String, MethodValue> methods,
-            Map<String, StaticMethodValue> staticMethods) {
+    
+    public ConcreteType(TypeName name, Map<String, FieldValue> fields, MethodValue constructor, Map<String, MethodValue> methods, Map<String, StaticMethodValue> staticMethods) {
         this.name = name;
         this.fields = fields;
         this.constructor = constructor;
@@ -170,27 +103,21 @@ public class ConcreteType {
     public Optional<FieldValue> getField(String fieldName) {
         return Optional.ofNullable(fields.get(fieldName));
     }
-
+    
     public InterpreterValue callMethod(Environment environment, InterpreterValue receiver, String methodName, List<InterpreterValue> arguments) {
-        val method = findMethod(methods, methodName, arguments);
-        return method.apply(
-            environment,
-            MethodCallArguments.of(receiver, new PositionalArguments(arguments)));
+        final org.zwobble.couscous.interpreter.values.MethodValue method = findMethod(methods, methodName, arguments);
+        return method.apply(environment, MethodCallArguments.of(receiver, new PositionalArguments(arguments)));
     }
-
+    
     public InterpreterValue callStaticMethod(Environment environment, String methodName, List<InterpreterValue> arguments) {
-        val method = findMethod(staticMethods, methodName, arguments);
+        final org.zwobble.couscous.interpreter.values.StaticMethodValue method = findMethod(staticMethods, methodName, arguments);
         return method.apply(environment, new PositionalArguments(arguments));
     }
-
-    public InterpreterValue callConstructor(
-            Environment environment,
-            List<InterpreterValue> arguments) {
-        val object = new ObjectInterpreterValue(this);
+    
+    public InterpreterValue callConstructor(Environment environment, List<InterpreterValue> arguments) {
+        final org.zwobble.couscous.interpreter.values.ObjectInterpreterValue object = new ObjectInterpreterValue(this);
         checkMethodArguments(constructor, arguments);
-        constructor.apply(
-            environment,
-            MethodCallArguments.of(object, new PositionalArguments(arguments)));
+        constructor.apply(environment, MethodCallArguments.of(object, new PositionalArguments(arguments)));
         return object;
     }
     
@@ -198,20 +125,17 @@ public class ConcreteType {
         if (!methods.containsKey(methodName)) {
             throw new NoSuchMethod(methodName);
         }
-        val method = methods.get(methodName);
+        final T method = methods.get(methodName);
         checkMethodArguments(method, arguments);
         return method;
     }
-
-    private static void checkMethodArguments(
-            final Callable method,
-            List<InterpreterValue> arguments) {
+    
+    private static void checkMethodArguments(final Callable method, List<InterpreterValue> arguments) {
         if (method.getArgumentTypes().size() != arguments.size()) {
             throw new WrongNumberOfArguments(method.getArgumentTypes().size(), arguments.size());
         }
-        
         for (int index = 0; index < arguments.size(); index++) {
-            val formalArgumentType = method.getArgumentTypes().get(index);
+            final org.zwobble.couscous.ast.TypeName formalArgumentType = method.getArgumentTypes().get(index);
             InterpreterTypes.checkIsInstance(formalArgumentType, arguments.get(index));
         }
     }
@@ -220,4 +144,4 @@ public class ConcreteType {
     public String toString() {
         return "ConcreteType<" + name + ">";
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/FieldValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/FieldValue.java
index d778144..4ee1c95 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/FieldValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/FieldValue.java
@@ -2,10 +2,50 @@ package org.zwobble.couscous.interpreter.values;
 
 import org.zwobble.couscous.ast.TypeName;
 
-import lombok.Value;
+public final class FieldValue {
+    private final String name;
+    private final TypeName type;
 
-@Value
-public class FieldValue {
-    String name;
-    TypeName type;
-}
+    public FieldValue(final String name, final TypeName type) {
+        this.name = name;
+        this.type = type;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public TypeName getType() {
+        return this.type;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof FieldValue)) return false;
+        final FieldValue other = (FieldValue)o;
+        final java.lang.Object this$name = this.getName();
+        final java.lang.Object other$name = other.getName();
+        if (this$name == null ? other$name != null : !this$name.equals(other$name)) return false;
+        final java.lang.Object this$type = this.getType();
+        final java.lang.Object other$type = other.getType();
+        if (this$type == null ? other$type != null : !this$type.equals(other$type)) return false;
+        return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final java.lang.Object $name = this.getName();
+        result = result * PRIME + ($name == null ? 43 : $name.hashCode());
+        final java.lang.Object $type = this.getType();
+        result = result * PRIME + ($type == null ? 43 : $type.hashCode());
+        return result;
+    }
+
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "FieldValue(name=" + this.getName() + ", type=" + this.getType() + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
index 95b05aa..bd214cb 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java
@@ -1,48 +1,67 @@
 package org.zwobble.couscous.interpreter.values;
 
 import java.util.Optional;
-
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.values.IntegerValue;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
 import org.zwobble.couscous.values.StringValue;
-
 import static java.util.Arrays.asList;
 
-import lombok.Value;
-import lombok.val;
-
-@Value
-public class IntegerInterpreterValue implements InterpreterValue {
-    public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF)
-        .staticMethod("parseInt", asList(StringValue.REF),
-            (environment, arguments) -> {
-                val value = (StringInterpreterValue)arguments.get(0);
-                return new IntegerInterpreterValue(Integer.parseInt(value.getValue()));
-            })
-        
-        .build();
-    
-    int value;
-
+public final class IntegerInterpreterValue implements InterpreterValue {
+    public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF).staticMethod("parseInt", asList(StringValue.REF), (environment, arguments) -> {
+        StringInterpreterValue value = (StringInterpreterValue)arguments.get(0);
+        return new IntegerInterpreterValue(Integer.parseInt(value.getValue()));
+    }).build();
+    private final int value;
+    
     @Override
     public ConcreteType getType() {
         return TYPE;
     }
-
+    
     @Override
     public Optional<PrimitiveValue> toPrimitiveValue() {
         return Optional.of(PrimitiveValues.value(value));
     }
-
+    
     @Override
     public InterpreterValue getField(String fieldName) {
         throw new NoSuchField(fieldName);
     }
-
+    
     @Override
     public void setField(String fieldName, InterpreterValue value) {
         throw new NoSuchField(fieldName);
     }
-}
+    
+    public IntegerInterpreterValue(final int value) {
+        this.value = value;
+    }
+    
+    public int getValue() {
+        return this.value;
+    }
+    
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof IntegerInterpreterValue)) return false;
+        final IntegerInterpreterValue other = (IntegerInterpreterValue)o;
+        if (this.getValue() != other.getValue()) return false;
+        return true;
+    }
+    
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        result = result * PRIME + this.getValue();
+        return result;
+    }
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "IntegerInterpreterValue(value=" + this.getValue() + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java b/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java
index 9f3e937..23af57f 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java
@@ -2,11 +2,6 @@ package org.zwobble.couscous.interpreter.values;
 
 import org.zwobble.couscous.interpreter.PositionalArguments;
 
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@AllArgsConstructor(staticName="of")
-@Getter
 public class MethodCallArguments<T> {
     private final T receiver;
     private final PositionalArguments positionalArguments;
@@ -14,4 +9,21 @@ public class MethodCallArguments<T> {
     public InterpreterValue get(int index) {
         return positionalArguments.get(index);
     }
-}
+    
+    private MethodCallArguments(final T receiver, final PositionalArguments positionalArguments) {
+        this.receiver = receiver;
+        this.positionalArguments = positionalArguments;
+    }
+    
+    public static <T> MethodCallArguments<T> of(final T receiver, final PositionalArguments positionalArguments) {
+        return new MethodCallArguments<T>(receiver, positionalArguments);
+    }
+    
+    public T getReceiver() {
+        return this.receiver;
+    }
+    
+    public PositionalArguments getPositionalArguments() {
+        return this.positionalArguments;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
index b5068fc..81964fb 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
@@ -2,21 +2,53 @@ package org.zwobble.couscous.interpreter.values;
 
 import java.util.List;
 import java.util.function.BiFunction;
-
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.interpreter.Environment;
 
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Value;
-
-@Value
-public class MethodValue implements Callable {
-    List<TypeName> argumentTypes;
-    @Getter(value=AccessLevel.NONE)
-    BiFunction<Environment, MethodCallArguments<InterpreterValue>, InterpreterValue> apply;
+public final class MethodValue implements Callable {
+    private final List<TypeName> argumentTypes;
+    private final BiFunction<Environment, MethodCallArguments<InterpreterValue>, InterpreterValue> apply;
     
     public InterpreterValue apply(Environment environment, MethodCallArguments<InterpreterValue> arguments) {
         return apply.apply(environment, arguments);
     }
-}
+    
+    public MethodValue(final List<TypeName> argumentTypes, final BiFunction<Environment, MethodCallArguments<InterpreterValue>, InterpreterValue> apply) {
+        this.argumentTypes = argumentTypes;
+        this.apply = apply;
+    }
+    
+    public List<TypeName> getArgumentTypes() {
+        return this.argumentTypes;
+    }
+    
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof MethodValue)) return false;
+        final MethodValue other = (MethodValue)o;
+        final java.lang.Object this$argumentTypes = this.getArgumentTypes();
+        final java.lang.Object other$argumentTypes = other.getArgumentTypes();
+        if (this$argumentTypes == null ? other$argumentTypes != null : !this$argumentTypes.equals(other$argumentTypes)) return false;
+        final java.lang.Object this$apply = this.apply;
+        final java.lang.Object other$apply = other.apply;
+        if (this$apply == null ? other$apply != null : !this$apply.equals(other$apply)) return false;
+        return true;
+    }
+    
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final java.lang.Object $argumentTypes = this.getArgumentTypes();
+        result = result * PRIME + ($argumentTypes == null ? 43 : $argumentTypes.hashCode());
+        final java.lang.Object $apply = this.apply;
+        result = result * PRIME + ($apply == null ? 43 : $apply.hashCode());
+        return result;
+    }
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "MethodValue(argumentTypes=" + this.getArgumentTypes() + ", apply=" + this.apply + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java
index b248398..bebd5f7 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java
@@ -3,18 +3,15 @@ package org.zwobble.couscous.interpreter.values;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-
 import org.zwobble.couscous.interpreter.InterpreterTypes;
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.interpreter.UnboundField;
 import org.zwobble.couscous.values.PrimitiveValue;
 
-import lombok.val;
-
 public class ObjectInterpreterValue implements InterpreterValue {
     private final ConcreteType type;
     private final Map<String, InterpreterValue> fields;
-
+    
     public ObjectInterpreterValue(ConcreteType type) {
         this.type = type;
         this.fields = new HashMap<>();
@@ -24,26 +21,27 @@ public class ObjectInterpreterValue implements InterpreterValue {
     public ConcreteType getType() {
         return type;
     }
-
+    
     @Override
     public Optional<PrimitiveValue> toPrimitiveValue() {
         return Optional.empty();
     }
-
+    
     @Override
     public InterpreterValue getField(String fieldName) {
         type.getField(fieldName).orElseThrow(() -> new NoSuchField(fieldName));
         if (fields.containsKey(fieldName)) {
-            return fields.get(fieldName);            
+            return fields.get(fieldName);
         } else {
             throw new UnboundField(fieldName);
         }
     }
-
+    
     @Override
     public void setField(String fieldName, InterpreterValue value) {
-        val field = type.getField(fieldName).orElseThrow(() -> new NoSuchField(fieldName));
+        FieldValue field = type.getField(fieldName)
+            .orElseThrow(() -> new NoSuchField(fieldName));
         InterpreterTypes.checkIsInstance(field.getType(), value);
-        fields.put(fieldName, value);   
+        fields.put(fieldName, value);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
index 37f3c56..302582c 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
@@ -2,23 +2,54 @@ package org.zwobble.couscous.interpreter.values;
 
 import java.util.List;
 import java.util.function.BiFunction;
-
 import org.zwobble.couscous.ast.TypeName;
 import org.zwobble.couscous.interpreter.PositionalArguments;
 import org.zwobble.couscous.interpreter.Environment;
 
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.Value;
-
-@Value
-public class StaticMethodValue implements Callable {
-    List<TypeName> argumentTypes;
-    @Getter(value=AccessLevel.NONE)
-    BiFunction<Environment, PositionalArguments, InterpreterValue> apply;
+public final class StaticMethodValue implements Callable {
+    private final List<TypeName> argumentTypes;
+    private final BiFunction<Environment, PositionalArguments, InterpreterValue> apply;
     
     public InterpreterValue apply(Environment environment, PositionalArguments arguments) {
         return apply.apply(environment, arguments);
     }
-
-}
+    
+    public StaticMethodValue(final List<TypeName> argumentTypes, final BiFunction<Environment, PositionalArguments, InterpreterValue> apply) {
+        this.argumentTypes = argumentTypes;
+        this.apply = apply;
+    }
+    
+    public List<TypeName> getArgumentTypes() {
+        return this.argumentTypes;
+    }
+    
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof StaticMethodValue)) return false;
+        final StaticMethodValue other = (StaticMethodValue)o;
+        final java.lang.Object this$argumentTypes = this.getArgumentTypes();
+        final java.lang.Object other$argumentTypes = other.getArgumentTypes();
+        if (this$argumentTypes == null ? other$argumentTypes != null : !this$argumentTypes.equals(other$argumentTypes)) return false;
+        final java.lang.Object this$apply = this.apply;
+        final java.lang.Object other$apply = other.apply;
+        if (this$apply == null ? other$apply != null : !this$apply.equals(other$apply)) return false;
+        return true;
+    }
+    
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final java.lang.Object $argumentTypes = this.getArgumentTypes();
+        result = result * PRIME + ($argumentTypes == null ? 43 : $argumentTypes.hashCode());
+        final java.lang.Object $apply = this.apply;
+        result = result * PRIME + ($apply == null ? 43 : $apply.hashCode());
+        return result;
+    }
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "StaticMethodValue(argumentTypes=" + this.getArgumentTypes() + ", apply=" + this.apply + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
index 15bde43..42ee713 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
@@ -1,53 +1,71 @@
 package org.zwobble.couscous.interpreter.values;
 
 import java.util.Optional;
-
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.values.IntegerValue;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
 import org.zwobble.couscous.values.StringValue;
-
 import static java.util.Arrays.asList;
 
-import lombok.Value;
-import lombok.val;
-
-@Value
-public class StringInterpreterValue implements InterpreterValue {
-    public static final ConcreteType TYPE = ConcreteType.builder(StringInterpreterValue.class, StringValue.REF)
-        .method("length", asList(),
-            (environment, arguments) ->
-                new IntegerInterpreterValue(arguments.getReceiver().value.length()))
-        
-        .method("substring", asList(IntegerValue.REF, IntegerValue.REF),
-            (environment, arguments) -> {
-                val startIndex = (IntegerInterpreterValue)arguments.get(0);
-                val endIndex = (IntegerInterpreterValue)arguments.get(1);
-                return new StringInterpreterValue(arguments.getReceiver().value.substring(startIndex.getValue(), endIndex.getValue()));
-            })
-        
-        .build();
-    
-    String value;
-
+public final class StringInterpreterValue implements InterpreterValue {
+    public static final ConcreteType TYPE = ConcreteType.builder(StringInterpreterValue.class, StringValue.REF).method("length", asList(), (environment, arguments) -> new IntegerInterpreterValue(arguments.getReceiver().value.length())).method("substring", asList(IntegerValue.REF, IntegerValue.REF), (environment, arguments) -> {
+        IntegerInterpreterValue startIndex = (IntegerInterpreterValue)arguments.get(0);
+        IntegerInterpreterValue endIndex = (IntegerInterpreterValue)arguments.get(1);
+        return new StringInterpreterValue(arguments.getReceiver().value.substring(startIndex.getValue(), endIndex.getValue()));
+    }).build();
+    private final String value;
+    
     @Override
     public ConcreteType getType() {
         return TYPE;
     }
-
+    
     @Override
     public Optional<PrimitiveValue> toPrimitiveValue() {
         return Optional.of(PrimitiveValues.value(value));
     }
-
+    
     @Override
     public InterpreterValue getField(String fieldName) {
         throw new NoSuchField(fieldName);
     }
-
+    
     @Override
     public void setField(String fieldName, InterpreterValue value) {
         throw new NoSuchField(fieldName);
     }
-}
+    
+    public StringInterpreterValue(final String value) {
+        this.value = value;
+    }
+    
+    public String getValue() {
+        return this.value;
+    }
+    
+    @java.lang.Override
+    public boolean equals(final java.lang.Object o) {
+        if (o == this) return true;
+        if (!(o instanceof StringInterpreterValue)) return false;
+        final StringInterpreterValue other = (StringInterpreterValue)o;
+        final java.lang.Object this$value = this.getValue();
+        final java.lang.Object other$value = other.getValue();
+        if (this$value == null ? other$value != null : !this$value.equals(other$value)) return false;
+        return true;
+    }
+    
+    @java.lang.Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final java.lang.Object $value = this.getValue();
+        result = result * PRIME + ($value == null ? 43 : $value.hashCode());
+        return result;
+    }
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "StringInterpreterValue(value=" + this.getValue() + ")";
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/UnitInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/UnitInterpreterValue.java
index 1c184a4..2d4ef9c 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/UnitInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/UnitInterpreterValue.java
@@ -1,40 +1,39 @@
 package org.zwobble.couscous.interpreter.values;
 
 import java.util.Optional;
-
 import org.zwobble.couscous.interpreter.NoSuchField;
 import org.zwobble.couscous.values.PrimitiveValue;
 import org.zwobble.couscous.values.PrimitiveValues;
 
-import lombok.ToString;
-
-@ToString
 public class UnitInterpreterValue implements InterpreterValue {
-    private static final ConcreteType TYPE = ConcreteType.builder(UnitInterpreterValue.class, "Unit")
-        .build();
-    
-    public static final UnitInterpreterValue UNIT = new UnitInterpreterValue(); 
+    private static final ConcreteType TYPE = ConcreteType.builder(UnitInterpreterValue.class, "Unit").build();
+    public static final UnitInterpreterValue UNIT = new UnitInterpreterValue();
     
     private UnitInterpreterValue() {
     }
-
+    
     @Override
     public ConcreteType getType() {
         return TYPE;
     }
-
+    
     @Override
     public Optional<PrimitiveValue> toPrimitiveValue() {
         return Optional.of(PrimitiveValues.UNIT);
     }
-
+    
     @Override
     public InterpreterValue getField(String fieldName) {
         throw new NoSuchField(fieldName);
     }
-
+    
     @Override
     public void setField(String fieldName, InterpreterValue value) {
         throw new NoSuchField(fieldName);
     }
-}
+    
+    @java.lang.Override
+    public java.lang.String toString() {
+        return "UnitInterpreterValue()";
+    }
+}
\ No newline at end of file