Presentation from hotcode 2013 (http://www,hotcode.org)

1. Iteratee: функциональная потоковая обработка
Руслан Шевченко.

2. Iteratee
структуры данных (Iteratee, Enumerator, Iteratee)
которые определяют состояние процессинга
потока.
●
Разобраться что это такое
●
Построить 'с нуля' подобные интерфейсы
●
Язык scala как псевдокод
●
Показать использование как OO- паттерна
https://github.com/rssh/iteratee-article

3. Iteratee

Eng. (ee) => rus (уемый)

Trainee – тот кого тренируют

Iteratee – то, что итерируют

4. Tрадиционный подход
trait Iterator[A]
{
def next: A
def hasNext: Boolean
}
val s = initialState
while(it.hasNext) {
s = doSomething(s,it.next)
}

5. Наоборот:
trait Iteratee[A,S]
{
def doSomething(whenNext: A,S => S)
}

6. Наоборот:
trait Iteratee0[A,S]
{
def doSomething(whenNext: A,S => S)
}
Fold: - есть в стандартной библиотеке
trait Collection[A] {
...
def foldLeft(x:S)(f:(S,A)=>S)
...
}

7. Наоборот:
trait Iteratee[A,S]
{
def doSomething(whenNext: A,S => S)
}
Fold: - есть в стандартной библиотеке
trait Collection[A] {
...
def foldLeft(x:S)(f:(S,A)=>S)
...
}

8. Fold - свертка
1. Отредуцировать все элементы коллекции
с помощью какой-то операции
Collection[A]: def foldLeft[S](s0:S)((S,A)=>S)
(1 to 10) foldLeft ( _ + _)
2. Произвести разбор случаев и вернуть значение
одного типа:
Either[A,B]: def fold[X](fa: A=>X, fb: B=>X)
Left(“problem x”).fold[String]( “error:” + _ ,
“ok:” + _ )

9. Fold - свертка
1. Отредуцировать все элементы коллекции
с помощью какой-то операции
Collection[A]: def foldLeft[S](s0:S)((S,A)=>S)
(1 to 10) foldLeft ( _ + _)
2. Произвести разбор случаев и вернуть
значение одного типа:
Either[A,B]: def fold[X](fa: A=>X, fb: B=>X)
Left(“problem x”).fold[String]( “error:” + _ ,
“ok:” + _ )

10. Коллекция – это то, что дает нам fold
trait Iteratee1[A,S]
{
def fold( whenNext: (S, A) => S,
whenEof: S => S)
}

11. Коллекция – это то что, дает нам fold
trait Iteratee1[A,S]
{
def fold( whenNext: (S, A) => S,
whenEof: S => S)
}
def run(input,state) =
if (!input.isEmpty && state.isDone) {
state = whenNext(state, input.readElement)
run(input, state)
} else {
whenEof(state)
}

12. Коллекция – это то, что дает нам fold
trait Iteratee1[A,S]
{
def fold( whenNext: (S, A) => S,
whenEof: S => S)
}
def run(input,state) =
if (!input.isEmpty && !state.isDone) {
state = whenNext(state, input.readElement)
run(input, state)
} else {
whenEof(state)
}

13. trait Iteratee2[A,S]
{
def fold(whenNext: A => (Iteratee[A,S],S),
whenEnd: S => S)
}
Переходом в следующее состояние управляет
kлиент (тот, кто вызывает fold)

14. trait Iteratee3[A,S]
{
def fold(whenNext: (A => Iteratee[A,S]) => S),
whenEnd: S => S)
}
Переходом в следующее состояние управляет
коллекция

15. trait Iteratee3[A,S]
{
def fold(whenNext: (A => Iteratee[A,S]) => S),
whenEnd: S => S)
}

16. trait Iteratee4[A,S]
{
def fold[B](whenNext: (A => Iteratee[A,S]) => B),
whenEnd: S => B)
}

17. trait Iteratee4[A,S]
{
def fold[B](whenNext: (A => Iteratee[A,S]) => B),
whenEnd: S => B)
}

