Этот текст является вольным переводом серии статей Sacha Barber из Brighton, UK , которые мне показались достаточно интересным

Это первый пост в моей серии по F#. Итак, что мы собираемся охватить? Как хорошо знают многие программисты, принято начинать с примера «Hello World».

Так что мы будем делать именно это. Итак, без лишних слов, что нужно для создания отдельного приложения «Hello World» на F#.

Вот оно:

open System

[<EntryPoint>]
let main argv = 
    printfn "Hello World" 
    Console.ReadLine() |> ignore
    0

//К сожалению, не нашёл выделение кода для F#

Этого может показаться недостаточно для обсуждения, но тут уже есть что рассмотреть, чтобы погрузиться в некоторые принципы F#.

Так что именно здесь происходит?

Так как это отдельное приложение, нам, очевидно, нужна точка входа (так же, как и для любого другого языка .NET).

Итак, как определяется точка входа?

Ну, это почти то же самое, что и с другими языками .NET, у нас есть метод Main(или функция в F# терминологии), который принимает строковый массив, и мы используем атрибут [], чтобы указать, что метод с этим атрибутом является точкой входа.

Компилятор и Visual Studio любят нас за это.

Даже в этом примере для Вас должны звучать тревожные колокольчики или, по крайней мере, какое-то чувство непонимания. Итак, мы сказали, что есть начальная функция, которая принимает массив строкового типа. Все, что я вижу, это переменная с именем «argv», которую я не вижу объявленной, как массив. Эта переменная «argv» — это, очевидно, строковый массив, который мы ожидаем, но почему у него нет типа…. Ммм, интересно.

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

(variableName :variableType)

Поэтому, взяв приведенный выше пример «argv», мы могли бы вместо этого объявить вышеуказанную программу следующим образом, и это было бы хорошо:

open System

[<EntryPoint>]
let main (argv :string[]) = 
    printfn "Hello World" 
    Console.ReadLine() |> ignore
    0

Вы видите, что мы полностью определили имя входной переменной с ее типом, который в этом случае является массивом string [].

Что еще там интересует? Ну, как я говорил, есть о чем поговорить.

Почему у меня есть строка с этим странным |> ignore в конце. Что это?

Ну, поскольку это консольное приложение F#, я хотел, чтобы приложение не завершало работу, пока пользователь не введет символ. Так что мне нужно сделать 2 вещи:

1. Открыть пространство имен «System», которое позволяет мне использовать типы пространства имен «System», почти так же, как если бы я использовал «using System» в C # или «Imports System» в VB .NET ».
2. Так как F# является функциональным языком, он будет жаловаться, если функция, в данном случае это «Console.ReadLine (…)», которая может возвращать строку, не передаст результат далее функции «ignore», которая фактически означает return () (это способ в F# сказать void, но он называется Unit). Это явно указывает F# игнорировать результат вызова метода «Console.ReadLine (..)».

Например, вот как будет выглядеть код, если я решу не включать |> ignore



Программисту на C#/VB.NET может не увидеть, о чем здесь говорится. Но F# довольно жестко относится к тому, что функция может и не может делать. И одна вещь, которую функция ДОЛЖНА ВСЕГДА делать, это возвращать результат. В случае функции «main» ожидаемым результатом будет целочисленное значение 0.

Но как насчет случая «Console.ReadLine (..)»?

Хорошо, хоть в этом случае результат не имеет большого значения, и мы не заинтересованы в нем, и программа все равно будет работать нормально, если мы пропустим |> ignore, но если вы действительно не заинтересованы в результате, вы должны приучиться использовать |> ignore. Просто на тот случай, если вам интересно, конвейерный оператор «|>» направит возвращаемое значение левого выражения в правую функцию, что в данном случае равняется «принять возвращаемое значение Console.Readline (…) и игнорировать, как никому нет дела до него». Не беспокойтесь, если это ничего не значит для вас на данном этапе, мы еще поговорим об этом позже.

Последнее, что мне нужно сделать, это убедиться, что функция F# всегда возвращает значение, это делается в строке, где вы просто видите строку 0. Этого достаточно для того, чтобы F# понял, что это возвращаемое значение «0», которое система вывода типов выведет, это значение Int, равное 0. Причина, по которой компилятор F# знает, что это возвращаемое значение, заключается в том, что в данном случае это последнее утверждение, поэтому оно ДОЛЖНО быть возвращаемым значением. Очевидно, что это может усложниться с помощью условной логики if, else и т.д. Важно отметить, что в F# функция ДОЛЖНА ВСЕГДА возвращать значение, и в этом случае, поскольку значение 0 Int было последней найденной строкой (хотя все может быть более сложным), она используется в качестве возвращаемого значения. Вы, конечно, можете вернуть Unit, что делается с помощью «()», который фактически ничего не возвращает (void, если хотите).

Еще одна вещь, которую я хотел бы упомянуть в этом тривиальном примере, это то, что пробел играет ключевую роль в разработке F#.

Например, предположим, что мой тривиальный пример выглядел так в редакторе (в моем случае Visual Studio 2012):



Это крошечная программа, и ВСЕ, что я сделал, это удалил пробелы в начале строки «printfn». Мммм, похоже, что компилятору F# это совсем не понравилось. Да, это справедливо.

В F # пробел ОЧЕНЬ ОЧЕНЬ важен, так что играйте с ним хорошо, иначе привыкните к отладке загадочных ошибок, таких как показанная выше, которая вызвана простой проблемой некорректного семантического пробела.

Во всяком случае, это пример «Hello World». Пока мы не встретимся снова в следующий раз, я желаю вам всего хорошего.