Начало
Учебные материалы
Функциональное программирование на Scheme и Kotlin
История функциональных языков Базовые типы данных Управляющие конструкции Списки, обработка списков Ленивые вычисления, частичное применение, запоминание Классы в Kotlin
Управляющие конструкции
Определение глобальных имен и функций
```scheme
(define pi 3.1415926)
(define (sqr x) (* x x)) ; квадрат
(define (plus x y) (+ x y)) ; сумма 2 чисел
```
Вызов функции, изменение значения
```scheme
(sqr pi)
(plus 2 3)
(set! pi 3)
```
`lambda`-выражения (анонимные функции)
```scheme
( (lambda (x y) (+ x y)) 2 3) ; определение и вызов анонимной функции
(define root ; функция с 1 или 2 параметрами
(case-lambda
((x) (sqrt x)) ; один аргумент - квадратный корень
((x n) (expt x (/ n))) ; два аргумента - корень n-й степени
)
)
(root 2) ; 1.4142135623730951
(root 8 3) ; 2.0
```
Последовательность действий, локальные определения
```scheme
(let
((a 2) (b 3)) ; локальные имена a b
(display "Сумма ")
(display (+ a b))
(newline)
)
(begin (display "A") (display "B") (display "C")) ; как (let () действия)
```
Результатом ``begin`` и ``let`` является значение последнего выражения Несколько действий можно указывать в ``(lambda параметры действия)``
Ветвление
```scheme
(define (min x y) ; минимум
(if (< x y) ; (if условие
x ; результат-если-условие-истинно
y ; результат-если-условие-ложно
)
)
(define (sign x) ; знак числа
(cond
((< x 0) -1) ; (условие действия)
((> x 0) 1)
(else 0) ; (else действия)
)
)
(define (whatday x) ; тип дня недели
(case x
((1 2 3 4 5) "workday") ; ((список вариантов) действия)
((6 7) "weekend")
(else "not a weekday")
)
)
```
Циклы в Scheme чаще реализуются через рекурсию, но можно использовать специальную конструкцию, похожую на ``let``
```scheme
(define (factorial n)
(if (<= n 1) 1
(* n (factorial (- n 1)))
)
)
(define (factorial n)
(do ; (do список-локальных-имен (условие-завершения действия) действия)
((i 1 (+ i 1)) ; (имя начальное-значение изменение)
(a 1 (* a i)))
((> i n) a) ; (условие-завершения результат)
)
)
(define (scale-vector! v k)
(do ((i 0 (+ i 1)))
((= i (vector-length v))) ; ничего не возвращаем
(vector-set! v i (* (vector-ref v i) k)) ; изменяем i-й элемент вектора
)
)
```
### Язык Kotlin
Определение глобальных имен и функций
```kotlin
val pi=3.1415926 // константа
var a=3 // переменная
fun sqr(x:Double)=x*x // функция, сокращенная форма
fun plus(x:Int, y:Int):Int { // функция, полная форма
return x+y
}
fun hello(s:String):Unit { // функция не возвращает значения
println("Hello, $s!")
}
```
Вызов функции, изменение значения
```kotlin
plus(2,3)
sqr(pi)
pi=3.0 // Ошибка!
a=5 // Ok
```
`lambda`-выражения, анонимные функции
```kotlin
{x:Int,y:Int -> x+y}(2,3) // Лямбда-выражение
val sqr:(Double)->Double={it*it} // по умолчанию единственный параметр называется it
val plus=fun(x:Int,y:Int):Int { return x+y } // Анонимная функция
```
Если тип параметров `lambda`-выражения ясен из предыдущего контекста, то их тип можно не указывать.
Последовательность действий, локальные определения
```kotlin
{ // интерпретируется как лямбда-выражение ()->Unit
val a=2
val b=3
print("Сумма ")
println(a+b)
}
```
Ветвление
```kotlin
fun min(x:Int,y:Int)=if(x<y) x else y // if-выражение
fun min(x:Int,y:Int):Int {
if(x<y) return x // if-оператор
else return y
}
fun sign(x:Double)= when { // when-выражение
x<0 -> -1
x>0 -> 1
else -> 0
}
fun whatday(x:Int):Unit {
when(x) { // when-оператор
in 1..5 -> println("workday")
6,7 -> println("weekend")
else -> println("not a weekday")
}
}
```
Циклы
```kotlin
val lc=listOf('a','b','c')
for(x in lc)
println(x)
for (i in 1..10) {
println(i)
}
for (i in 10 downTo 0 step 2) {
println(i)
}
var i=10
while (i >= 0) {
println(i)
i-=2
}
do {
val y = readLine()
} while (y != null)
```
