Фа Шарп (язык программирования)

Не путать с F (язык программирования) или F* (язык программирования) .

Ф#

Парадигмы	Мультипарадигмальность : функциональная , императивная , объектно-ориентированная , агентно-ориентированная , метапрограммирование , рефлексивная , параллельная.
Семья	ML : Caml : OCaml
Разработано	Дон Сайм , Microsoft Research
Разработчик	Microsoft , Фонд программного обеспечения F#
Впервые появился	2005 г ( 2005 ) , версия 1.0
Стабильная версия	8.0.0 / 14 ноября 2023 г ( 14.11.2023 )
Дисциплина набора текста	Статический , сильный , предполагаемый
ТЫ	Кроссплатформенность : .NET Framework, Mono.
Лицензия	С
Расширения имен файлов	.fs, .fsi, .fsx, .fsscript
Веб-сайт	fsharp .org учиться .microsoft .с /en-нас /дотнет /fsharp
Под влиянием
С# , Эрланг , Хаскель , ML , OCaml , Питон , Скала
Под влиянием
С# , Вяз , F* , LiveScript
Программирование F Sharp в Wikibooks

F# (произносится как F Sharp ) — это общего назначения , высокоуровневый , строго типизированный , многопарадигмальный язык программирования который включает в себя функциональные , императивные и объектно-ориентированные методы программирования. Чаще всего он используется в качестве кроссплатформенного языка Common Language Infrastructure (CLI) в .NET , но также может генерировать JavaScript. и код графического процессора (GPU).

F# разработан F# Software Foundation , Microsoft и открытые участники. Кроссплатформенный компилятор с открытым исходным кодом для F# доступен на сайте F# Software Foundation. F# — полностью поддерживаемый язык в Visual Studio. и JetBrains Rider . Плагины, поддерживающие F#, существуют для многих широко используемых редакторов, включая Visual Studio Code , Vim и Emacs .

F# является членом семейства языков ML и возник как реализация .NET Framework ядра языка программирования OCaml . На него также повлиял C# , Питон , Хаскель , Скала и Эрланг .

История

Версии

Ф# версия	Спецификация языка	Дата	Платформы	Время выполнения
1.х		май 2005 г.	Окна	.NET 1.0–3.5
2.0	август 2010 г.	апрель 2010 г.	Linux , MacOS , Windows	.NET 2.0–4.0, моно
3.0	ноябрь 2012 г.	август 2012 г.	Linux , MacOS , Windows ; JavaScript , графический процессор	.NET 2.0–4.5, моно
3.1	Ноябрь 2013	Октябрь 2013	Linux , MacOS , Windows ; JavaScript , графический процессор	.NET 2.0–4.5, моно
4.0	Январь 2016 г.	июль 2015 г.
4.1	май 2018 г.	Март 2017 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET 3.5–4.6.2, .NET , моно
4.5		август 2018 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET 4.5 – 4.7.2, Пакет SDK для .NET Core 2.1.400
4.6		март 2019 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET 4.5 – 4.7.2, Пакет SDK для .NET Core 2.2.300
4.7		сентябрь 2019 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET 4.5–4.8, Пакет SDK для .NET Core 3.0.100
5.0		ноябрь 2020 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET SDK 5.0.100
6.0		ноябрь 2021 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET SDK 6.0.100
7.0		ноябрь 2022 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET SDK 7.0.100
8.0		ноябрь 2023 г.	Linux , MacOS , Windows , JavaScript , графический процессор	.NET SDK 8.0.100

Эволюция языка

F# использует открытый процесс разработки и проектирования. Процессом развития языка управляет Дон Сайм из Microsoft Research как пожизненный доброжелательный диктатор (BDFL) в области разработки языка совместно с F# Software Foundation. Более ранние версии языка F# были разработаны Microsoft и Microsoft Research с использованием закрытого процесса разработки.

F# был впервые включен в Visual Studio в выпуске 2010 года , на том же уровне, что и Visual Basic (.NET) и C# (хотя и в качестве опции), и остается во всех более поздних выпусках, что делает язык широко доступным и хорошо поддерживаемым.