18. def nextStep = fold( identity // f => f,
(s:S) => Function1.constant(this)
);
def isDone = fold( f => false,
(s:S) => true
)

22. trait Iteratee4[A,S]
{
def fold[B](whenNext: (A => Iteratee[A,S]) => B),
whenEnd: S => B)
}
Секунду – давайте введем еще одно преобразование:
В текущем интерфейса
Введем условное получение следующего элемента

23. trait Iteratee5[A,S]
{
def fold[B](whenNext: (Input[A]Input[A] => Iteratee[A,S]) => B),
whenEnd: S => B)
}
sealed trait Input[+A]
case class El[+A] extends Input[A]
case object Eol extends Input[Nothing]
+ ....

24. sealed trait Input[+A]
case class El[+A] extends Input[A]
case object Eof extends Input[Nothing]
+ ....

25. case class Done[A,S](s:S) extends Iteratee4[A,S]
{
Def fold[B] ( whenNext: (Input[A] => Iteratee4[A,S])=>B,
whenDone: S => S) =
whenDone(s)
}

26. sum first N [collect]

27. case class Collect[A](s:String) extends Iteratee[A,String]
{
def fold[B](onNext: (Input[A] => Iteratee[A,String])=>B,
onDone: String => B) =
onNext { case Input.El(a) => Collect(s + a.toString)
case Input.EOF => Done(s)
}
}

28. case class Collect[A](s:String) extends Iteratee[A,String]
{
def fold[B](onNext: (Input[A] => Iteratee[A,String])=>B,
onDone: String => B) =
onNext { case Input.El(a) => Collect(s + a.toString)
case Input.EOF => Done(s)
}
}

29. case class Collect[A](s:String) extends Iteratee[A,String]
{
def fold[B](onNext: (Input[A] => Iteratee[A,String])=>B,
onDone: String => B) =
onNext { case Input.El(a) => Collect(s + a.toString)
case Input.EOF => Done(s)
}
}

30. Enumerator
Генератор элементов

31. Enumerator
Генератор элементов

32. Enumerator:
trait Enumerator[A]
{
def apply[S] (it: Iteratee[S,A]): Iteratee[S,A]
}
Сгенерировать элемент == вызвать его обработчик (fold)

33. case class ListEnumerator[A](l:List[A]) extends MyEnumerator[A]
{
def apply(it: MyIteratee4[S,A]) =
l.foldLeft(it)( (it,e) => it.fold( step => step(Input.El(e)),
Function.const(it)
)
)
}

34. Compose

Enumerator
(сгенерировать 10 елемент, а потом еще 10)

Iteratee
(принять заголовок пакета, а потом сам пакет)

35. Compose

Enumerator
(сгенерировать 10 елемент, а потом еще 10)
def compose(x: Enumerator[A], y:Enumerator[A]) =
new Enumerator[A] {
def apply[S](it: Iteratee[A,S]) = y(x(it))
}

36. Compose

Enumerator
(сгенерировать 10 елемент, а потом еще 10)
def compose(x: Enumerator[A], y:Enumerator[A]) =
new Enumerator[A] {
def apply[S](it: Iteratee[A,S]) = y(x(it))
}

37. Compose

Iteratee
(принять заголовок пакета, а потом сам пакет)
def compose[A,S](frs: Iteratee[A,S], snd:Iteratee[A,S]) =
new Iteratee[A,S] {
def fold[B](onNext: (Input[A] => Iteratee[A,S])=>B,
onDone: S => B) =
frs.fold( step => onNext(compose(step(_),snd)),
s => snd.fold(onNext,onDone)
)
}
Первое намерение:

38. Compose

Iteratee -- problems
def compose[A,S](x: MyIteratee[A,S], y:MyIteratee[A,S]) =
new MyIteratee[A,S] {
def fold[B](onNext: (Input[A] => MyIteratee[A,S])=>B,
onDone: S => B) =
frs.fold( step => onNext(compose(step(_),snd)),
s => snd.fold(onNextonNext,onDone)
)
}
Теряем символ

