your code doesn't compile for me

Changed that, thanks. Sequence is defined in the kotlin/collections/Sequences.kt file, it works fine for me with the 1.0 plugin.

Oh wait, maybe it's not the 1.0 plugin.

Looks like pressing 'update' in the IntelliJ update notification did not actually update the Kotlin plugin for me. Installing it manually now, will update the gist accordingly.

how would you define a sequence with a returning lambda anyway?

this looks like a coroutine in C# but Kotlin doesn't have that

It does, there's a return@sequence statement which returns a value from the lambda expression.

yeah but only once

sequence

is now called

generateSequence

, it invokes the lambda until it returns null.

Gist updated.

That's also the reason why the sequence lambda returns null after the while-loop has finished

interesting, didn't know that

turns out kotlin had coroutines all along

I guess you could also use

for (i in pattern.indices)

Where?

in line 7

I mean 10

sorry

oh wait that's wrong

you start at 1

sorry

however you can drop the parantheses in line 10

Yes, I'll do that. I've just tried building the stdlib, but Maven complains: https://gist.github.com/cbruegg/8e2f7e208022fb59bfb4

@cbruegg: try

mvn compile -pl :kotlin-stdlib -am

Looks like I'll need to build everything else first, sorry.

@ilya.gorbunov: That makes the error go away, thanks!

@cbruegg: I have a couple questions about `occurrencesOf`: - can it be generalized to a) ignore case b) find occurrences of any of patterns, like

indexOfAny

and

findAnyOf

do? - what are the use-cases where it would be beneficial to use

occurrencesOf

instead of

indexOf

?

@ilya.gorbunov: Regarding a): That should be fairly easy to do. b): I don't think this can be achieved in a good way using Knuth-Morris-Pratt, except for just running it with pattern after pattern. It's using the prefix function to avoid unnecessary comparisons, which makes this O(n), but I can't think of a way to efficiently support multiple patterns using that method. An abstract use case would be finding all occurences of a short pattern of length

k

in a long text of length

n

, which would be O(nk) with

indexOf

, but is O(n) with

occurencesOf

. A more concrete use case: Suppose we have a large number of texts (like a search engine) we would like to run a search query against. With

occurencesOf

, we could get all relevant parts of the text very efficiently, maybe get a substring of the occurence 100 chars before and after, obtaining a summary of where the word occurs.

Updated gist with

ignoreCase

parameter.