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

Не путать с 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 , Mono
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 ключевое слово для привязки значений к имени. Например:

let x = 3 + 4

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

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

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

 type R = 
        { Name : string 
         Age : int }

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

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

 type A = 
    | UnionCaseX of string
    | UnionCaseY of 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 then
               yield b*b }

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

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

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

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

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

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

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

// Define 'x' with initial value '1'
let mutable x = 1
// Change the value of 'x' to '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# . Например, вот класс с конструктором, принимающим имя и возраст и объявляющим два свойства.

/// A simple object type definition
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age

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

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

let asynctask = 
    async { let req = WebRequest.Create(url)
            let! response = req.GetResponseAsync()
            use stream = response.GetResponseStream()
            use streamreader = new System.IO.StreamReader(stream)
            return streamreader.ReadToEnd() }

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

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

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

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

    open System.Net.Http
    let fetchUrlAsync (url:string) = // string -> Task<string>
        task {
            use client = new HttpClient()
            let! response = client.GetAsync(url) 
            let! content = response.Content.ReadAsStringAsync()
            do! Task.Delay 500
            return content
        }

    // Usage
    let fetchPrint() =
        let task = task {
            let! data = fetchUrlAsync "https://example.com"
            printfn $"{data}"
        } 
        task.Wait()

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

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

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

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

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

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

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

[<Measure>] type m                  // meter
[<Measure>] type s                  // second

let distance = 100.0<m>     // float<m>
let time = 5.0<s>           // float<s>
let speed = distance/time   // float<m/s>


[<Measure>] type kg                 // kilogram
[<Measure>] type N = (kg * m)/(s^2) // Newtons
[<Measure>] type Pa = N/(m^2)       // Pascals 

[<Measure>] type days 
let better_age = 3u<days>          // uint<days>

Средство проверки статического типа 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 . Например:

// Use the OData type provider to create types that can be used to access the Northwind database.
open Microsoft.FSharp.Data.TypeProviders

type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc">
let db = Northwind.GetDataContext()

// A query expression.
let query1 = query { for customer in db.Customers do
                     select customer }

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

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

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

    type Message =
        | Enqueue of string
        | Dequeue of AsyncReplyChannel<Option<string>>

    // Provides concurrent access to a list of strings
    let listManager = MailboxProcessor.Start(fun inbox ->
        let rec messageLoop list = async {
            let! msg = inbox.Receive()
            match msg with
                | Enqueue item ->
                    return! messageLoop (item :: list)

                | Dequeue replyChannel ->
                    match list with
                    | [] -> 
                        replyChannel.Reply None
                        return! messageLoop list
                    | head :: tail ->
                        replyChannel.Reply (Some head)
                        return! messageLoop tail
        }

        // Start the loop with an empty list
        messageLoop []
    )

    // Usage 
    async {
        // Enqueue some strings
        listManager.Post(Enqueue "Hello")
        listManager.Post(Enqueue "World")

        // Dequeue and process the strings
        let! str = listManager.PostAndAsyncReply(Dequeue)
        str |> Option.iter (printfn "Dequeued: %s")

    }
    |> Async.Start

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

• 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, грубо говоря, без каких-либо функторов, объектов, полиморфных вариантов или других дополнений.

Примеры

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

// This is a comment for a sample hello world program.
printfn "Hello World!"

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

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

// Creating an instance of the record
let person = { FirstName = "John"; LastName = "Doe"; Age = 30 }

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

/// This is a documentation comment for a type definition.
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
    
/// class instantiation
let mrSmith = Person("Smith", 42)

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

/// Using pattern matching expression
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)

/// For a single-argument functions there is syntactic sugar (pattern matching function):
let rec factorial = function 
    | 0 -> 1 
    | n -> n * factorial (n - 1)
    
/// Using fold and range operator
let factorial n = [1..n] |> Seq.fold (*) 1

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

/// Iteration using a 'for' loop
let printList lst = 
    for x in lst do
        printfn $"{x}" 

/// Iteration using a higher-order function
let printList2 lst = 
    List.iter (printfn "%d") lst

/// Iteration using a recursive function and pattern matching
let rec printList3 lst =
    match lst with
    | [] -> ()
    | h :: t ->
        printfn "%d" h
        printList3 t

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

/// Fibonacci Number formula
[<TailCall>]
let fib n =
    let rec g n f0 f1 =
        match n with
        | 0 -> f0
        | 1 -> f1
        | _ -> g (n - 1) f1 (f0 + f1)
    g n 0 1

/// Another approach - a lazy infinite sequence of Fibonacci numbers
let fibSeq = Seq.unfold (fun (a,b) -> Some(a+b, (b, a+b))) (0,1)

// Print even fibs
[1 .. 10]
|> List.map     fib
|> List.filter  (fun n -> (n % 2) = 0)
|> printList

// Same thing, using a list expression
[ for i in 1..10 do
    let r = fib i
    if r % 2 = 0 then yield r ]
|> printList

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

// Open the Windows Forms library
open System.Windows.Forms

// Create a window and set a few properties
let form = new Form(Visible=true, TopMost=true, Text="Welcome to F#")

// Create a label to show some text in the form
let label =
    let x = 3 + (4 * 5)
    new Label(Text = $"{x}")

// Add the label to the form
form.Controls.Add(label)

// Finally, run the form
[<System.STAThread>]
Application.Run(form)

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

/// A simple prime number detector
let isPrime (n:int) =
   let bound = int (sqrt (float n))
   seq {2 .. bound} |> Seq.forall (fun x -> n % x <> 0)

// We are using async workflows
let primeAsync n =
    async { return (n, isPrime n) }

/// Return primes between m and n using multiple threads
let primes m n =
    seq {m .. n}
        |> Seq.map primeAsync
        |> Async.Parallel
        |> Async.RunSynchronously
        |> Array.filter snd
        |> Array.map fst

// Run a test
primes 1000000 1002000
    |> Array.iter (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.
• Учебное пособие, показывающее процесс создания функционального дизайна; включает в себя тестирование и параллельное кодирование