(findProperty(KotlinDslScriptsModel.SCRIPTS_GRADLE_PROPERTY_NAME) as? String)
        ?.split("|")
        ?.asSequence()
        ?.filter { it.isNotBlank() }
        ?.map(::canonicalFile)
        ?.filter { it.isFile }
        ?.toList()


// TODO:kotlin-dsl naive implementation for now, refine
private
fun Project.collectKotlinDslScripts(): List<File> = buildList {

    }

    @Override
    public FileCollection filter(Closure filterClosure) {
        return filter(Specs.convertClosureToSpec(filterClosure));
    }

    @Override
    public FileCollectionInternal filter(final Spec<? super File> filterSpec) {
        return new FilteredFileCollection(this, filterSpec);
    }

    /**

        split(fessConfig.getSuggestFieldContents(), ",")
                .of(stream -> stream.filter(StringUtil::isNotBlank).forEach(contentFieldNameSet::add));
        split(fessConfig.getSuggestFieldTags(), ",").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(tagFieldNameSet::add));
        split(fessConfig.getSuggestFieldRoles(), ",").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(roleFieldNameSet::add));

    minus(configuration.get())


/**
 * See [Configuration.filter].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().filter(filterSpec"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.filter(filterSpec: Spec<File>) =
    get().filter(filterSpec)


/**
 * See [Configuration.isEmpty].
 */

          try {
            // The cast is safe because tryAdvance puts a T into `holder`.
            action.accept(function.apply(uncheckedCastNullableTToT(holder), index++));
            return true;
          } finally {
            holder = null;
          }
        }
        return false;
      }

      @Override
      Splitr createSplit(Spliterator<T> from, long i) {

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter} (same).
   */
  public final FluentIterable<E> filter(Predicate<? super E> predicate) {
    return from(Iterables.filter(getDelegate(), predicate));
  }

  /**
   * Returns the elements from this fluent iterable that are instances of class {@code type}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.filter(type::isInstance).map(type::cast)}.

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter} (same).
   */
  public final FluentIterable<E> filter(Predicate<? super E> predicate) {
    return from(Iterables.filter(getDelegate(), predicate));
  }

  /**
   * Returns the elements from this fluent iterable that are instances of class {@code type}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.filter(type::isInstance).map(type::cast)}.

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter}.
   */
  public static <T extends @Nullable Object> Iterable<T> filter(
      final Iterable<T> unfiltered, final Predicate<? super T> retainIfTrue) {
    checkNotNull(unfiltered);
    checkNotNull(retainIfTrue);
    return new FluentIterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return Iterators.filter(unfiltered.iterator(), retainIfTrue);
      }

                    is File -> element
                    is SubtractingFileCollectionSpec -> element.left.minus(element.right)
                    is FilteredFileCollectionSpec -> element.collection.filter(element.filter)
                    is ProviderBackedFileCollectionSpec -> element.provider
                    is FileTree -> element

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<RoleCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<RoleCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }