Знакомство с языком F# (Эф-шарп) на примере простого приложения для командной строки

Размещено на http://www.allbest.ru/

Лабораторная работа

Знакомство с языком F# (Эф-шарп) на примере простого приложения для командной строки



Содержание

1. Вводная часть

2. Основные положения при работе с F#

3. Создание приложения «Учебник по F#»

4. Создание консольного приложения

5. О приложении к Лабораторной работе № 21



1. Вводная часть

Функционамльное программимрование -- раздел дискретной математики и парадигма программирования, в которой процесс вычисления трактуется как вычисление значений функций в математическом понимании последних (в отличие от функций как подпрограмм в процедурном программировании).

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

F# -- это мультипарадигменный язык программирования, разработанный в подразделении Microsoft Research и предназначенный для исполнения на платформе Microsoft .NET. Он сочетает в себе выразительность функциональных языков, таких как OCaml и Haskell с возможностями и объектной моделью .NET. Язык обеспечивает безопасность относительно типов, неплохую производительность, а также способен выступать в роли языка сценариев.

Поскольку все понятия функционального программирования проникают в основные языки (C#, Visual Basic) через такие технологии, как обобщенные типы .NET или LINQ, язык F# обязан своим успехом прежде всего сообществу .NET -- причем успешен он был настолько, что в ноябре 2007 года корпорация Microsoft объявила о том, что F# будет переведён в разряд поддерживаемых языков программирования .NET.

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

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

По производительности F# сравним с C#, однако если сравнивать с языками, которые настолько же лаконичны, как F#, в частности с динамическими языками и языками сценариев, он имеет гораздо лучшие показатели. И так же как во многих динамических языках, в F# имеются средства, позволяющие проверить данные: написать фрагмент кода и запустить его в интерактивном режиме.

Первая версия языка появилась в 2005 году. С тех пор вокруг F# стало формироваться сообщество. За счёт поддержки функциональной парадигмы язык оказался востребован в научной сфере и финансовых организациях. Во многом благодаря этому Microsoft решила перевести F# из статуса исследовательских проектов в статус поддерживаемых продуктов и поставить его в один ряд с основными языками платформы .NET. И это несмотря на то, что в последнее время всё большую активность проявляют динамические языки, поддержка которых также присутствует в .NET Framework. 12 апреля 2010 года свет увидела новая версия флагманского продукта для разработчиков -- Microsoft Visual Studio 2010, которая поддерживает разработку на F# прямо из коробки, то есть можно создавать приложения сразу после установки среды разработки.

2. Основные положения при работе с F#

Исполняемый файл Fsi.exe, входящий в комплект поставки F#, представляет собой интерактивную консоль, в которой можно быстро проверить работоспособность отдельных фрагментов кода на F#. После установки среды разработки расположен по адресу (для Windows 7 64-бит): C:\Program Files (x86)\Microsoft F#\v4.0\Fsi.exe

Рис. 2.1 Fsi.exe

В состав современных инсталляционных пакетов F# входят также модули интеграции в Visual Studio 2008 и свободно распространяемую Visual Studio 2008 Shell, которые позволяют компилировать участки кода прямо из редактора кода. Открыв текст программы во встроенном редакторе кода, можно отправлять выделенные участки на исполнение простым нажатием комбинации клавиш Alt+Enter.

Исполняемый файл Fsc.exe -- непосредственно компилятор исходного кода F#, который можно использовать совместно со своим любимым текстовым редактором. Расположен в той же директории что и Fsi.exe.

Утилиты fsc.exe и fsi.exe отлично работают и под Mono, открытой реализацией .NET Framework.

Файлы, содержащие код на F#, обычно имеют следующие расширения:

*.fs -- обычный файл с кодом, который может быть скомпилирован;

*.fsi -- файл описания публичного интерфейса модуля. Обычно генерируется компилятором на основе кода, а затем редактируется вручную;

*.fsx -- исполняемый скрипт. Может быть запущен прямо из проводника Windows при помощи соответствующего пункта всплывающего меню или передан на исполнение в интерактивную консоль Fsi.exe.

Иногда можно встретить в начале F# кода директиву #light on. Эта директива отключает режим совместимости синтаксиса с OCaml, делая отступы в коде значимыми (как, например в Python или Haskell). В последних версиях языка облегчённый режим включен по умолчанию, поэтому необходимости в указании директивы #light больше нет.

Также для F# не поддерживается режим конструктора страниц ASP.NET. Это не означает, что F# нельзя использовать вместе с ASP.NET -- отнюдь. Просто в Visual Studio, работая с F#, нельзя без дополнительных средств перетаскивать элементы управления, как при работе с C# или Visual Basic.

3. Создание приложения «Учебник по F#»

После запуска Visual Studio 2010, откроется Начальная страница:

Рис. 3.1 Начальная страница VisualStudio 2010 Professional (русская версия)

Для начала, надо создать пустой проект, для этого выполним последовательно: Файл ->Создать ->Проект… (также можно просто нажать сочетание клавиш Ctrl+Shift+N или пункт «Создать проект…» на Начальной странице):



Рис. 3.2 Создание нового проекта

Откроется окно создания проекта и выбора необходимых нам параметров.

Выберем слева в пункте Установленные шаблоны->Другие языки ->VisualF#, далее найдём в списке Учебник по F#. Также здесь можно выбрать, какой использовать «фреймворк» (набора компонентов для написания программ). В нашем случае выберем .NETFramework 4.

Рис. 3.3 Окно создания нового проекта

В поле Имя вводим LWP21-Tutorial-- это название программы (выбрано по названию лабораторного практикума, номеру и названию работы). В поле Расположение указана конечная директория, где будет находиться весь проект (значение «по умолчанию» можно поменять, выполнив действия: Сервис ->Параметры… ->Проекты и решения -> меняем путь в поле Размещение проектов). Выберем расположение удобное для быстрого поиска. В поле Имя решения вводится либо название программы «по умолчанию» из поля Имя автоматически, либо можно ввести своё собственное. Под этим именем будет создана конечная папка проекта (если Имя и Имя решения разные).

Рис. 3.4 Вводим данные нового проекта «Учебник по F#»

После нажатия клавиши ОК мы увидим сформированный проект и исходный код консольного приложения (не пустого изначально).

Рис. 3.5 Исходный код консольного приложения сформированного средой разработки

Как видим, среда разработки сформировала один файл Tutorial.fs с исходным кодом. В самом конце кода вставим следующую строчку:

let c = Console.ReadKey()

Без точки с запятой как в C#... Код служит «паузой» для окна консоли после компиляции.

Теперь, можно откомпилировать созданную программу, нажав клавишу F5 или Отладка ->Начать отладку. Если программист хочет запустить программу без отладки и уверен что программа не нуждается в поиске ошибок и оптимизации кода, то можно нажать Отладка ->Запуск без отладки.

По умолчанию клавиша отладки вынесена на панель инструментов вверху. Запускаем приложение в режиме отладки (и компиляции debug-версии программы) нажав на иконку (Debug выбрано изначально).

Рис. 3.5 Запуск приложения «Учебник по F#» по конфигурации Debug

Но компиляция в случае данного приложения не нужна. Весь файл содержит примеры для изучения F#. В файле собрано достаточное количество различных примеров с использование оператора let. Более подробно о том, что делает та или иная строчка кода можно прочитать из русскоязычных комментариев (если их нет, взять код с комментариями из Приложения № 1 к данной лабораторной работе).

Для получения промежуточных результатов работы кода можно воспользоваться комбинацией: выделение участка кода + Alt+Enter.

Найдём и выделим мышкой следующий код:

/// Очень простое константное целое

let int1 = 1

/// Другое очень простое константное целое

let int2 = 2

/// Добавление двух целых

let int3 = int1 + int2

После выделения жмём «альт» + «энтер» и...:

Рис 3.6 Результат выполнения выделенного участка кода в окне F# Interactive

Как видим, здесь сработала встроенная интерактивная консоль Fsi.exe. Выделяем и выполняем другие участки кода и смотрим на результаты. Код в принципе, как уже был сказано, достаточно хорошо прокомментирован, потому в пояснениях не нуждается.

Наполним наш «учебник» новыми «уроками».

Перед вызовом функции «паузы» окна консоли добавим код:

let results = [ for i in 0 .. 100 -> (i, i*i) ]

printfn "\n\tРезультаты работы цикла и операции с шагом цикла i: i*i = \n\n%A" results

На первый взгляд этот цикл for кажется совершенно безобидным, но в действительности простым его никак не назовешь. Официально это создаваемый список (так своеобразно именуется часть кода, результатом работы которого является список).

Список -- это примитив, часто встречающийся в функциональных языках. Во многих отношениях список схож с массивом. Разница состоит в том, что список не позволяет получать доступ к отдельному элементу на основании его позиции в списке (как традиционное выражение a[i] в C#). В функциональном программировании списки можно встретить в самых различных ситуациях. По большей части их можно считать эквивалентом List<T> в .NET Framework с несколько расширенными возможностями.

Список всегда относится к какому-то определенному типу. В нашем примере идентификатор порождает список кортежей, а точнее кортежей, относимых языком F# к типу (int * int). Список кортежей можно представить в виде пары столбцов, возвращаемых оператором SELECT в SQL. Наш код создаёт список, содержащий 100 пар целых чисел.

Ни одно введение в язык программирования не обходится без программы «Hello, World». F# не станет исключением.

После цикла добавим код:

printf"HelloWorld!"

openSystem.Windows.Forms

letmb = MessageBox.Show("ПриветмириF#!", "УчебникпоF# (F#) :: РаботасMessageBox")

F# полностью поддерживает связь и взаимодействие с нижележащей платформой CLR -- в том числе и библиотеки Windows Forms. Но для работы кода выше потребуется добавить в приложение библиотеку. В обозревателе решений выделим Ссылки и нажмём правую кнопку мыши, далее в открывшемся окне на вкладке .NETнайдём System.Windows.Forms, далее ОК.

Рис. 3.7 Добавление ссылки: System.Windows.Forms



Компилируем приложение (Debug) и запускаем.Видим следующее:

Рис. 3.8 Результат выполнения новых участков кода в приложении «Учебник по F#»

Оператор let. Это вообще самый важный оператор. Формально let присваивает идентификатору значение. «Определяет переменную», но это было бы неверно. Идентификаторы в F# имеют природу двойственную. Во-первых, однажды определенный идентификатор может так никогда и не измениться. Именно этот момент позволяет писать программы, не нарушающие параллельность обработки: изменение состояния язык F# не приветствует. Во-вторых, идентификатор может относиться не только к примитивному или объектному типу, как в C# и Visual Basic, но и к функциональному типу, подобному тем, что встречаются в LINQ. Обратим внимание ещё и на то, что явно тип идентификатора никогда не указывается. Идентификатор результата, к примеру, никогда не определяется -- он выводится из правой части выражения, следующего за ним. Эта функция известна как вывод типа. Она свидетельствует о способности компилятора проанализировать код, определить возвращаемое значение и автоматически его использовать. Аналогичным образом действуют новые выражения с выводимым типом в C#, содержащие ключевое слово var. Оператор let работает не только с данными. Его можно применять для определения функций, которые в F# являются понятиями первостепенными:

консоль код интеграция приложение



let add a b =

a + b

Программа выше делает именно то, что от неё ожидается: складывает числа a и b и неявно возвращает результат вызывающей стороне. Технически, каждая функция F# возвращает значение, даже если оно по природе своей является не значением, а особой единицей под названием unit. Бывают ситуации, в которых функция должна игнорировать передаваемые ей параметры. Тогда в F# используется знак нижнего подчеркивания -- в качестве заполнителя для параметра. Добавим следующий код в наш «учебник»:

letaddab = a + b

let return10 _ = add 5 5

let ten = return10 12

printf "\n\nДесять = %d\n" ten

Как и в большинстве функциональных языков, в F# функцию можно определить частично -- в расчёте на то, что недостающие параметры будут переданы при вызове:

let add5 a =

add a 5

В определённой степени это напоминает создание перегруженного метода, который получает другой набор параметров и вызывает ещё один метод (код C#):



publicclass Adders {

publicstatic int add(int a, int b) { return a + b; }

publicstatic int add5(int a) { return add(a, 5); }

}

Но есть небольшая разница. Обратим внимание на то, что в F# типы явным образом не определяются. Это означает, что компилятор проделывает всю работу по выводу типов, определяет, совместим ли параметр функции add5 по типу с возможностью сложения с целочисленным литералом 5, и либо проводит компиляцию, либо сообщает об ошибке. В действительности в F# чаще всего имеет место неявная параметризация по типам (то есть используются общие типы).

Если в Visual Studio навести указатель мыши на определение числа десять, приведенное выше, мы увидим, что его тип объявляется следующим образом:

На языке F# это означает, что десять -- это значение, функция, принимающая один параметр любого типа, и возвращающая целочисленный результат. Синатксис с «галочкой» -- это грубый эквивалент синтаксиса <T> в C#, так что в наилучшем переводе на язык функций C# можно было бы сказать, что десять -- это экземпляр делегата метода с параметризацией типов, тип которого в действительности лучше просто игнорировать (только по правилам C# это невозможно):

delegate int Transformer<T>(T ignored);

publicclass App

{

publicstatic int return10(object ignored) { return 5 + 5; }

staticvoid Main()

{

Transformer<object> ten = return10;

System.Console.WriteLine("\n\nДесять = {0}", return10(0));

}

}

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

let compute2 x = (x, x*x)

let compute3 x = (x, x*x, x*x*x)

let results2 = [ for i in 0 .. 10 -> compute2 i ]

let results3 = [ for i in 0 .. 10 -> compute3 i ]

printfn"\n\tРезультатыработыциклаиоперациисшагомциклаi: i*i = \n\n%A"results2

printfn "\n\tРезультаты работы цикла и операции с шагом цикла i: i*i, i*i*i = \n\n%A" results3

Поэлементный просмотр списка (или массива, или любой другой схожей конструкции) настолько распространен в функциональных языках, что его свели к единому базовому методу List.iter. Он просто вызывает функцию для каждого элемента списка. Весьма полезны и другие схожие библиотечные функции. Например, метод List.map принимает в качестве аргумента функцию и применяет её к каждому элементу списка, создавая, таким образом, новый список.

Немного об асинхронном выполнении функций. Вставим следующий код:

openSystem.Threading

printf "\n"

let printWithThread str =

printfn "[ID потока = %d] %s" Thread.CurrentThread.ManagedThreadId str

let evals =

let z = 1.0

[ async { do printWithThread "Вычисляем z*z\n"

return z + z };

async { do printWithThread "Вычисляем sin(z)\n"

return (sin z) };

async { do printWithThread "Вычисляем log(z)\n"

return (log z) } ]

let awr =

async { let! vs = Async.Parallel evals

do printWithThread "Вычисляем v1 + v2 + v3\n"

return (Array.fold (fun a b -> a + b) 0.0 vs) }

let R = Async.RunSynchronously awr

printf "Результатвычислений = %f\n" R

В нём показана работа асинхронных рабочих потоков в упрощенном, удобоваримом виде. Если не вдаваться в подробности, evals является массивом функций, которые должны быть выполнены. Каждая из них помещается в очередь на выполнение путем вызова Async.Parallel. При выполнении становится ясно, что функции, входящие в массив evals, фактически находятся в отдельных потоках, идущих от функции в awr. Хотя, по причине природы пула потоков .NET, часть функций из массива evals или даже все функции могут выполняться в одном потоке, что заметно при выводе результата: части некоторых строк при печати окажутся не в том месте. Факт выполнения функций в пуле потоков .NET ещё раз подтверждает отличную приспособленность языка F# ко взаимодействию с нижележащей средой выполнения. То, что он опирается на библиотеку классов .NET там, где другие функциональные языки используют специальные методы (например, многопоточность), означает, что в программах на C# можно использовать библиотеки и модули F# -- и наоборот.

4. Создание консольного приложения

Теперь продемонстрируем возможности языка F# на примере работы непосредственно с обычным консольным приложением и созданием на его основе простенькой игры. Суть будет заключаться в воде числовых ответов на вопрос типа число умножить на число. Игра будет выдавать случайные задания, число которых определяет пользователь. Правильные ответы будут учитываться в статистике. Итогом игры станет число верных ответов и время, затраченное на ответы.

Также в коде будем использовать русскоязычные имена.

Для начала нужно создать новый проект. Основу на этот раз станет тип проекта VisualF#: Приложение F#. Имя будет LWP21Console.

Рис. 4.1 Вводим данные нового проекта «Приложение F#»



Но на самом деле, после создания такого проекта и ввода имени, мы увидим пустую страницу с кодом и один единственный файл в обозревателе решений (Program.fs):

Рис. 4.2 Обозреватель решений: состав проекта приложения F# сформированного средой разработки

Пустота обусловлена отсутствием нормальных шаблонов в версии среды разработки VisualStudio 2010. Шаблоны приложений (в том числе и консольного) можно получить, например на официальном блоге разработчик F# (VisualStudioF# TeamBlog).

Рис. 4.3 Блог команды разработчиков F#: шаблон консольного приложения

Загруженный с сайта шаблон устанавливается в «один клик» (специальное расширение файла, запускает встроенный установщик VisualStudio):



Рис. 4.4 Пример установленного шаблона консольного приложения для F#

Либо можно поискать шаблоны в сети Интернет (окно Создать проект ->Шаблоны в Интернете):

Рис. 4.5 Шаблоны в Интернете: доступные шаблоны

Вернёмся к нашему пустому приложению. Вставим туда следующий код игры:

// Open - объявление импорта указывает модуль или пространство имён,

// на элементы которого можно ссылаться без использования полного имени

open System

open System.Threading

// System.Console - System можнонеписать

Console.Title <- "Консольное приложение (F#)"

letввод() = Console.ReadLine()

letожидание() = Console.ReadKey()

let преобразование = Int32.TryParse // Преобразуем ввод ответа в Int32

letиспользоватьцвет f =

Console.ForegroundColor <- цвет

f()

Console.ResetColor()

letкрасный = ConsoleColor.Red

letзелёный = ConsoleColor.Green

letтёмножёлтый = ConsoleColor.DarkYellow

letсигнал() = Console.Beep()

letждать(n:int) = Threading.Thread.Sleep n // Числосекунд (n000)

letсейчас() = DateTime.Now

letслучайно = Random()

let сообщение = ждать (1000)

использовать тёмножёлтый (fun () -> printfn "Добро пожаловать в игру \"Умножение на время\"!"

printfn "Пожалйста, ввидете число заданий для игры \"Умножение на вермя\""

printf "Число заданий = ")

let задания = Convert.ToInt32(ввод()) // Вводим число заданий

let игра время =

for сообщение in ["\nПриготовиться!"; "3"; "2"; "1"; "Поехали!\n"] // Выводим сообщения цикла последовательно, через одну секунду

do

printfn "%s" сообщение

ждать 1000

let начало = сейчас() // Фиксируем время старта

[1..время] |> Seq.sumBy (fun i ->// Фиксируем сумму правильных результатов (1), 0 - неправильные результаты

let a, b = случайно.Next 13, случайно.Next 13

printf "%d x %d = " a b

let введено = ввод()

match преобразование введено with

| true, ответ when ответ = a * b ->// Истина, если ответ верен (a * b)

использовать зелёный (fun () -> printfn "Правильно!")

1

| _, _ ->

сигнал()

использовать красный (fun () -> printfn "%d x %d = %d" a b (a*b))

0

) |> (fun счёт ->

let получить = (сейчас() - начало).ToString("c") // Получаем итоговое время и преобразуем в строку

// Подстановка параметров: сначала подставляем результат работы блока "[1.." (число верных ответов),

// потом общее число заданий "..время]" (число срабатывания блока),

// потом время на ответы

printfn "\nИгра завершена!\n%d правильных ответов из %d заданий, за время: %s.\n" счёт время получить

)

whiletruedo

игра (задания) // Число заданий

ждать 5000

printfn "Играть снова?\nДля продолжения игры нажмите любую клавишу . . ."

ожидание() |> ignore

Код содержит все необходимые комментарии и достаточно понятен. После запуска и инициализации пространства имён (директива open), меняем заголовок приложения, затем инициализируем все необходимые функции (в данном случае с русскоязычными именами), выводим приветственные сообщения и вводим число заданий для игры. После ввода числа, запускается цикл, который посекундно выводит куски сообщения(...«2», «1» и «Поехали!»). printfвыводит строку без добавления новой строки. Далее в том же цикле на основе числа заданий выводятся выражения типа «aумножить на b»со случайными aи b (диапазон от 0 до 12) и программа ждёт ввода ответа пользователя, этот ответ проверяется и выводится результат. Неправильный ответ вызывает также звуковой сигнал.

Сама игра продолжается по «вине» следующего цикла:

whiletruedo

игра (задания) // Число заданий

После окончания игры выводится результат и сообщение о продолжении. Компилируем приложение (Release) и запускаем.

Рис. 4.6 Результат работы консольного приложения игры «Умножение на время»



5. О приложении к Лабораторной работе № 21

Получившиеся программы (LWP21-Tutorial.exeи LWP21-Console.exe), собранные из кусков кода приведённых в данной лабораторной работе, а также установочный файл шаблона консольного приложения для F# (FSharp.Console.vsix), можно загрузить по ссылке в конце этого материала.

Размещено на Allbest.ur