Code Reference

# Example 1: Aggregating a list of numbers using the addition function
numbers = [1, 2, 3, 4, 5]
result = aggregate(numbers, lambda x, y: x + y)
print(result)  # Output: 15

# Example 2: Aggregating a list of strings using the concatenation function
words = ["Hello", " ", "World", "!"]
result = aggregate(words, lambda x, y: x + y)
print(result)  # Output: Hello World!

# Example: Check if all numbers are even
numbers = Queryable([2, 4, 6, 8])
result = numbers.all(lambda x: x % 2 == 0)
print(result)  # Output: True

# Example: Check if any numbers are odd
numbers = Queryable([2, 4, 6, 8])
result = numbers.any(lambda x: x % 2 != 0)
print(result)  # Output: False

# Example: Calculate the average of a list of numbers
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.average()
print(result)  # Output: 3

# Create a Queryable with initial elements
queryable1 = Queryable([1, 2, 3])

# Another iterable to concatenate
other_iterable = [4, 5, 6]

# Concatenate the two iterables
result_queryable = queryable1.concat(other_iterable)

# Result Queryable contains elements from both iterables
assert list(result_queryable) == [1, 2, 3, 4, 5, 6]

# Example: Check if a list contains a specific element
numbers = Queryable([1, 2, 3, 4])
result = numbers.contains(3)
print(result)  # Output: True

# Example: Count the number of even numbers
numbers = Queryable([1, 2, 3, 4, 5, 6])
result = numbers.count(lambda x: x % 2 == 0)
print(result)  # Output: 3

# Example: Provide a default value for an empty list
empty_list = Queryable([])
result = empty_list.default_if_empty(default=0).to_list()
print(result)  # Output: [0]

data = [1, 2, 2, 3, 4, 4, 5]
queryable_data = Queryable(data)

distinct_queryable = queryable_data.distinct()

# Result: Queryable([1, 2, 3, 4, 5])

# Example: Get the element at index 2 in a list
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.element_at(2)
print(result)  # Output: 3

# Example: Get the element at index 5 in a list or return -1 if none found
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.element_at_or_default(5, default=-1)
print(result)  # Output: -1

# Example: Exclude common elements from two sets of numbers
set1 = Queryable([1, 2, 3, 4])
set2 = [3, 4, 5, 6]
result = set1.except_for(set2)
print(result)  # Output: Queryable([1, 2])

# Example: Find the first even number in a list
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.first(lambda x: x % 2 == 0)
print(result)  # Output: 2

# Example: Find the first odd number in a list or return 0 if none found
numbers = Queryable([2, 4, 6, 8])
result = numbers.first_or_default(lambda x: x % 2 != 0, default=0)
print(result)  # Output: 0

# Example usage of group_join

# Define two sequences
outer_sequence = Queryable([1, 2, 3, 4])
inner_sequence = Queryable([(1, 'a'), (2, 'b'), (2, 'c'), (3, 'd')])

# Perform a group join based on the first element of each tuple
result = outer_sequence.group_join(
    inner_sequence,
    outer_key_selector=lambda x: x,
    inner_key_selector=lambda x: x[0],
    result_selector=lambda outer, inner: (outer, list(inner))
)

# Display the result
for item in result:
    print(item)

# Output:
# (1, [('a',)])
# (2, [('b', 'c')])
# (3, [('d',)])
# (4, [])

# Example: Intersection of two sets of numbers
set1 = Queryable([1, 2, 3, 4])
set2 = [3, 4, 5, 6]
result = set1.intersect(set2)
print(result)  # Output: Queryable([3, 4])

# Example: Join two sets of numbers based on common factors
set1 = Queryable([1, 2, 3, 4])
set2 = [3, 4, 5, 6]
result = set1.join(set2, outer_key_selector=lambda x: x, inner_key_selector=lambda x: x % 3,
                   result_selector=lambda x, y: (x, y))
print(result.to_list())  # Output: [(1, 4), (2, 5), (3, 6)]

# Example: Find the last even number in a list
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.last(lambda x: x % 2 == 0)
print(result)  # Output: 4

# Example: Find the last odd number in a list or return 0 if none found
numbers = Queryable([2, 4, 6, 8])
result = numbers.last_or_default(lambda x: x % 2 != 0, default=0)
print(result)  # Output: 0

# Example: Find the maximum value in a list of numbers
numbers = Queryable([3, 1, 4, 1, 5, 9, 2])
result = numbers.max()
print(result)  # Output: 9

# Example: Find the minimum value in a list of numbers
numbers = Queryable([3, 1, 4, 1, 5, 9, 2])
result = numbers.min()
print(result)  # Output: 1