F# создан Microsoft Research, Кембридж, Великобритания. Первоначально язык был разработан и реализован Доном Саймом . По словам кого-то в команде fsharp, буква F означает «веселье». Эндрю Кеннеди внес свой вклад в разработку единиц измерения . Инструменты Visual F# для Visual Studio разработаны Microsoft. F# Software Foundation разработал компилятор и инструменты F# с открытым исходным кодом, включающие реализацию компилятора с открытым исходным кодом, предоставленную командой Microsoft Visual F# Tools.

Краткое описание версий

Ф# версия	Добавлены функции
1.0	Функциональное программирование Дискриминированные профсоюзы Рекорды Кортежи Сопоставление с образцом Введите сокращения Объектно-ориентированного программирования Структуры Файлы подписи Файлы сценариев Императивное программирование Модули (без функций) Вложенные модули Совместимость .NET
2.0	Активные шаблоны Единицы измерения Выражения последовательности Асинхронное программирование Агентское программирование Члены расширения Именованные аргументы Необязательные аргументы Нарезка массива Котировки Встроенная совместимость Выражения вычислений
3.0	Тип поставщиков Выражения запроса LINQ Атрибут CLImutable Строки в тройных кавычках Авто-свойства Предоставленные единицы измерения
3.1	Поля именованных типов объединения Расширения для нарезки массива Улучшения вывода типов
4.0	Printf для унифицированных значений Инициализаторы свойств расширения Ненулевые предоставленные типы Первичные конструкторы как функции Статические параметры для предоставленных методов Интерполяция печати Расширенная грамматика #if Атрибут хвостового вызова Несколько экземпляров интерфейса Необязательный тип аргументов Словари параметров
4.1	Структурные кортежи, которые взаимодействуют с кортежами C#. Структурные аннотации для записей Структурные аннотации для однорегистровых дискриминируемых объединений Подчеркивания в числовых литералах Атрибуты аргумента информации о вызывающем абоненте Тип результата и некоторые основные функции результата Взаимно ссылочные типы и модули в одном файле Неявный синтаксис «Модуль» для модулей с общим именем в качестве типа. Возврат Byref, поддерживающий использование методов возврата ссылок C#. Улучшения сообщений об ошибках Поддержка «фиксированных»
4.5	Выравнивание версий двоичного файла, пакета и языка Поддержка Span<T> и связанных типов. Возможность получения возвратов по ссылке Тип «voidptr» Типы «inref<'T>» и «outref<'T>» для представления «byref» только для чтения и только для записи. Структуры IsByRefLike Структуры IsReadOnly Поддержка методов расширения для 'byref<'T>'/'inref<'T>'/'outref<'T>' 'соответствовать!' ключевое слово в выражениях вычислений Расслабленное преобразование с «выходом» в выражениях F# seq/list/array. Удобные отступы с помощью выражений списков и массивов. Переписные дела объявлены общедоступными
4.6	Анонимные типы записей
4.7	Неявная доходность Больше не требуется двойное подчеркивание Уменьшение отступов для параметров, передаваемых конструкторам и статическим методам. функция 'nameof' Открытые статические классы
5.0	FSharp.Core теперь нацелен только на netstandard2.0. Ссылки на пакеты в сценариях F# Поддержка ноутбуков Jupyter, nteract и VSCode. Строковая интерполяция Поддержка имени Объявления открытого типа Улучшенная нарезка Улучшения котировок F# Прикладные вычислительные выражения Улучшены трассировки стека в асинхронных выражениях F# и других вычислительных выражениях. Улучшенное взаимодействие с .NET. Улучшена производительность карт и наборов в FSharp.Core. Улучшена производительность компилятора. Улучшенный анализ компилятора для авторов библиотек.
6.0	Задания Упрощенная индексация Дополнения к «активным шаблонам» Перегруженные пользовательские операции в выражениях вычислений. шаблоны «как» Изменения синтаксиса отступов Больше неявных преобразований Больше неявных преобразований с повышением уровня Неявные целочисленные преобразования Первоклассная поддержка неявных преобразований в стиле .NET. Дополнительные предупреждения о неявных преобразованиях Форматирование двоичных чисел Сбрасывает привязки при использовании Директива оптимизатора InlineIfLambda Возобновляемый код Больше функций сбора Карта имеет ключи и значения Дополнительные возможности для NativePtr Больше числовых типов с аннотациями единиц измерения Информационные предупреждения для редко используемых символьных операторов
7.0	Поддержка статических абстрактных членов в интерфейсах Упрощение работы с SRTP (статически разрешенными параметрами типа). Обязательная проверка свойств Область инициализации и свойства только для инициализации Поддержка эталонных сборок Автономные развертывания F# и собственный AOT Добавлена ​​поддержка массивов Nd до 32 ранга. Модуль результатов работает наравне с Option. Исправления в коде возобновляемых конечных автоматов для сборки задач. Улучшенный генератор кода для получения свойств, генерируемых компилятором, без побочных эффектов. Компилятор для конкретной платформы ARM64 и целевая поддержка ARM64 в компиляторе F#. Менеджер зависимостей #r, поддержка кэширования Поддержка параллельной проверки типов и проверки проектов (экспериментальная, может быть включена через настройку VS или авторами инструментов) Различные исправления и улучшения.
8.0	_.Property сокращение для (fun x -> x.Property) Копирование и обновление поля вложенной записи пока! (во время взрыва) функция Расширенный синтаксис интерполяции строк Используйте и составляйте строковые литералы для printf и связанных с ним функций. Арифметические операторы в литералах Синтаксис пересечения ограничений типов Расширенная фиксированная привязка Упрощенное определение метода [<Extension>] Статические члены в интерфейсах Статический let в распознаваемых объединениях, записях, структурах и типах без первичных конструкторов. try-with с выражениями коллекции seq{}, [] и [||] Рекурсивные вызовы и выход! в обработчике исключений Атрибут хвостового вызова Объединения [<Struct>] теперь могут иметь > 49 регистров. Строгие правила отступов Новая диагностика от компилятора Переключатели для распараллеливания компилятора

Обзор языка

Функциональное программирование

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

Примеры функциональных особенностей:

• Все есть выражение
• Вывод типа (с использованием вывода типа Хиндли-Милнера )
• Выполняет функции первоклассных граждан
• Анонимные функции с захватом семантики (т. е. замыканиями ).
• Неизменяемые переменные и объекты
• ленивых оценок Поддержка
• Функции высшего порядка
• Вложенные функции
• каррирование
• Сопоставление с образцом
• Алгебраические типы данных
• Кортежи
• Понимание списка
• монад Поддержка шаблонов (называемых выражениями вычислений). )
• Оптимизация хвостового вызова

F# — это язык, основанный на выражениях, использующий нетерпеливую оценку , а также в некоторых случаях ленивую оценку . Каждый оператор в F#, включая if выражения, try выражения и циклы — это составное выражение статического типа. Функции и выражения, которые не возвращают никакого значения, имеют тип возвращаемого значения: unit. F# использует let ключевое слово для привязки значений к имени. Например:

пусть   х   =   3   +   4 

связывает значение 7 к имени x.

Новые типы определяются с помощью typeключевое слово. Для функционального программирования F# предоставляет типы кортеж , запись , дискриминируемое объединение , список , параметр и результат . Кортеж представляет собой набор из n значений, где n ≥ 0. Значение n называется арностью кортежа. Тройной кортеж будет представлен как (A, B, C), где A, B и C — значения, возможно, разных типов. Кортеж можно использовать для хранения значений только в том случае, если количество значений известно во время разработки и остается постоянным во время выполнения.

Запись . — это тип, в котором элементы данных имеют имена Вот пример определения записи:

 тип   R   =  
         {   Имя   :   строка  
          Возраст   :   int   } 

Записи могут создаваться как let r = { Name="AB"; Age=42}. with Ключевое слово используется для создания копии записи, как в { r with Name="CD"}, который создает новую запись путем копирования r и изменение стоимости Name поле (при условии, что запись, созданная в последнем примере, имела имя r).

Тип дискриминируемого объединения — это типобезопасная версия C. объединений Например,

 тип   А   =  
     |    UnionCaseX   строки  ​ 
     |    UnionCaseY   int  ​ 

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

Тип списка представленный — это неизменяемый связанный список, либо с помощью head::tail обозначение ( :: является оператором cons ) или сокращением, например [item1; item2; item3]. Пишется пустой список []. Тип опции . представляет собой дискриминируемый тип объединения с вариантами выбора Some(x) или None. Типы F# могут быть универсальными , реализованными как универсальные типы .NET.

F# поддерживает лямбда-функции и замыкания . Все функции в F# являются значениями первого класса и неизменяемы. Функции могут быть каррированы . Будучи значениями первого класса, функции могут передаваться в качестве аргументов другим функциям. Как и другие языки функционального программирования, F# допускает композицию функций с использованием >> и << операторы.

F# обеспечивает выражения последовательности которые определяют последовательность seq { ... }, список [ ... ] или массив [| ... |]через код, который генерирует значения. Например,

 seq   {   for   b   in   0   ..   25   do 
            if   b   <   15   , то 
                получим   b  *  b   } 

формирует последовательность квадратов чисел от 0 до 14 путем фильтрации чисел из диапазона чисел от 0 до 25. Последовательности являются генераторами – значения генерируются по требованию (т. е. лениво оцениваются ) – в то время как списки и массивы оцениваются с нетерпением .

F# использует сопоставление с образцом для привязки значений к именам. Сопоставление с образцом также используется при доступе к распознаваемым объединениям: объединение — это значение, сопоставленное с правилами шаблона, и правило выбирается в случае успешного сопоставления. F# также поддерживает активные шаблоны как форму расширяемого сопоставления шаблонов. Он используется, например, когда существует несколько способов сопоставления типа.

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

Императивное программирование

Поддержка F# для императивного программирования включает в себя

• for петли
• while петли
• массивы , созданные с помощью [| ... |] синтаксис
• хеш-таблица , созданная с помощью dict [ ... ] синтаксис или System.Collections.Generic.Dictionary<_,_> тип.

Значения и поля записи также можно пометить как mutable. Например:

// Определить 'x' с начальным значением '1' 
 let   mutable   x   =   1 
 // Изменить значение 'x' на '3' 
 x   <-   3 

Кроме того, F# поддерживает доступ ко всем типам и объектам CLI, например тем, которые определены в System.Collections.Generic пространство имен, определяющее императивные структуры данных.

Объектно-ориентированное программирование

Как и другие языки Common Language Infrastructure (CLI), F# может использовать типы CLI посредством объектно-ориентированного программирования. Поддержка F# для объектно-ориентированного программирования в выражениях включает в себя:

• Точечная запись, например, x.Name
• Выражения объекта, например, { new obj() with member x.ToString() = "hello"}
• Конструкция объекта, например, new Form()
• Типовые испытания, например, x :? string
• Тип приведения, например, x :?> string
• Именованные аргументы, например, x.Method(someArgument=1)
• Именованные сеттеры, например, new Form(Text="Hello")
• Необязательные аргументы, например, x.Method(OptionalArgument=1)

Поддержка объектно-ориентированного программирования в шаблонах включает в себя

• Типовые испытания, например, :? string as s
• Активные шаблоны, которые можно определить для типов объектов.

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

/// Простое определение типа объекта 
 type   Person  (  name   :   string  ,   age   :   int  )   = 
     member   x  .   Имя   =   имя 
     участника   x  .   Возраст   =   возраст 

Асинхронное программирование

F# поддерживает асинхронное программирование посредством асинхронных рабочих процессов . Асинхронный рабочий процесс определяется как последовательность команд внутри async{ ... }, как в

