[Перевод] Функциональное мышление. Часть 316.10.2018 11:04

Подъехала третья часть из серии статей по функциональному программированию. Сегодня мы расскажем обо всех типах этой парадигмы и на примерах покажем их использование. Подробнее о примитивных типах, обобщенных типах и многом другом под катом!

Первая часть
Вторая часть

Теперь, когда у нас есть некоторое понимание функций, мы посмотрим, как типы взаимодействуют с функциями, такими как domain и range. Данная статья — это просто обзор. Для более глубокого погружения в типы есть серия «understanding F# types».

Для начала нам надо чуть лучше понять нотацию типов. Мы видели стрелочную нотацию »->», разделяющую domain и range. Так что сигнатура функций всегда выглядит вот так:

val functionName : domain -> range

Еще несколько примеров функций:

let intToString x = sprintf "x is %i" x  // форматирует int в string
let stringToInt x = System.Int32.Parse(x)

Если выполнить этот код в интерактивном окне, можно увидеть следующие сигнатуры:

val intToString : int -> string
val stringToInt : string -> int

Они означают:

• intToString имеет domain типа int, который сопоставляется с range типа string.
• stringToInt имеет domain типа string, который сопоставляется с range типа int.

Примитивные типы

Есть ожидаемые примитивные типы: string, int, float, bool, char, byte, и т.д., а также еще множество других производных от системы типов .NET.

Еще пара примеров функций с примитивными типами:

let intToFloat x = float x // "float" ф-ция конвертирует int во float
let intToBool x = (x = 2)  // true если x равен 2
let stringToString x = x + " world"

и их сигнатуры:

val intToFloat : int -> float
val intToBool : int -> bool
val stringToString : string -> string

Аннотация типов

В предыдущих примерах компилятор F# корректно определял типы параметров и результатов. Но так бывает не всегда. Если попробовать выполнить следующий код, будет получена ошибка компиляции:

let stringLength x = x.Length         
   => error FS0072: Lookup on object of indeterminate type

Компилятор не знает тип аргумента «x», и из-за этого не знает, является ли «Length» валидным методом. В большинстве случаев, это может быть исправлено через передачу «аннотации типа» компилятору F#. Тогда он будет знать, какой тип необходимо использовать. В исправленной версии мы указываем, что тип «x» — string.

let stringLength (x:string) = x.Length         

Скобки вокруг параметра x:string важны. Если они будут пропущены, то компилятор решит, что строкой является возвращаемое значение! То есть, «открытое» двоеточие используется для обозначения типа возвращаемого значения, как показано в следующем примере.

let stringLengthAsInt (x:string) :int = x.Length         

Мы указываем, что параметр x является строкой, а возвращаемым значением является целое число.

Типы функций как параметры

Функция, которая принимает другие функции как параметры или возвращает функцию, называется функцией высшего порядка (higher-order function иногда сокращается до HOF). Их применяют в качестве абстракции для задания как можно более общего поведения. Данный вид функций очень распространен в F#, их использует большинство стандартных библиотек.

Рассмотрим функцию evalWith5ThenAdd2, которая принимает функцию в качестве параметра, и затем вычисляет эту функцию от 5 и добавляет 2 к результату:

let evalWith5ThenAdd2 fn = fn 5 + 2     // то же самое, что и fn(5) + 2

Сигнатура этой функции выглядит так:

val evalWith5ThenAdd2 : (int -> int) -> int

Можно увидеть, что domain равен (int->int), а range int. Что это значит? Это значит, что входным параметром является не простое значение, а функция из множества функций из int в int. Выходное же значение не функция, а просто int.

Попробуем:

let add1 x = x + 1      // описываем ф-цию типа (int -> int)
evalWith5ThenAdd2 add1  // тестируем ее

и получим:

val add1 : int -> int
val it : int = 8

»add1» — это функция, которая сопоставляет int в int, как мы видим из сигнатуры. Она является допустимым параметром evalWith5ThenAdd2, и ее результат равен 8.

Кстати, специальное слово »it» используется для обозначения последнего вычисленного значения, в данном случае это результат, которого мы ждали. Это не ключевое слово, это просто соглашение об именовании.

Другой случай:

let times3 x = x * 3      // ф-ция типа (int -> int)
evalWith5ThenAdd2 times3  // пробуем ее

дает:

val times3 : int -> int
val it : int = 17

»times3» также является функцией, которая сопоставляет int в int, что видно из сигнатуры. Она также является валидным параметром для evalWith5ThenAdd2. Результат вычислений равен 17.

Следует учесть, что входные данные чувствительны к типам. Если передаваемая функция использует float, а не int, то ничего не получится. Например, если у нас есть:

let times3float x = x * 3.0  // ф-ция типа (float->float)  
evalWith5ThenAdd2 times3float 

Компилятор, при попытке скомпилировать, вернет ошибку:

error FS0001: Type mismatch. Expecting a int -> int but 
              given a float -> float    

сообщающую, что входная функция должна быть функцией типа int->int.

Функции как выходные данные

Функции-значения также могут быть результатом функций. Например, следующая функция сгенерирует «adder» функцию, которая будет добавлять входное значение.

let adderGenerator numberToAdd = (+) numberToAdd

Ее сигнатура:

val adderGenerator : int -> (int -> int)

означает, что генератор принимает int и создает функцию («adder»), которая сопоставляет ints в ints. Посмотрим как это работает:

let add1 = adderGenerator 1
let add2 = adderGenerator 2

Создаются две функции сумматора. Первой создается функция, добавляющая к вводу 1, вторая добавляет 2. Заметим, что сигнатуры именно такие, какие мы ожидали.

val add1 : (int -> int)
val add2 : (int -> int)

Теперь можно использовать генерируемые функции как обычные, они ничем не отличаются от функций, определенных явно:

add1 5    // val it : int = 6
add2 5    // val it : int = 7

Использование аннотаций типа для ограничения типов функции

В первом примере мы рассмотрели функцию:

let evalWith5ThenAdd2 fn = fn 5 +2
> val evalWith5ThenAdd2 : (int -> int) -> int

В данном примере F# может сделать вывод, что »fn» преобразует int в int, поэтому ее сигнатура будет int->int.

Но какова сигнатура «fn» в следующем случае?

let evalWith5 fn = fn 5

Понятно, что »fn» — разновидность функции, которая принимает int, но что она возвращает? Компилятор не может ответить на этот вопрос. В таких случаях, если возникает необходимость указать тип функции, можно добавить тип аннотации для параметров функций, также как и для примитивных типов.

let evalWith5AsInt (fn:int->int) = fn 5
let evalWith5AsFloat (fn:int->float) = fn 5

Кроме того, можно определить возвращаемый тип.

let evalWith5AsString fn :string = fn 5

Т.к. основная функция возвращает string, функция »fn» также вынуждена возвращать string. Таким образом, не требуется явно указывать тип »fn».

Тип «unit»

В процессе программирования мы иногда хотим, чтобы функция делала что-то, не возвращая ничего. Рассмотрим функцию »printInt». Функция действительно ничего не возвращает. Она просто выводит строку на консоль как побочный эффект исполнения.

let printInt x = printf "x is %i" x        // вывод на консоль

Какова же ее сигнатура?

val printInt : int -> unit

Что такое »unit»?

Даже если функция не возвращает значений, ей все еще нужен range. В мире математики не существует «void» функций. Каждая функция должна что-то возвращать, потому-что функция — это отображение, а отображение должно что-то отображать!

Итак, в F# функции, подобные этой, возвращают специальный тип результата, называемый »unit». Он содержит только одно значение, обозначаемое »()». Можно подумать, что unit и () — что-то вроде «void» и «null» из C# соответственно. Но в отличие от них, unit является реальным типом, а () реальным значением. Чтобы убедиться в этом, достаточно выполнить:

let whatIsThis = ()

будет получена следующая сигнатура:

val whatIsThis : unit = ()

Которая указывает, что метка »whatIsThis» принадлежит типу unit и связана со значением ().

Теперь, вернувшись к сигнатуре »printInt», можно понять значение этой записи:

