F# 入門:少しでも書けるようになるための記録 - Qiita

はじめに 関数まつりというイベント先日参加して、F#について興味がでてきました。F#を少しでも書けるようになってみたいとおもい、ちょっと paiza で問題を解いてみたので、その時に学んだことをまとめたものです。これから F# を始めたい人などの参考になれば嬉しいです。 ...

Qiita

またまた世界にモナドの解説が増えてしまいました。😅 今回はHaskellとOCamlのアプローチを比較して、型クラスがどれだけ重要な違いを齎すかに就いて書いてみました。JavaScriptのPromiseと比べる譬えは半分しか真実を語っていないんですよね…

https://hackers.pub/@hongminhee/2025/monads

#関数型プログラミング #Haskell #またモナドの話か

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

【シン・プロセス指向】pythonを題材にDomain Modeling Made Functional【気分はstatic! 】 - Qiita

前置きDomain Modeling Made Functional 的手法というのか、fDDD的なやつのおすすめ記事です# order-workflowOrder -> validateOr…

Qiita
Elixir入門からPhoenixでCRUD + SPAまで - Qiita

この記事は「Elixir Advent Calendar 2023 9日目の記事ですpiyoyo_exのMotzです。普段はTypeScript,React,Go,Pythonなどを書くことが多…

Qiita

[Tw] RT @shoeisha_books: 📚見本誌できました!📚

【8/3発売予定 ご予約受付中】
『なっとく!関数型プログラミング』
Michał Płachta 原著
https://t.co/GhOFp2tMGo

#翔泳社 #プログラミング #開発 #関数型プログラミング https://t.co/HElDOguFWK
[de] https://twitter.com/windymelt/status/1686717998613385216

なっとく!関数型プログラミング | 翔泳社

"当たり前"となった関数型を 意識せずに使いこなすために 本書は Michał Płachta, "Grokking Functional Programming" Manning Publications 2022 の邦訳版です。 いまや、どの言語の開発環境においてもフツーに目にする「関数型プログラミング」。 ということは、概念さえしっかり把握してしまえば、どんな開発の現場であっても関数型プログラミングのメリットを(検索やAIを援用することなく)享受できるということです。 本書は  ・シグネチャがウソをつかない  ・本体が極力宣言的である というトピックを少しずつ掘り下げながら、最終的に「古い習慣に囚われることのない、現実的なプログラム」を構築できるように読者をいざなってくれます。 本書によって、オブジェクト指向プログラミングと同様、関数型プログラミングを母国語のように書き、問題解決の新しいアプローチを習得できるでしょう。 【著者について】 ・Michał Płachta(ミハエル・プワッチャ) 2014年にScalaの商用利用を始めて以来、ScalaおよびJVMコミュニティに積極的に貢献してきました。定期的にカンファレンスで講演したりワークショップやミートアップを開催するなど、関数型プログラミングによって開発者がより良いプロダクトを作成できるように支援しています。 【目次】 Part 1 関数型ツールキット  第1章 関数型プログラミングを学ぶ  第2章 純粋関数  第3章 イミュータブルな値  第4章 値としての関数 Part2 関数型プログラム  第5章 逐次プログラム  第6章 エラー処理  第7章 型としての要件  第8章 値としてのIO  第9章 値としてのストリーム  第10章 並行プログラム Part3 関数型プログラミングの応用  第11章 関数型プログラムを設計する  第12章 関数型プログラムをテストする

Shoeisha
#java
#関数型プログラミング
クロージャーで苦労じゃあ。
Java8の関数リテラルでは関数の外にある変数はfinalか実質的にfinalな変数(再代入が無いコード)じゃないと使えない…。
なぜfor文は禁止なのか?関数型記述のススメ by ukiuni@github https://qiita.com/ukiuni@github/items/abad07524856c65a20ea #Qiita #JavaScript #関数型プログラミング
なぜfor文は禁止なのか?関数型記述のススメ - Qiita

# なぜfor文は禁止なのか。 結論からいうと、可読性のためです。 for文は何かを「繰り返し処理をする」ことに使いますが、実際に求められるのは、「全ての要素に処理をする」とか、「母集団から選択して処理をする」こともおおくあります。 ...

以下のタグの Qiita 記事がこの1時間に投稿されました。
➖➖➖➖➖➖➖➖➖➖
#ses
#talend
#word2vec
#zabbix
#クーポン情報をまとめて
#考古学
#関数型プログラミング
➖➖➖➖➖➖➖➖➖➖
各 Qiita 記事へのリンクは、このトゥートのスレッドに「非公開」もしくは「未収載」でトゥートされています。
スレッドを見るにはこのトゥートをクリックしてください。
以下のタグの Qiita 記事がこの1時間に投稿されました。
➖➖➖➖➖➖➖➖➖➖
#11010
#analytics
#android
#aws
#check
#cognos
#convolutionalneuralnetworks
#dapps
#elasticbeanstalk
#es6
#ethereum
#fontawesome
#globus
#javascript
#keyword
#python
#python3
#rails
#ruby
#scality
#setup
#sinatra
#solidity
#telnet
#tensorflow
#unicode
#vpc
#zabbix
#ドリルスルー
#ブロックチェーン
#新機能
#関数型プログラミング
➖➖➖➖➖➖➖➖➖➖
各 Qiita 記事へのリンクは、このトゥートのスレッドに「非公開」もしくは「未収載」でトゥートされています。
スレッドを見るにはこのトゥートをクリックしてください。