пусть   asynctask   =  
     async   {   let   req   =   WebRequest  .   Создайте  (  url  ) 
             пусть!    ответ   =   требование  .   GetResponseAsync  () 
             использует   поток   =   ответ  .   GetResponseStream  ( 
             используйтеstreamreader   =   .   new   System  )   ИО  .   StreamReader  (  stream  ) 
             возвращает   средство чтения потока  .   ReadToEnd  ()   } 

The let!указывает, что выражение справа (получение ответа) должно выполняться асинхронно, но поток должен продолжаться только тогда, когда результат доступен. Другими словами, с точки зрения блока кода получение ответа — это как бы блокирующий вызов, тогда как с точки зрения системы поток не будет заблокирован и может использоваться для обработки других потоков. до тех пор, пока не станет доступен необходимый для этого результат.

Асинхронный блок можно вызвать с помощью Async.RunSynchronouslyфункция. Несколько асинхронных блоков могут выполняться параллельно с помощью Async.Parallel функция, которая принимает список async объекты (в примере asynctaskявляется асинхронным объектом) и создает другой асинхронный объект для параллельного выполнения задач в списках. Результирующий объект вызывается с помощью Async.RunSynchronously.

Инверсия управления в F# соответствует этому шаблону.

Начиная с версии 6.0, F# поддерживает непосредственное создание, использование и возврат задач .NET.

    откройте   System.Net.Http 
     let   fetchUrlAsync   (  url  :  string  )   =   // string -> Task<string> 
         Task   { 
             use   client   =   new   HttpClient  () 
             let!    ответ   =   клиент  .   GetAsync  (  url  )  
             пусть!    контент   =   ответ  .   Содержание  .   ReadAsStringAsync  () 
             делаю  !    Задача  .   Задержка   500 
             возврата   содержимого 
         } 

     // Использование 
     let   fetchPrint  ()   = 
         let   Task   =   Task   { 
             let!    data   =   fetchUrlAsync   "https://example.com" 
             printfn   $  "{data}" 
         }  
         Task  .   Ждать  () 

Параллельное программирование

Параллельное программирование частично поддерживается через Async.Parallel, Async.Start и другие операции, которые параллельно запускают асинхронные блоки.

Параллельное программирование также поддерживается через Array.Parallel операторы функционального программирования в стандартной библиотеке F#, прямое использование System.Threading.Tasks модель программирования задач, прямое использование пула потоков .NET и потоков .NET, а также динамическая трансляция кода F # в альтернативные механизмы параллельного выполнения, такие как графический процессор. код.

Единицы измерения

Система типов F# поддерживает проверку единиц измерения чисел.

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

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

[<  Measure  >]   type   m                    // метр 
 [<  Measure  >]   type   s                    // секунда 

 let   distance   =   100  .   0  <  m  >       // float<m> 
 let   time   =   5  .   0  <  s  >             // float<s> 
 let   скорость   =   расстояние  /  время     // float<m/s> 


 [<  Measure  >]   тип   кг                   // килограмм 
 [<  Measure  >]   тип   N   =   (  кг   *   м  )/(  с  ^  2  )   // Ньютоны 
 [<  Мера  >]   тип   Pa   =   N  /(  m  ^  2  )         // Паскали 

 [<  Мера  >]   тип   дни  
 let   Better_age   =   3u  <  дни  >            // uint<дни> 

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

Metaprogramming

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

F# включает функцию метапрограммирования во время выполнения, называемую кавычками. Выражение кавычки оценивается как представление абстрактного синтаксического дерева выражений F#. Аналогично, определения, помеченные знаком [<ReflectedDefinition>]Доступ к атрибуту также можно получить в форме цитаты. Кавычки F# используются для различных целей, в том числе для компиляции кода F# в JavaScript. и графический процессор код. Кавычки представляют выражения кода F# как данные для использования другими частями программы, требуя при этом синтаксически правильного кода F#.

Информационное

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

В F# 3.0 функции кавычек F# и вычислительных выражений объединены для реализации запросов LINQ . Например:

// Используйте поставщика типов OData для создания типов, которые можно использовать для доступа к базе данных Northwind. 
  откройте   Microsoft.FSharp.Data.TypeProviders 

 и введите   Northwind   =   ODataService  <  "http://services.odata.org/Northwind/Northwind.svc"  > 
 let   db   =   Northwind  .   GetDataContext  () 

 // Выражение запроса. 
  пусть   query1   =   запрос   {   для   клиента   в   БД  .   Клиенты   выбирают 
                     ​   клиента   } 

Сочетание поставщиков типов, запросов и строго типизированного функционального программирования известно как информационно насыщенное программирование .

Программирование агента

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

    тип   Сообщение   = 
         |    Очередь   строк  ​ 
         |    Удаление   из   очереди AsyncReplyChannel  <  Option  <  string  >> 

     // Обеспечивает одновременный доступ к списку строк, 
     пусть   listManager   =   MailboxProcessor  .   Start  (  fun   inbox   -> 
         let   Rec   messageLoop   list   =   async   { 
             let!   msg   =   inbox  .  Receive  () 
             сопоставить   сообщение   с 
                 |   в очередь   Поставить элемент   -> 
                     вернуть  !   messageLoop   (  item   ::   list  ) 

                 |   Удалить из очереди   AnswerChannel   -> 
                     совпадений   список   с 
                     |   []   ->  
                         ReplyChannel  .  Reply   None 
                         return  !   messageLoop   list 
                     |   head   ::   Tail   -> 
                         ReplyChannel  .  Reply   (  Some   head  ) 
                         return  !   messageLoop   Tail 
         } 

         // Запускаем цикл с пустым списком 
         messageLoop   [] 
     ) 

     // Использование 
     async   { 
         // Постановка в очередь некоторые строки 
         listManager  .   Опубликовать  (  поставить в очередь   «Привет»  ) 
         listManager  .   Post  (  Enqueue   "World"  ) 

         // Извлекаем из очереди и обрабатываем строки 
         let!    стр   =   Менеджер списка  .   PostAndAsyncReply  (  Dequeue  ) 
         str   |>   Option  .   iter   (  printfn   «Из очереди: %s»  ) 

     } 
     |>   Async  .   Начинать 

Инструменты разработки

• Visual Studio с установленными инструментами Visual F# от Microsoft можно использовать для создания, запуска и отладки проектов F#. Инструменты Visual F# включают интерактивную консоль цикла чтения-оценки-печати (REPL), размещенную в Visual Studio, которая может выполнять код F# по мере его написания. Visual Studio для Mac также полностью поддерживает проекты F#.
• Visual Studio Code содержит полную поддержку F# через расширение Ionide .
• F# можно разрабатывать с помощью любого текстового редактора. Особая поддержка существует в таких редакторах, как Emacs .
• JetBrains Rider оптимизирован для разработки кода F#, начиная с версии 2019.1.
• LINQPad поддерживает F# начиная с версии 2.x.

Сравнение интегрированных сред разработки

Этот раздел представляет собой отрывок из книги «Сравнение интегрированных сред разработки § F#» . [ редактировать ]

ИДЕТ	Лицензия	Окна	Линукс	macOS	Разработчик
Майкрософт Визуал Студия	Собственный (стандартный) Бесплатное ПО (версия сообщества)	Да	Нет	Да	Майкрософт
Код Visual Studio	Собственный ( двоичный код ) Лицензия MIT ( исходный код )	Да	Да	Да	Майкрософт
Райдер	Собственный	Да	Да	Да	JetBrains

Области применения

F# — язык программирования общего назначения .

Веб-программирование

SAFE Stack — это комплексный стек F# для разработки веб-приложений. Он использует ASP.NET Core на стороне сервера и Fable на стороне клиента.

Альтернативным вариантом сквозного F# является платформа WebSharper .

Разработка кроссплатформенных приложений

F# можно использовать вместе с инструментами Visual Studio для Xamarin для разработки приложений для iOS и Android . Библиотека Fabulous предоставляет более удобный функциональный интерфейс.

