"fmt"
	"reflect"
)

type Stream[T any] struct {
}

func (s Stream[T]) DropWhile() Stream[T] {
	return Pipe[T, T](s)
}

func Pipe[T, R any](s Stream[T]) Stream[R] {
	it := func(fn func(R) bool) {
	}
	fmt.Println(reflect.TypeOf(it).String())
	return Stream[R]{}
}

func main() {
	s := Stream[int]{}
	s = s.DropWhile()

func (s Stream[T]) Iterate(fn func(T) bool) {
	if s.it == nil {
		return
	}
	s.it.Iterate(fn)
}

func FromIterator[T any](it Iterator[T]) Stream[T] {
	return Stream[T]{it: it}
}

func (s Stream[T]) DropWhile(fn func(T) bool) Stream[T] {
	return Pipe[T, T](s, func(t T) (T, bool) {
		return t, true
	})
}

func Pipe[T, R any](s Stream[T], op func(d T) (R, bool)) Stream[R] {
	it := func(fn func(R) bool) {

    }

    private static String linesBetween(File file, String beginLine, String endLine) {
        return file.withReader('utf-8') { reader ->
            reader.lines().iterator()
                .dropWhile { it != beginLine }
                .drop(1)
                .takeWhile { it != endLine }
                .collect()
                .join('\n')
        }
    }

    @Nullable

                    } else {
                        qualified.collectDescendantsOfType<KtSimpleNameExpression>()
                    }
                refs.map { it.getReferencedName() }
                    .dropWhile { it == ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE }
                    .joinToString(separator = ".")
                    .let(::FqName)
            }
        }
    }