ladybird/AK/AnyOf.h

/*
 * Copyright (c) 2021, the SerenityOS developers.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Concepts.h>
#include <AK/Find.h>
#include <AK/Iterator.h>

namespace AK {

template<typename TEndIterator, IteratorPairWith<TEndIterator> TIterator>
[[nodiscard]] constexpr bool any_of(
    TIterator const& begin,
    TEndIterator const& end,
    auto const& predicate)
{
    return find_if(begin, end, predicate) != end;
}

template<IterableContainer Container>
[[nodiscard]] constexpr bool any_of(Container&& container, auto const& predicate)
{
    return any_of(container.begin(), container.end(), predicate);
}

}

using AK::any_of;
AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`/*`
			`* Copyright (c) 2021, the SerenityOS developers.`
			`*`
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt * 2021-04-22 08:24:48 +00:00			`* SPDX-License-Identifier: BSD-2-Clause`
AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`*/`

			`#pragma once`

AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version). 2021-07-22 14:41:00 +00:00			`#include <AK/Concepts.h>`
AK: Reimplement any_of in terms of find_if Problem: - Now that a generic free-function form of `find_if` is implemented the code in `any_of` is redundant. Solution: - Follow the "don't repeat yourself" mantra and make the code DRY by implementing `any_of` in terms of `find_if`. 2021-06-11 23:57:46 +00:00			`#include <AK/Find.h>`
AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`#include <AK/Iterator.h>`

			`namespace AK {`

AK: Rewrite {AnyOf,AllOf,Find}.h to use the IteratorPairWith concept This makes it so these algorithms are usable with arbitrary iterators, as opposed to just instances of AK::SimpleIterator. This commit also makes the requirement of ::index() in find_index() explicit, as previously it was accepting any iterator. 2021-07-22 14:49:34 +00:00			`template<typename TEndIterator, IteratorPairWith<TEndIterator> TIterator>`
AK: Add `nodiscard` attribute to AnyOf functions 2022-06-26 16:19:34 +00:00			`[[nodiscard]] constexpr bool any_of(`
AK: Rewrite {AnyOf,AllOf,Find}.h to use the IteratorPairWith concept This makes it so these algorithms are usable with arbitrary iterators, as opposed to just instances of AK::SimpleIterator. This commit also makes the requirement of ::index() in find_index() explicit, as previously it was accepting any iterator. 2021-07-22 14:49:34 +00:00			`TIterator const& begin,`
			`TEndIterator const& end,`
AK: Convert AnyOf/AllOf to east-const style 2021-07-22 14:43:56 +00:00			`auto const& predicate)`
AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`{`
AK: Reimplement any_of in terms of find_if Problem: - Now that a generic free-function form of `find_if` is implemented the code in `any_of` is redundant. Solution: - Follow the "don't repeat yourself" mantra and make the code DRY by implementing `any_of` in terms of `find_if`. 2021-06-11 23:57:46 +00:00			`return find_if(begin, end, predicate) != end;`
AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`}`

AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version). 2021-07-22 14:41:00 +00:00			`template<IterableContainer Container>`
AK: Add `nodiscard` attribute to AnyOf functions 2022-06-26 16:19:34 +00:00			`[[nodiscard]] constexpr bool any_of(Container&& container, auto const& predicate)`
AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version). 2021-07-22 14:41:00 +00:00			`{`
AK: Implement any_of using common implementation Problem: - `any_of` is implemented in 2 different ways, one for the entire container and a different implementation for a partial container using iterators. Solution: - Follow the "don't repeat yourself" (DRY) idiom and implement the entire container version in terms of the partial version. 2021-07-25 18:56:52 +00:00			`return any_of(container.begin(), container.end(), predicate);`
AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version). 2021-07-22 14:41:00 +00:00			`}`

AK: Implement generic any_of algorithm Problem: - Raw loops are often written to validate that any values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `any_of`. 2021-01-14 22:36:23 +00:00			`}`
AK: Publish AK::any_of by default 2021-02-07 10:35:08 +00:00
			`using AK::any_of;`