Начало
Учебные материалы
Функциональное программирование на Scheme и Kotlin
История функциональных языков Базовые типы данных Управляющие конструкции Списки, обработка списков Ленивые вычисления, частичное применение, запоминание Классы в Kotlin
Списки, обработка списков
```scheme
(define x (list 'a (+ 1 2) 'c 7)) ; создание списка из заданных значений: x->(a 3 c 7)
(list? x) ; является списком: #t
(length x) ; длина списка: 4
(list-ref x 2) ; 2-й элемент списка: c
(append '(1 2) x '(5 6)) ; сцепление списков: (1 2 a 3 c 7 5 6)
(reverse x) ; список в обратном порядке: (7 c 3 a)
(map number? x) ; применение функции к каждому элементу: (#f #t #f #t)
(map + '(1 2 3 4) '(40 30 20 10)) ; функции с 2+ параметрами к элементам нескольких списков: (41 32 23 14)
(for-each (lambda(x) (display x) (newline)) x) ; применение функции к элементам списка без образования результата
(foldl + 0 '(1 2 3 4)) ; редукция/применение функции к элементам списка слева направо: (4+(3+(2+(1+0)))) = 10
(foldl cons '() x) ; (7 c 3 a)
(foldr - 0 '(1 2 3 4)) ; применение функции к элементам списка справа налево: (1-(2-(3-(4-0)))) = -2
(filter number? x) ; фильтрация списка: (3 7)
(find number? x) ; первый элемент, для которого функция возвращает #t, или #f: 3
(find number? '(a b)) ; #f
(memp number? x) ; часть списка, для головы которого функция возвращает #t, или #f: (3 c 7)
(sort '(1 7 2 5) <) ; сортировка списка: (1 2 5 7)
```
### Язык Kotlin
##### Списки Kotlin
```kotlin
val x=listOf("a",1+2,"c",7) // создание списка из заданных значений: [a, 3, c, 7]
x is List<*> // является списком: #t
x.size // длина списка: 4
x[2] // 2-й элемент списка: "c"
listOf(1,2)+x+listOf(5,6) // сцепление списков: [1, 2, a, 3, c, 7, 5, 6]
x.reversed() // список в обратном порядке: [7, c, 3, a]
x.map{it is Int} // применение функции к каждому элементу: [false, true, false, true]
(listOf(1,2,3,4) zip listOf(40,30,20,10)).map{it.first+it.second} // к соединению нескольких списков: [41, 32, 23, 14]
x.forEach{println(x)} // применение функции ко всем элементам списка без образования результата
listOf(1,2,3,4).fold(0,{a,b->a+b}) // редукция/применение функции к элементам списка слева направо: 10
listOf(1,2,3,4).foldRight(0,{a,b->a-b}) // применение функции к элементам списка справа налево: -2
x.filter {it is Int} // фильтрация списка: [3, 7]
x.find{it is Int} // первый элемент, для которого функция возвращает true, или null: 3
listOf(1,2).find{it<0} // null
x.dropWhile{it !is Int} // часть списка, для головы которого функция возвращает false, или пустой список: [3, c, 7]
listOf(1,7,2,5).sorted() // сортировка списка: [1, 2, 5, 7]
```
##### Списки в стиле LISP
```kotlin
typealias SPair=Pair<Any?,Any?>
fun car(ls:Any?)= when(ls) {
null -> throw IllegalArgumentException("car")
is SPair -> ls.first
else -> throw IllegalArgumentException("car")
}
fun cdr(ls:Any?)= when(ls) {
null -> throw IllegalArgumentException("cdr")
is SPair -> ls.second
else -> throw IllegalArgumentException("cdr")
}
fun caar(ls:Any?)=car(car(ls))
fun cadr(ls:Any?)=car(cdr(ls))
fun cdar(ls:Any?)=cdr(car(ls))
fun cddr(ls:Any?)=cdr(cdr(ls))
val cons={ h:Any?,t:Any? -> SPair(h,t) }
fun isnull(ls:Any?)=ls==null
val eq={a:Any?,b:Any? -> a===b}
fun atom(a:Any?)= when(a) {
null -> true
is SPair -> false
else -> true
}
fun S(vararg ls:Any?):Any? {
var result:Any?=null
for(i in (ls.size-1) downTo 0)
result=cons(ls[i],result)
return result
}
var a=S(1,S(2,3),"a") // список '(1 (2 3) "a")
println(car(a))
println(cons("b",a))
```