# Create a Queryable with mixed types
data = [1, "two", 3.0, "four", 5]

# Create a Queryable instance
queryable_data = Queryable(data)

# Filter the Queryable to include only integers
result = queryable_data.of_type(int)

# Print the filtered result
print(result)  # Output: Queryable([1, 5])

# Create a Queryable with a list of tuples
data = Queryable([(1, "apple"), (3, "banana"), (2, "orange")])

# Order the Queryable based on the first element of each tuple (numeric order)
result = data.order_by(lambda x: x[0]).to_list()

# Output: [(1, 'apple'), (2, 'orange'), (3, 'banana')]
print(result)

# Example usage of order_by_descending method
data = [5, 2, 8, 1, 7]
queryable_data = Queryable(data)

# Sorting the data in descending order based on the element itself
result = queryable_data.order_by_descending(lambda x: x)

# Result: Queryable([8, 7, 5, 2, 1])

# Another example with custom key selector
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [Person("Alice", 25), Person("Bob", 30), Person("Charlie", 22)]
queryable_people = Queryable(people)

# Sorting people by age in descending order
result = queryable_people.order_by_descending(lambda person: person.age)

# Result: Queryable([Person('Bob', 30), Person('Alice', 25), Person('Charlie', 22)])

result = Queryable.range(1, 5, 2)
print(result)
Queryable([1, 3])

result = Queryable.range(3)
print(result)
Queryable([0, 1, 2])

# Example usage of select method
def double(x):
    return x * 2

data = Queryable([1, 2, 3, 4, 5])
result = data.select(double)

# The 'result' Queryable will contain [2, 4, 6, 8, 10]

# Example usage:
def get_digits(n: int) -> Iterable[int]:
    return (int(digit) for digit in str(n))

numbers = Queryable([123, 456, 789])
result = numbers.select_many(get_digits)

print(list(result))
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Example: Find the single even number in a list
numbers = Queryable([2, 4, 6, 8])
result = numbers.single(lambda x: x % 2 == 0)
print(result)  # Output: 2

# Example: Find the single odd number in a list or return 0 if none found
numbers = Queryable([2, 4, 6, 8])
result = numbers.single_or_default(lambda x: x % 2 != 0, default=0)
print(result)  # Output: 0

# Create a Queryable with elements [1, 2, 3, 4, 5]
queryable = Queryable([1, 2, 3, 4, 5])

# Skip the first 2 elements
result = queryable.skip(2)

# The result should contain elements [3, 4, 5]
assert list(result) == [3, 4, 5]

# Example: Calculate the sum of a list of numbers
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.sum()
print(result)  # Output: 15

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [
    Person("Alice", 30),
    Person("Bob", 25),
    Person("Charlie", 35),
]

queryable_people = Queryable(people)

# Sort by age in ascending order and then by name in ascending order
sorted_people = queryable_people.order_by(lambda p: p.age).then_by(lambda p: p.name).to_list()

# Result: [Bob(25), Alice(30), Charlie(35)]

# Example usage of then_by_descending method
from typing import List

class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

people: List[Person] = [
    Person("Alice", 30),
    Person("Bob", 25),
    Person("Charlie", 35),
]

# Create a Queryable from a list of Person objects
queryable_people = Queryable(people)

# Sort the people by age in descending order
sorted_people = queryable_people.then_by_descending(lambda person: person.age)

# Display the sorted list
print(sorted_people)

# Example: Convert Queryable of tuples to a dictionary with the first element as the key
pairs = Queryable([(1, 'one'), (2, 'two'), (3, 'three')])
result = pairs.to_dictionary(key_selector=lambda x: x[0], value_selector=lambda x: x[1])
print(result)  # Output: {1: 'one', 2: 'two', 3: 'three'}

# Example: Convert Queryable to a list
numbers = Queryable([1, 2, 3, 4, 5])
result = numbers.to_list()
print(result)  # Output: [1, 2, 3, 4, 5]

# Example: Union of two sets of numbers
set1 = Queryable([1, 2, 3, 4])
set2 = [3, 4, 5, 6]
result = set1.union(set2)
print(result)  # Output: Queryable([1, 2, 3, 4, 5, 6])

# Create a Queryable with numbers from 1 to 5
numbers = Queryable([1, 2, 3, 4, 5])

# Define a predicate to filter even numbers
def is_even(n):
    return n % 2 == 0

# Use the 'where' method to filter even numbers
result = numbers.where(is_even)

# Display the result
print(list(result))
# Output: [2, 4]

queryable1 = Queryable([1, 2, 3, 4])
queryable2 = Queryable(['a', 'b', 'c', 'd'])
result = queryable1.zip(queryable2)

list(result)
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]