Packages

trait IsSchemeLattice[L] extends JoinLattice[L]

A lattice for Scheme should support the following operations

Linear Supertypes
JoinLattice[L], PartialOrdering[L], Equiv[L], Serializable, Serializable, Monoid[L], Semigroup[L], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IsSchemeLattice
  2. JoinLattice
  3. PartialOrdering
  4. Equiv
  5. Serializable
  6. Serializable
  7. Monoid
  8. Semigroup
  9. AnyRef
  10. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait MonoidLaw extends scalaz.Monoid.SemigroupLaw
    Definition Classes
    Monoid
  2. trait SchemeLatticeLaw extends MonoidLaw
  3. trait SemigroupLaw extends AnyRef
    Definition Classes
    Semigroup
  4. trait JoinLatticeLaw extends AnyRef
    Definition Classes
    JoinLattice

Abstract Value Members

  1. abstract def binaryOp(op: BinaryOperator)(x: L, y: L): MayFail[L]

    Performs a binary operation on abstract values x and y

  2. abstract def bottom: L

    A lattice has a bottom element

    A lattice has a bottom element

    Definition Classes
    JoinLattice
  3. abstract def car[Addr](x: L)(implicit arg0: Address[Addr]): Set[Addr]

    Takes the car of a cons cell

  4. abstract def cardinality(x: L): Cardinality

    Cardinality of this value

    Cardinality of this value

    Definition Classes
    JoinLattice
  5. abstract def cdr[Addr](x: L)(implicit arg0: Address[Addr]): Set[Addr]

    Takes the cdr of a cons cell

  6. abstract def cons[Addr](car: Addr, cdr: Addr)(implicit arg0: Address[Addr]): L

    Creates a cons cell

  7. abstract def counting: Boolean

    It should state whether it supports abstract counting or not.

    It should state whether it supports abstract counting or not. (TODO: this is probably not the best place for that)

    Definition Classes
    JoinLattice
  8. abstract def getClosures[Exp, Addr](x: L)(implicit arg0: Expression[Exp], arg1: Address[Addr]): Set[(Exp, Environment[Addr])]

    Extract closures contained in this value

  9. abstract def getPrimitives[Addr, Abs](x: L)(implicit arg0: Address[Addr], arg1: JoinLattice[Abs]): Set[Primitive[Addr, Abs]]

    Extract primitives contained in this value

  10. abstract def getVectors[Addr](x: L)(implicit arg0: Address[Addr]): Set[Addr]

    Extract vector addresses contained in this value

  11. abstract def inject[Exp, Addr](x: (Exp, Environment[Addr]))(implicit arg0: Expression[Exp], arg1: Address[Addr]): L

    Injection of a closure

  12. abstract def inject[Addr, Abs](x: Primitive[Addr, Abs])(implicit arg0: Address[Addr], arg1: JoinLattice[Abs]): L

    Injection of a primitive function

  13. abstract def inject(x: Char): L

    Injection of a character

  14. abstract def inject(x: Boolean): L

    Injection of a boolean

  15. abstract def inject(x: String): L

    Injection of a string

  16. abstract def inject(x: Double): L

    Injection of a float

  17. abstract def inject(x: Int): L

    Injection of an integer

  18. abstract def injectSymbol(x: String): L

    Injection of a symbol

  19. abstract def intTop: L

    The top integer

  20. abstract def isFalse(x: L): Boolean

    Can this value be considered false for conditionals?

  21. abstract def isPrimitiveValue(x: L): Boolean

    Some elements may contain addresses in there and are therefore not considered as primitive values

    Some elements may contain addresses in there and are therefore not considered as primitive values

    Definition Classes
    JoinLattice
  22. abstract def isTrue(x: L): Boolean

    Can this value be considered true for conditionals?

  23. abstract def join(x: L, y: L): L

    Elements of the lattice can be joined together

    Elements of the lattice can be joined together

    Definition Classes
    JoinLattice
  24. abstract def name: String

    A name identifying the lattice

    A name identifying the lattice

    Definition Classes
    JoinLattice
  25. abstract def nil: L

    Nil value

  26. abstract def subsumes(x: L, y: L): Boolean

    Subsumption between two elements can be checked

    Subsumption between two elements can be checked

    Definition Classes
    JoinLattice
  27. abstract def unaryOp(op: UnaryOperator)(x: L): MayFail[L]

    Performs a unary operation on the abstract value x

  28. abstract def vector[Addr](addr: Addr, size: L, init: Addr)(implicit arg0: Address[Addr]): MayFail[(L, L)]

    Creates a vector of the given size, where the initial value lies at address.

    Creates a vector of the given size, where the initial value lies at address. Return the vector address wrapped in a lattice value, as well as the vector value itsel

  29. abstract def vectorRef[Addr](vector: L, index: L)(implicit arg0: Address[Addr]): MayFail[Set[Addr]]

    Get a value from a vector.

    Get a value from a vector. Returns the addresses where to look for the values

  30. abstract def vectorSet[Addr](vector: L, index: L, addr: Addr)(implicit arg0: Address[Addr]): MayFail[(L, Set[Addr])]

    Changes a value inside a vector.

    Changes a value inside a vector. The address given is an address where the value can be stored if needed. Returns the vector value, as well as the addresses to update in the store. The value stored is not passed to vectorSet, but will be stored in the returned addresses.

Concrete Value Members

  1. def and(x: L, y: ⇒ L): L

    Conjunction

  2. def append(x: L, y: ⇒ L): L
    Definition Classes
    JoinLattice → Semigroup
  3. final def applicative: Applicative[[α]L]
    Definition Classes
    Monoid
  4. final def apply: Apply[[α]L]
    Definition Classes
    Semigroup
  5. def boolTop: L

    The top boolean

  6. final def category: Category[[α, β]L]
    Definition Classes
    Monoid
  7. final def compose: Compose[[α, β]L]
    Definition Classes
    Semigroup
  8. def equiv(x: L, y: L): Boolean
    Definition Classes
    PartialOrdering → Equiv
  9. def gt(x: L, y: L): Boolean
    Definition Classes
    PartialOrdering
  10. def gteq(x: L, y: L): Boolean
    Definition Classes
    PartialOrdering
  11. final def ifEmpty[B](a: L)(t: ⇒ B)(f: ⇒ B)(implicit eq: Equal[L]): B
    Definition Classes
    Monoid
  12. def isMZero(a: L)(implicit eq: Equal[L]): Boolean
    Definition Classes
    Monoid
  13. def lt(x: L, y: L): Boolean
    Definition Classes
    PartialOrdering
  14. def lteq(x: L, y: L): Boolean
    Definition Classes
    JoinLattice → PartialOrdering
  15. def monoidLaw: MonoidLaw
    Definition Classes
    Monoid
  16. val monoidSyntax: MonoidSyntax[L]
    Definition Classes
    Monoid
  17. def multiply(value: L, n: Int): L
    Definition Classes
    Monoid
  18. def multiply1(value: L, n: Int): L
    Definition Classes
    Semigroup
  19. final def onEmpty[A, B](a: L)(v: ⇒ B)(implicit eq: Equal[L], mb: Monoid[B]): B
    Definition Classes
    Monoid
  20. final def onNotEmpty[B](a: L)(v: ⇒ B)(implicit eq: Equal[L], mb: Monoid[B]): B
    Definition Classes
    Monoid
  21. def or(x: L, y: ⇒ L): L

    Disjunction

  22. def reverse: PartialOrdering[L]
    Definition Classes
    PartialOrdering
  23. val schemeLatticeLaw: SchemeLatticeLaw
  24. def semigroupLaw: SemigroupLaw
    Definition Classes
    Semigroup
  25. val semigroupSyntax: SemigroupSyntax[L]
    Definition Classes
    Semigroup
  26. def totalLessThan(a: L, b: L): Boolean

    Force an artificial "total order" to sort final values and have a deterministic printing output.

    Force an artificial "total order" to sort final values and have a deterministic printing output. (The corresponding relation <= is not always transitive, but it is good enough.)

    Definition Classes
    JoinLattice
  27. def tryCompare(x: L, y: L): Option[Int]

    If x and y are comparable then returns the comparison, else returns None.

    If x and y are comparable then returns the comparison, else returns None.

    Definition Classes
    JoinLattice → PartialOrdering
  28. def zero: L
    Definition Classes
    JoinLattice → Monoid