val printInt : int -> unit

Данная сигнатура говорит, что printInt имеет domain из int, который преобразуется в нечто, что нас не интересует.

Функции без параметров

Теперь, когда мы понимаем unit, можем ли мы предсказать его появление в другом контексте? Например, попробуем создать многократно используемую функцию «hello world». Поскольку нет ни ввода ни вывода, мы можем ожидать сигнатуру unit -> unit. Посмотрим:

let printHello = printf "hello world"        // вывод на консоль

Результат:

hello world
val printHello : unit = ()

Не совсем то, что мы ожидали. «Hello world» было выведено немедленно, а результатом стала не функция, а простое значение типа unit. Мы можем сказать, что это простое значение, поскольку, как мы видели ранее, оно имеет сигнатуру вида:

val aName: type = constant

В данном примере мы видим, что printHello действительно является простым значением (). Это не функция, которую мы можем вызвать позже.

В чем разница между printInt и printHello? В случае с printInt значение не может быть определено до тех пор, пока мы не узнаем значения параметра x, поэтому определение было функцией. В случае printHello нет параметров, поэтому правая часть может быть определена на месте. И она была равна () с побочным эффектом в виде вывода на консоль.

Можно создать настоящую многократно используемую функцию без параметров, заставляя определение иметь unit аргумент:

let printHelloFn () = printf "hello world"    // вывод на консоль

Теперь ее сигнатура равна:

val printHelloFn : unit -> unit

и чтобы вызвать ее, мы должны передать () в качестве параметра:

printHelloFn ()

Усиление unit типов с помощью функции ignore

В некоторых случаях компилятор требует unit тип и жалуется. Для примера, оба следующих случая вызовут ошибку компилятора:

do 1+1     // => FS0020: This expression should have type 'unit'

let something = 
  2+2      // => FS0020: This expression should have type 'unit'
  "hello"

Чтобы помочь в данных ситуациях, существует специальная функция ignore, которая принимает что угодно и возвращает unit. Корректная версия данного кода могла бы быть такой:

do (1+1 |> ignore)  // ok

let something = 
  2+2 |> ignore     // ok
  "hello"

Обобщенные типы

В большинстве случаев, если тип параметра функции может быть любым типом, нам надо как-то сказать об этом. F# использует обобщения (generic) из .NET для таких ситуаций.

Например, следующая функция конвертирует параметр в строку добавляя немного текста:

let onAStick x = x.ToString() + " on a stick"

Не важно какого типа параметр, все объекты умеют в ToString().

Сигнатура:

val onAStick : 'a -> string

Что за тип 'a? В F# — это способ индикации обобщенного типа, который неизвестен на момент компиляции. Апостроф перед «a» означает, что тип является обобщенным. Эквивалент данной сигнатуры на C#:

string onAStick();   

//или более идиоматично
string OnAStick();   // F#-еры используют написание 'a так же как 
                              // C#'-еры используют написание "TObject" по конвенции 

onAStick 22
onAStick 3.14159
onAStick "hello"

let concatString x y = x.ToString() + y.ToString()

val concatString : 'a -> 'b -> string

let isEqual x y = (x=y)

val isEqual : 'a -> 'a -> bool 

string * int      // ("hello", 1)

int list          // List type  например [1;2;3]
string list       // List type  например ["a";"b";"c"]
seq          // Seq type   например seq{1..10}
int []            // Array type например [|1;2;3|]

int option        // Some 1  

let testA   = float 2
let testB x = float 2
let testC x = float 2 + x
let testD x = x.ToString().Length
let testE (x:float) = x.ToString().Length
let testF x = printfn "%s" x
let testG x = printfn "%f" x
let testH   = 2 * 2 |> ignore
let testI x = 2 * 2 |> ignore
let testJ (x:int) = 2 * 2 |> ignore
let testK   = "hello"
let testL() = "hello"
let testM x = x=x
let testN x = x 1          // подсказка: что в данном случае x?
let testO x:string = x 1   // подсказка: что меняется при :string ? 

© Habrahabr.ru