enumeration module

class cls.enumeration.ComputationStep

_abc_impl = <_abc._abc_data object>

run() → None

class cls.enumeration.EmptyStep

_abc_impl = <_abc._abc_data object>

class cls.enumeration.Enumeration

class LocalClearCacheComputation(outer: Enumeration[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

_add_opt(other: Enumeration[C]) → Enumeration[Union[C, A]]

_mul_opt(other: Enumeration[C]) → Enumeration[Tuple[C, A]]

all_values() → Iterator[A]

cached_computation(index: int) → ComputationStep

cached_max_size_computation() → ComputationStep

clear_cache() → None

clear_cache_computation() → ComputationStep

abstract computation(index: int) → ComputationStep

static empty() → Enumeration[C]

get_values(index: int) → Finite[A]

static ints() → Enumeration[int]

static lazy(factory: Callable[[], Enumeration[C]]) → Enumeration[C]

static lazy_singleton(value: Callable[[], C]) → Enumeration[C]

map(f: Callable[[A], C]) → Enumeration[C]

abstract max_size_computation() → ComputationStep

static of(iterable: Iterable[C]) → Enumeration[C]

pay() → Enumeration[A]

static singleton(value: C) → Enumeration[C]

unsafe_max_size() → Union[int, NoReturn]

class cls.enumeration.EnumerationEmpty

_abc_impl = <_abc._abc_data object>

_add_opt(other: Enumeration[C]) → Enumeration[Union[C, A]]

_mul_opt(other: Enumeration[C]) → Enumeration[Tuple[C, A]]

clear_cache() → None

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

get_values(index: int) → Finite[A]

map(f: Callable[[A], C]) → Enumeration[C]

max_size_computation() → ComputationStep

pay()

class cls.enumeration.EnumerationLazy(factory: Callable[[], Enumeration[A]])

class LazyComputation(outer: EnumerationLazy[A], index: int)

_abc_impl = <_abc._abc_data object>

class LocalClearCacheComputation(outer: EnumerationLazy[A])

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationLazy[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationLazySingleton(value: Callable[[], A])

class LazySingletonComputation(outer: EnumerationLazySingleton[A], index: int)

_abc_impl = <_abc._abc_data object>

class LocalClearCacheComputation(outer: EnumerationLazySingleton[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

get_values(index: int) → Finite[A]

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationMap(over: Enumeration[C], f: Callable[[C], A])

class LocalClearCacheComputation(outer: EnumerationMap[C, A])

_abc_impl = <_abc._abc_data object>

class MapComputation(outer: EnumerationMap[C, A], index: int)

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationMap[C, A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

map(f: Callable[[A], C]) → Enumeration[C]

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationOfIterable(iterable: Iterable[A])

class IterableComputation(outer: EnumerationOfIterable[A], index: int)

_abc_impl = <_abc._abc_data object>

class LocalClearCacheComputation(outer: EnumerationOfIterable[A])

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationOfIterable[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationPay(other: Enumeration[A])

class LocalClearCacheComputation(outer: EnumerationPay[A])

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationPay[A])

_abc_impl = <_abc._abc_data object>

class PayComputation(outer: EnumerationPay[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationProduct(left: Enumeration[A], right: Enumeration[B])

class LocalClearCacheComputation(outer: EnumerationProduct[A, B])

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationProduct[A])

_abc_impl = <_abc._abc_data object>

class ProductComputation(outer: EnumerationProduct[A, B], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationSingleton(value: A)

class SingletonComputation(outer: EnumerationSingleton[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

_mul_opt(other: Enumeration[C]) → Enumeration[Tuple[C, A]]

clear_cache() → None

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

get_values(index: int) → Finite[A]

map(f: Callable[[A], C]) → Enumeration[C]

max_size_computation() → ComputationStep

class cls.enumeration.EnumerationSlice(over: Enumeration[A], s: slice)

class LocalClearCacheComputation(outer: EnumerationSlice[A])

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: EnumerationSlice[A])

_abc_impl = <_abc._abc_data object>

class SliceComputation(outer: EnumerationSlice[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.EnumerationUnion(left: Enumeration[A], right: Enumeration[A])

class LocalClearCacheComputation(outer: EnumerationUnion[A])

_abc_impl = <_abc._abc_data object>

class MaxSizeComputation(outer: EnumerationUnion[A])

_abc_impl = <_abc._abc_data object>

class UnionComputation(outer: EnumerationUnion[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

max_size_computation() → ComputationStep

class cls.enumeration.Finite

class LocalClearCacheComputation(outer: Finite[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

_add_opt(other: Finite[C]) → Finite[Union[C, A]]

_mul_opt(other: Finite[C]) → Finite[Tuple[C, A]]

cached_computation(index: int) → ComputationStep

cached_size_computation() → ComputationStep

clear_cache() → None

clear_cache_computation() → ComputationStep

abstract computation(index: int) → ComputationStep

static empty() → Finite[C]

get_checked(index: int) → A

static lazy_singleton(value: Callable[[], C]) → Finite[C]

map(f: Callable[[A], C]) → Finite[C]

static of(seq: Sequence[C]) → Finite[C]

static singleton(value: C) → Finite[C]

property size: int

abstract size_computation() → ComputationStep

class cls.enumeration.FiniteEmpty

_abc_impl = <_abc._abc_data object>

_add_opt(other: Finite[C]) → Finite[Union[C, A]]

_mul_opt(other: Finite[C]) → Finite[Tuple[C, A]]

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

map(f: Callable[[A], C]) → Finite[C]

pay()

size_computation() → ComputationStep

class cls.enumeration.FiniteLazySingleton(value: Callable[[], A])

class LocalClearCacheComputation(outer: Finite[A])

_abc_impl = <_abc._abc_data object>

class SingletonComputation(outer: FiniteLazySingleton[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.FiniteMap(over: Finite[C], f: Callable[[C], A])

class LocalClearCacheComputation(outer: FiniteMap[C, A])

_abc_impl = <_abc._abc_data object>

class MapComputation(outer: FiniteMap[C, A], index: int)

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: FiniteMap[C, A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

map(f: Callable[[A], C]) → Finite[C]

size_computation() → ComputationStep

class cls.enumeration.FiniteOfSequence(seq: Sequence[A])

class SequenceComputation(outer: FiniteOfSequence[A], index: int)

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: FiniteOfSequence[A])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.FiniteProduct(left: Finite[A], right: Finite[B])

class LocalClearCacheComputation(outer: FiniteProduct[A, B])

_abc_impl = <_abc._abc_data object>

class ProductComputation(outer: FiniteProduct[A, B], index: int)

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: FiniteProduct[A, B])

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.FiniteSingleton(value: A)

_abc_impl = <_abc._abc_data object>

_mul_opt(other: Finite[C]) → Finite[Tuple[C, A]]

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

map(f: Callable[[A], C]) → Finite[C]

size_computation() → ComputationStep

class cls.enumeration.FiniteSlice(over: Finite[A], s: slice)

class LocalClearCacheComputation(outer: FiniteSlice[A])

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: FiniteSlice[A])

_abc_impl = <_abc._abc_data object>

class SliceComputation(outer: FiniteSlice[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.FiniteUnion(left: Finite[A], right: Finite[A])

class LocalClearCacheComputation(outer: FiniteUnion[A])

_abc_impl = <_abc._abc_data object>

class SizeComputation(outer: FiniteUnion[A])

_abc_impl = <_abc._abc_data object>

class UnionComputation(outer: FiniteUnion[A], index: int)

_abc_impl = <_abc._abc_data object>

_abc_impl = <_abc._abc_data object>

clear_cache_computation() → ComputationStep

computation(index: int) → ComputationStep

size_computation() → ComputationStep

class cls.enumeration.SchweinfurtNumbers

_rec(n)