hydra.core.Term Maven / Gradle / Ivy
package hydra.core;
import java.io.Serializable;
/**
* A data term
*/
public abstract class Term implements Serializable {
public static final hydra.core.Name NAME = new hydra.core.Name("hydra/core.Term");
private Term () {
}
public abstract R accept(Visitor visitor) ;
public interface Visitor {
R visit(Annotated instance) ;
R visit(Application instance) ;
R visit(Function instance) ;
R visit(Let instance) ;
R visit(List instance) ;
R visit(Literal instance) ;
R visit(Map instance) ;
R visit(Optional instance) ;
R visit(Product instance) ;
R visit(Record instance) ;
R visit(Set instance) ;
R visit(Stream instance) ;
R visit(Sum instance) ;
R visit(Union instance) ;
R visit(Variable instance) ;
R visit(Wrap instance) ;
}
public interface PartialVisitor extends Visitor {
default R otherwise(Term instance) {
throw new IllegalStateException("Non-exhaustive patterns when matching: " + (instance));
}
default R visit(Annotated instance) {
return otherwise((instance));
}
default R visit(Application instance) {
return otherwise((instance));
}
default R visit(Function instance) {
return otherwise((instance));
}
default R visit(Let instance) {
return otherwise((instance));
}
default R visit(List instance) {
return otherwise((instance));
}
default R visit(Literal instance) {
return otherwise((instance));
}
default R visit(Map instance) {
return otherwise((instance));
}
default R visit(Optional instance) {
return otherwise((instance));
}
default R visit(Product instance) {
return otherwise((instance));
}
default R visit(Record instance) {
return otherwise((instance));
}
default R visit(Set instance) {
return otherwise((instance));
}
default R visit(Stream instance) {
return otherwise((instance));
}
default R visit(Sum instance) {
return otherwise((instance));
}
default R visit(Union instance) {
return otherwise((instance));
}
default R visit(Variable instance) {
return otherwise((instance));
}
default R visit(Wrap instance) {
return otherwise((instance));
}
}
/**
* A term annotated with metadata
*/
public static final class Annotated extends hydra.core.Term implements Serializable {
/**
* A term annotated with metadata
*/
public final hydra.core.Annotated, A> value;
public Annotated (hydra.core.Annotated, A> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Annotated)) {
return false;
}
Annotated o = (Annotated) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A function application
*/
public static final class Application extends hydra.core.Term implements Serializable {
/**
* A function application
*/
public final hydra.core.Application value;
public Application (hydra.core.Application value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Application)) {
return false;
}
Application o = (Application) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A function term
*/
public static final class Function extends hydra.core.Term implements Serializable {
/**
* A function term
*/
public final hydra.core.Function value;
public Function (hydra.core.Function value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Function)) {
return false;
}
Function o = (Function) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
public static final class Let extends hydra.core.Term implements Serializable {
public final hydra.core.Let value;
public Let (hydra.core.Let value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Let)) {
return false;
}
Let o = (Let) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A list
*/
public static final class List extends hydra.core.Term implements Serializable {
/**
* A list
*/
public final java.util.List> value;
public List (java.util.List> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof List)) {
return false;
}
List o = (List) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A literal value
*/
public static final class Literal extends hydra.core.Term implements Serializable {
/**
* A literal value
*/
public final hydra.core.Literal value;
public Literal (hydra.core.Literal value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Literal)) {
return false;
}
Literal o = (Literal) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A map of keys to values
*/
public static final class Map extends hydra.core.Term implements Serializable {
/**
* A map of keys to values
*/
public final java.util.Map, hydra.core.Term> value;
public Map (java.util.Map, hydra.core.Term> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Map)) {
return false;
}
Map o = (Map) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* An optional value
*/
public static final class Optional extends hydra.core.Term implements Serializable {
/**
* An optional value
*/
public final java.util.Optional> value;
public Optional (java.util.Optional> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Optional)) {
return false;
}
Optional o = (Optional) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A tuple
*/
public static final class Product extends hydra.core.Term implements Serializable {
/**
* A tuple
*/
public final java.util.List> value;
public Product (java.util.List> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Product)) {
return false;
}
Product o = (Product) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A record term
*/
public static final class Record extends hydra.core.Term implements Serializable {
/**
* A record term
*/
public final hydra.core.Record value;
public Record (hydra.core.Record value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Record)) {
return false;
}
Record o = (Record) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A set of values
*/
public static final class Set extends hydra.core.Term implements Serializable {
/**
* A set of values
*/
public final java.util.Set> value;
public Set (java.util.Set> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Set)) {
return false;
}
Set o = (Set) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* An infinite stream of terms
*/
public static final class Stream extends hydra.core.Term implements Serializable {
/**
* An infinite stream of terms
*/
public final hydra.core.Stream value;
public Stream (hydra.core.Stream value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Stream)) {
return false;
}
Stream o = (Stream) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A variant tuple
*/
public static final class Sum extends hydra.core.Term implements Serializable {
/**
* A variant tuple
*/
public final hydra.core.Sum value;
public Sum (hydra.core.Sum value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Sum)) {
return false;
}
Sum o = (Sum) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* An injection; an instance of a union type
*/
public static final class Union extends hydra.core.Term implements Serializable {
/**
* An injection; an instance of a union type
*/
public final hydra.core.Injection value;
public Union (hydra.core.Injection value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Union)) {
return false;
}
Union o = (Union) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
/**
* A variable reference
*/
public static final class Variable extends hydra.core.Term implements Serializable {
/**
* A variable reference
*/
public final hydra.core.Name value;
public Variable (hydra.core.Name value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Variable)) {
return false;
}
Variable o = (Variable) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
public static final class Wrap extends hydra.core.Term implements Serializable {
public final hydra.core.Nominal> value;
public Wrap (hydra.core.Nominal> value) {
this.value = value;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Wrap)) {
return false;
}
Wrap o = (Wrap) (other);
return value.equals(o.value);
}
@Override
public int hashCode() {
return 2 * value.hashCode();
}
@Override
public R accept(Visitor visitor) {
return visitor.visit(this);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy