Algebra

import algebra._
// Imports: Semigroup, Monoid, Group, CommutativeGroup, etc.

import algebra.ring._
// Imports: Ring, Field, Semiring, etc.

import algebra.lattice._
// Imports: Lattice, Bool, Heyting, etc.

import algebra.instances.all._
// Imports all standard type instances

import algebra._
import algebra.ring._
import algebra.lattice._
import algebra.instances.all._

// Using basic algebraic structures
val intMonoid = Monoid[Int]
val sum = intMonoid.combine(5, 3)  // 8

// Using ring operations
val intRing = Ring[Int]
val result = intRing.plus(intRing.times(3, 4), 2)  // 14
val fromInt = intRing.fromInt(42)  // 42

// Using field operations for rational numbers
import spire.math.Rational
val ratField = Field[Rational]
val quotient = ratField.div(Rational(3, 4), Rational(1, 2))  // 3/2

// Using lattice operations
val boolLattice = Bool[Boolean]
val conjunction = boolLattice.and(true, false)  // false
val disjunction = boolLattice.or(true, false)   // true

// Type aliases to cats-kernel structures
type Semigroup[A] = cats.kernel.Semigroup[A]
val Semigroup = cats.kernel.Semigroup

type Monoid[A] = cats.kernel.Monoid[A]  
val Monoid = cats.kernel.Monoid

type Group[A] = cats.kernel.Group[A]
val Group = cats.kernel.Group

type CommutativeGroup[A] = cats.kernel.CommutativeGroup[A]
val CommutativeGroup = cats.kernel.CommutativeGroup

trait Ring[A] extends Rig[A] with Rng[A] {
  def fromInt(n: Int): A
  def fromBigInt(n: BigInt): A
}

trait Field[A] extends EuclideanRing[A] with DivisionRing[A] with CommutativeSemifield[A] {
  def fromDouble(a: Double): A
  def gcd(a: A, b: A)(implicit eqA: Eq[A]): A
  def lcm(a: A, b: A)(implicit eqA: Eq[A]): A
}

trait Lattice[A] extends JoinSemilattice[A] with MeetSemilattice[A] {
  def dual: Lattice[A]
}

trait Bool[A] extends Heyting[A] with GenBool[A] {
  def and(a: A, b: A): A
  def or(a: A, b: A): A
  def not(a: A): A
  def xor(a: A, b: A): A
}

// Instance aggregation trait
trait AllInstances extends 
  ArrayInstances with BigDecimalInstances with BigIntInstances with
  BooleanInstances with ByteInstances with CharInstances with
  DoubleInstances with FloatInstances with IntInstances with
  ListInstances with LongInstances with MapInstances with
  OptionInstances with SetInstances with ShortInstances with
  StringInstances with TupleInstances with UnitInstances

sealed trait Priority[+P, +F] {
  def fold[Z](f: P => Z, g: F => Z): Z
  def toEither: Either[F, P]
  def isPreferred: Boolean
  def isFallback: Boolean
}

case class Preferred[P](get: P) extends Priority[P, Nothing]
case class Fallback[F](get: F) extends Priority[Nothing, F]

// Basic algebraic structures (re-exported from cats-kernel)
type Band[A] = cats.kernel.Band[A]
type BoundedSemilattice[A] = cats.kernel.BoundedSemilattice[A]
type CommutativeGroup[A] = cats.kernel.CommutativeGroup[A]
type CommutativeMonoid[A] = cats.kernel.CommutativeMonoid[A]
type CommutativeSemigroup[A] = cats.kernel.CommutativeSemigroup[A]
type Eq[A] = cats.kernel.Eq[A]
type Group[A] = cats.kernel.Group[A]
type Monoid[A] = cats.kernel.Monoid[A]
type Order[A] = cats.kernel.Order[A]
type PartialOrder[A] = cats.kernel.PartialOrder[A]
type Semigroup[A] = cats.kernel.Semigroup[A]
type Semilattice[A] = cats.kernel.Semilattice[A]

// Sign enumeration for signed types
object Sign {
  case object Zero extends Sign
  case object Positive extends Sign  
  case object Negative extends Sign
}