39. Iteratee - уточнение сигнатуры
trait Iteratee5[A,S]
{
def fold[B](whenNext: (Input[A] => Iteratee[A,S]) => B),
whenEnd: S => B)
}
old

40. Iteratee - уточнение сигнатуры
trait Iteratee5[A,S]
{
def fold[B](whenNext: (Input[A] => Iteratee[A,S]) => B),
whenEnd: S => B)
}
old

41. Iteratee - уточнение сигнатуры
trait Iteratee6[A,S]
{
def fold[B](whenNext: (Input[A] => Iteratee[A,S]) => B),
whenDone: (Input[A], S)(Input[A], S) => B)
}
new

42. sealed trait Input[+A]
case class El[+A] extends Input[A]
case object Eol extends Input[Nothing]
case object EmptyEmpty extends Input[Nothing]

43. def compose[A,S](frs: MyIteratee[A,S], snd:MyIteratee[A,S]) =
new MyIteratee[A,S] {
def fold[B](onNext: (Input[A] => MyIteratee[A,S])=>B,
onDone: (Input[A],S) => B) =
frs.fold( step => onNext(compose(step(_),snd)),
(in,s) => in match {
case Input.Eof => onDone(in,s)
case Input.Empty => snd.fold(in,s)
case Input.El(a) =>
PutOne(a)(snd).fold(onNext,onDone)
}
)
}

45. Enumeratee = Iteratee + Enumerator

46. Enumeratee = Iteratee + Enumerator

47. Enumeratee = Iteratee + Enumerator
trait Enumeratee[From, To]
{
def transform[S](it: Iteratee[From,S]): Iteratee[To, S]
= JoinIteratee(applyOn(it))
def applyOn[A](it: Iteratee[From,S]):
Iteratee[From,Iteratee[To,S]]
}

48. case class MapEnumeratee[From,To](f:From => To)
extends Enumeratee[From,To]
{
def applyOn[S](it: Iteratee[To,S]): Iteratee[From, Iteratee[To,S]]=
new Iteratee[From, Iteratee[To,S]] {
def fold[B](onNext, onDone) =
it.fold(
step => onNext( x => applyOn(step(x map f)) ),
(in, s) => onDone(Input.Empty,Done(in,s))
)
}
}
Enumeratee: пример
Доопределить map на Input: Input.El(x) map (f) = Input.El(f(x))
Input.Eof map f = Input.Eof
Input.Empy map f = Input.Empty

49. Итого:
Абстракции генерирования и потоковой обработки:

Iteratee -- конечное звено обработки элементов (fold)

Enumerator – генератор элементов (apply)

Enumeratee -- преобразователь (transform)

Строить нетривиальные процессы потоковой обработки

Комбинировать в функциональном стиле

50. FP/OOP

Можно использовать как OOP паттерн

Fold не нужен
trait OOIteratee[A,S]
{
def next(inp: Input[A]): OOIteratee[A,S]
def isDone: Boolean
}

51. trait OOIteratee[A,S]
{
def next(inp: Input[A]): OOIteratee[A,S]
def whenDone: Option[(Input[A],S)]
def isDone: Boolean = whenDone.isDefined
def whenNext: Option[Input[A]=>MyIteratee[A,S]] =
if (isDone) None else Some(next(_))
}

52. def fold[B](onNext: (Input[A]=>MyIteratee[A,S])=>B,
onDone: (Input[A],S) => B): B =
if (!isDone) {
onNext( step => next(step) )
} else {
onDone(whenDone.get)
}

53. Использование в реальной жизни
Scala - обработка потоков в play
http://www.playframework.com/documentation/2.1.1/Iteratees
C# -- Reactice Extensions (Rx)
http://msdn.microsoft.com/en-us/data/gg577609.aspx
Haskell -- Iteratee IO.
http://www.haskell.org/haskellwiki/Iteratee_I/O

54. Руслан Шевченкo

github : @rssh

https://github.com/rssh/iteratee-article

twitter: @rssh1
http://www.gosave.com
Помогаем монетизировать мобильные приложения