F# *

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

Глубже погрузимся в исследование типов-обёрток и узнаем, наконец, почему список тоже может быть обёрткой.

Четвёртая статья из цикла Вычислительные выражения Скотта Влащина. Скотт рассказывает о типах-обёртках и об их глубокой связи с вычислительными выражениями.

Godot — игровой движок, который имеет нативную поддержку dotnet. К сожалению, эта поддержка до такой степени заточена под C#, что F# она выходит боком. Почти все проблемы разрешимы, но при недостатке опыта они скатываются в большой пластилиново-волосатый валик у самого входа в подземелье, который иногда приводит к преждевременной и бессмысленной гибели. Чтобы избежать этого в данной статье я дам программу-минимум, которая позволит выжить в Godot, но не выжать из него максимум.

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

Третья статья из цикла про вычислительные выражения в F#. Продолжаем разбираться с функциями-продолжениями и исследуем метод "Bind".

Вторая часть из цилка статей про вычислительные выражения в F#. Здесь Скотт Влащин рассказывает про функции-продолжения. Сложная, но очень важная тема.

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

Группа энтузиастов давно (и с переменным успехом) пытается перевести руководство Скотта на русский.

Я завершаю перевод цикла, посвящённого одной из самых сакральных тем языка — вычислительным выражениям. Это как монады, только в .NET.

Неизвестно, когда нам удастся запустить полноценный русский сайт, поэтому я попросил у ребят разрешения опубликовать цикл на Хабре.
Материал интересный и хочется им поделиться.

Далее передают слово автору. Перед вами — первая статья цикла.

По многочисленным просьбам, мы поговорим про тайны вычислительных выражений, о том, что они из себя представляют и как могут применяться на практике (и я постараюсь избегать запрещённого слова на букву М).

В этом цикле статей вы узнаете, что такое вычислительные выражения, как их создавать, а также освоите несколько общих паттернов, связанных с ними. В процессе мы также познакомимся с продолжениями, функцией связывания, типами-обёртками и прочим.

Введение

Кажется, что вычислительные выражениях имеют репутацию заумной штуки, трудной для понимания.

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

Но как вы можете создать новую похожую конструкцию? Как они работают за кулисами?

В прошлой части мы научились определять собственные типы и модули. Мы облекли все достопримечательности в конкретные типы и теперь можем снабдить их индивидуальными свойствами-ребрами (см. рисунок ниже).

В этой части речь в первую очередь пойдёт про Fluent API, но мы также поковыряем тему параметров в дженериках и функциях. Это последняя статья, где детально разбирается AST. Я определённо будут возвращаться к кодогену, но предметом разбирательств будут принципы формирования выходного кода, а их реализация ввиду их линейности будет выноситься за скобки.

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

Мы возьмём сугубо игровую задачу с понятным результатом и на её примере узнаем:

• на какие ноды AST стоит обратить внимание в первую очередь;
• где Fantomas-у нельзя доверять;
• где можно хакать;
• где лучше придерживаться пуризма;
• и как на F# можно строить Fluent API.

В этой части мы сосредоточимся на общей организации генератора, входных данных и основных элементах AST. В следующей сделаем то же самое, но на более сложном уровне, сместив повествование в сторону устройства Fluent API.

Привет, Хабр!

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

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

В этой статье я расскажу про устойчивую комбинацию из Suave, Fable.Remoting и Hopac, которая может стать для вас молотком универсальным решением для реализации локальных служебных серверов.

В прошлой части мы познакомились с Abstract Syntax Tree (AST).
В этой займёмся его сборкой в полезных объёмах и генерации конечного кода.

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

Однако я хочу сосредоточиться лишь на очень маленькой области кустарной кодогенерации по месту требования. Её гораздо легче освоить, в отличие от энтерпрайз-монстров, и уж тем более починить или захакать при поддержке. Так что данный цикл будет полезен в первую очередь для работы малой организованной группой. Обеспечение кодогенерации в крупных долгоживущих проектах я оставлю за скобками.

В этой статье я расскажу, как засунуть F# в Yandex Cloud Functions. Навыка работы с Serverless у меня нет, так что это будет не компиляция моего опыта, а отчет о вполне успешном эксперименте.

Судя по всему, разработчики Yandex Cloud Functions считают, что dotnet = C#. Поэтому документация для dotnet написана только c позиции C#-разработчика. О том, что делать F#-разрабу - ни слова. Однако это не означает, что это невозможно в принципе.

Привет, Хабр!

Около трёх месяцев назад, я и мой друг - начинающие .NET разработчики, решили разработать свои виджеты на рабочий стол Windows, так как официальных нормальных виджетов нет (те что в Windows 11 не считаются). Недавно мы выпустили наш проект в релиз, пока что есть 2 виджета (Погода и Заметки), но вскоре их может быть больше! Проект называется Fancy Widgets и мы хотим поделиться им с вами. Вы можете попробовать наши виджеты, скачав их с нашего сайта https://fancy-widgets.onrender.com. Это наш pet-проект и поэтому он ни на что не претендует, мы просто делали его для себя и для удовольствия. Но мы будем рады услышать ваше мнение и предложения по улучшению нашего продукта. Вы можете оставить свои комментарии под этой статьей или написать нам на нашу почту fancy.widgets.help@gmail.com. Цель этой статьи - вкратце рассказать о нашем проекте и о сложностях, которые возникли у нас при разработке. Мы надеемся, что вы найдете нашу статью интересной и полезной. Приятного чтения! ?

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

В прошлой части мы освоили самые азы альтернатив. Познакомились с Alt, Alt.choose и коммитом. В этой части мы научимся собирать сложные альтернативы на основе базовых, а также скрывать этап их подготовки при необходимости.

Hopac -- самостоятельный асинхронный движок, написанный специально под F#.
Он стоит на 4 китах, одним из которых является перенаправление потоков вычисления через явное противопоставление конкурирующих задач.

Конкурирующие задачи (или ветки) реализуются через концепцию альтернатив (или Alt), которую я хочу осветить в этом цикле из трёх статей.

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

Грокнув Traversable, вы удивитесь, как вы вообще раньше жили без него. Попытки понять Traversable просто глядя на сигнатуру типа никогда не доставляли мне особого удовольствия. Поэтому, в этом посте мы используем другой подход и сами придумаем его в процессе решения реальной задачи. Так мы прочувствуем момент осознания, когда наконец поймем, как он работает, и где его можно применять.

В предыдущем посте мы открыли Аппликативный функтор, а если точнее, изобрели функцию apply. С ее помощью мы решили проблему валидации полей кредитной карты. Функция apply позволила легко объединить результаты каждой функции, отдельно проверяющей одно поле - номер карты, срок действия и CVV - в объект типа Result<CreditCard>, который представляет финальный результат проверки всех данных кредитной карты на корректность. Возможно, вы также помните, что в случае если у нас есть несколько ошибок валидации, мы решили пойти простым путем и просто возвращать первую из них.