# Compare

## Comparable Interface

The `Comparable` interface represents an object that can be compared to another object of the same type. It provides a method `compareTo` that returns a negative number if the current object is less than the other, zero if they are equal, or a positive number if the current object is greater than the other.

To make an object comparable it needs to implement the `Comparable` interface:

```typescript
class FooBar implements Comparable<FooBar>{

    constructor(private readonly code:number) {
    }

    compareTo(other: FooBar): number {
        return this.code - other.code;
    }
}

const foo = new FooBar(1);
const bar = new FooBar(2);
foo.compareTo(bar);
// Output: -1
```

### Examples:

#### Number Comparison

```typescript
const number1 = 10;
const number2 = 5;
const numberComparison = number1.compareTo(number2);
console.log(numberComparison); 
// Output: 1 (Example output; actual output will vary)
```

#### String Comparison

```typescript
const string1 = "apple";
const string2 = "banana";
const stringComparison = string1.compareTo(string2);
console.log(stringComparison); 
// Output: -1 (Example output; actual output will vary)
```

#### Date Comparison

```typescript
const date1 = new Date("2023-01-01");
const date2 = new Date("2023-01-15");
const dateComparison = date1.compareTo(date2);
console.log(dateComparison); 
// Output: -1 (Example output; actual output will vary)
```

## Comparator Interface

The `Comparator` interface represents a generic comparator function for comparing two elements of the same type. It provides a method `compare` that returns a negative number if the first element is less than the second, a positive number if the first element is greater than the second, or zero if they are equal.

### Examples:

#### Number Comparator

```typescript
const comparator: Comparator<number> = { compare: (a, b) => a - b };
console.log(comparator.compare(3, 5)); 
// Output: -2
```

#### String Comparator

```typescript
const stringComparator: Comparator<string> = { compare: (a, b) => a.localeCompare(b) };
console.log(stringComparator.compare("apple", "banana")); 
// Output: -1
```

## InlineComparator Interface

The `InlineComparator` interface represents a comparator function that can be used to compare two objects. It is a simpler alternative to the `Comparator` interface.

### Examples:

#### Number InlineComparator

```typescript
const numberComparator: InlineComparator<number> = (a, b) => a - b;
const numberComparison = numberComparator(10, 5);
console.log(numberComparison); 
// Output: 5 (Example output; actual output will vary)
```

#### String InlineComparator

```typescript
const stringComparator: InlineComparator<string> = (a, b) => a.localeCompare(b);
const stringComparison = stringComparator("apple", "banana");
console.log(stringComparison); 
// Output: -1 (Example output; actual output will vary)
```

## Prototype Extensions

*Katxupa* extends the prototypes of `Number`, `String`, and `Boolean` to include a `compareTo` method. This allows for convenient comparisons between primitive types.

### Examples:

#### Boolean Comparison

```typescript
const bool1 = true;
const bool2 = false;
console.log(bool1.compareTo(bool2)); 
// Output: 1
```

#### Number Comparison

```typescript
const num1 = 42;
const num2 = 24;
console.log(num1.compareTo(num2)); 
// Output: 18
```

#### String Comparison

```typescript
const str1 = 'apple';
const str2 = 'banana';
console.log(str1.compareTo(str2)); 
// Output: -1
```

These extensions enhance the native JavaScript types with a consistent and convenient way to perform comparisons.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://katxupa.gitbook.io/katxupa/get-a-taste-of-katxupa/usage/compare.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.