Аналитическое программирование

Помимо прочего, F# используется для количественного финансового программирования, торговля энергией и оптимизация портфеля, машинное обучение, бизнес-аналитика и социальные игры на Facebook .

В 2010-х годах F# позиционировался как оптимизированная альтернатива C# . Возможности написания сценариев F# и межъязыковая совместимость со всеми продуктами Microsoft сделали его популярным среди разработчиков.

Сценарии

F# можно использовать в качестве языка сценариев, в основном для сценариев цикла чтения-оценки-печати (REPL) на рабочем столе.

Сообщество открытого исходного кода

F# Сообщество открытого исходного кода включает F# Software Foundation. и группа открытого исходного кода F# на GitHub . Популярные проекты F# с открытым исходным кодом включают:

• Fable — транспилятор F# в Javascript, основанный на Babel .
• Paket — альтернативный менеджер пакетов для .NET, который по-прежнему может использовать репозитории NuGet , но имеет централизованное управление версиями.
• FAKE — дружественная к F# система сборки.
• Giraffe — функционально-ориентированное промежуточное ПО для ASP.NET Core .
• Suave — легкий веб-сервер и библиотека веб-разработки.

Совместимость

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

Примеры

Ниже приведены несколько небольших примеров:

// Это комментарий к примеру программы hello world. 
  printfn   «Привет, мир!» 

Определение типа записи. Записи по умолчанию неизменяемы и сравниваются по структурному равенству.

type   Person   =   { 
     FirstName  :   string 
     LastName  :   string 
     Age  :   int 
 } 

 // Создание экземпляра записи 
 let   person   =   {   FirstName   =   "John"  ;    Фамилия   =   "Доу"  ;    Возраст   =   30   } 

Класс Person с конструктором, принимающим имя и возраст, а также двумя неизменяемыми свойствами.

/// Это комментарий документации к определению типа. 
  введите   Person  (  имя   :   строка  ,   возраст   :   int  )   = 
     член   x  .   Имя   =   имя 
     участника   x  .   Age   =   age 
    
 /// создание экземпляра класса 
 let   mrSmith   =   Person  (  "Smith"  ,   42  ) 

Простой пример, который часто используется для демонстрации синтаксиса функциональных языков, — это функция факториала для неотрицательных 32-битных целых чисел, показанная здесь на F#:

/// Используя выражение сопоставления с образцом, 
 пусть   Rec   Factorial   n   = 
     соответствует   n   с 
     |    0   ->   1 
     |    _   ->   n   *   Factorial   (  n   -   1  ) 

 /// Для функций с одним аргументом существует синтаксический сахар (функция сопоставления с образцом): 
 let   Rec   factial   =   function  
     |    0   ->   1  
     |    n   ->   n   *   факториал   (  n   -   1  ) 
    
 /// Используя оператор свертки и диапазона, 
 пусть   факториал   n   =   [  1  ..  n  ]   |>   Seq  .   сложить   (*)   1 

Примеры итераций:

/// Итерация с использованием цикла 
 for let   printList   lst   =  
     for   x   in   lst   do 
         printfn   $  "{x}"  

 /// Итерация с использованием функции высшего порядка 
 let   printList2   lst   =  
     List  .   iter   (  printfn   "%d"  )   lst 

 /// Итерация с использованием рекурсивной функции и сопоставления с образцом 
 let   Rec   printList3   lst   = 
     match   lst   with 
     |    []   ->   () 
     |    h   ::   t   -> 
         printfn   "%d"   h 
         printList3   t 

Примеры Фибоначчи:

/// Формула числа Фибоначчи 
 [<  TailCall  >] 
 let   fib   n   = 
     let   Rec   g   n   f0   f1   = 
         сопоставить   n   с 
         |    0   ->   f0 
         |    1   ->   f1 
         |    _   ->   g   (  n   -   1  )   f1   (  f0   +   f1  ) 
     g   n   0   1 

 /// Другой подход — ленивая бесконечная последовательность чисел Фибоначчи, 
 пусть   fibSeq   =   Seq  .   развернуть   (  fun   (  a  ,  b  )   ->   Some  (  a  +  b  ,   (  b  ,   a  +  b  )))   (  0  ,  1  ) 

 // Вывести четные выдумки 
 [  1   ..   10  ] 
 |>   List  .   карта       фиб 
 |>   Список  .   filter    (  fun   n   ->   (  n   %   2  )   =   0  ) 
 |>   printList 

 // То же самое, используя выражение списка 
 [   for   i   in   1  ..  10   do 
     let   r   =   fib   i 
     if   r   %   2   =   0   then   return   r   ] 
 |>   список печати 

Пример программы Windows Forms:

// Открываем библиотеку Windows Forms 
 open   System.Windows.Forms 

 // Создаём окно и устанавливаем несколько свойств 
 let   form   =   new   Form  (  Visible  =  true  ,   TopMost  =  true  ,   Text  =  «Welcome to F#»  ) 

 // Создаём метку чтобы отобразить текст в форме, 
 let   label   = 
     let   x   =   3   +   (  4   *   5  ) 
     new   Label  (  Text   =   $  "{x}"  ) 

 // Добавляем метку в форму 
 form  .   Элементы управления  .   Добавить  (  метка  ) 

 // Наконец, запустите форму 
 [<  System  .   STAThread  >] 
 Приложение  .   Запустить  (  форма  ) 

Пример асинхронного параллельного программирования (параллельные задачи ЦП и ввода-вывода):

 Простой детектор простых чисел 
 isPrime   (   n  :  int  )  =   letbound 
    =   int   (   }   sqrt  (   float  n   )  ) 
    seq   {  2   ..bound   Seq  let   |>   . ///   forall   (  fun   x   ->   n   %   x   <>   0  ) 

 // Мы используем асинхронные рабочие процессы 
 let   primeAsync   n   = 
     async   {   return   (  n  ,   isPrime   n  )   } 

 /// Возвращаем простые числа между m и n, используя несколько потоков 
 let   primes   m   n   = 
     seq   {  м   ..   n  } 
         |>   Seq  .   карта   primeAsync 
         |>   Async  .   Параллельный 
         |>   Асинхронный  .   Запуститьсинхронно 
         |>   Массив  .   фильтр   snd 
         |>   Массив  .   map   fst 

 // Запуск теста 
 primes   1000000   1002000 
     |>   Array  .   итер   (  printfn   "%d"  ) 

См. также

• OCaml
• С#
• .NET Framework

Ссылки

• Сайм, Дон ; Гранич, Адам; Чистернино, Антонио (2007), Expert F # , Apress
• Харроп, Джон (2010), Visual F # 2010 для технических вычислений , консалтинговая компания Flying Frog
• Пикеринг, Роберт (2007), Основы F# , Apress
• Смит, Крис (2009), Программирование F# , О'Рейли
• Петричек, Томас (2009), Функциональное программирование в реальном мире с примерами на F # и C # , Manning Publications
• Хансен, Майкл; Ришель, Ганс (2013), Функциональное программирование с использованием F # , Cambridge University Press
• Астборг, Йохан (2013), F # для количественных финансов , Packt Publishing
• Лундин, Микаэль (2015), Тестирование с помощью F # , Packt Publishing

Внешние ссылки

• Официальный сайт Фонда программного обеспечения F#
• Группа открытого исходного кода F# на GitHub
• Центр разработчиков Visual F #. Архивировано 19 ноября 2008 г. на Wayback Machine.
• Попробуйте F# для изучения F# в веб-браузере.
• Сайт фрагментов F#
• Блог группы Visual F#
• Оригинальный веб-сайт Microsoft Research по F #
• Руководство по выживанию на F#, декабрь 2009 г. (интернет-книга)
• Спецификация языка F#
• Введение в программирование на F#. Архивировано 13 июля 2011 г. на Wayback Machine.
• Учебное пособие, показывающее процесс создания функционального дизайна; включает в себя тестирование и параллельное кодирование