Contents Introduction Stacks Collections Abstract data types Refactoring Handling nil Multiple results Asynchronous code Monads Conclusion Introduction Hello! Iâm going to tell you about monads, and how we can uncover them by refactoring our Ruby code. The ideas in this article might be unfamiliar, so before we get stuck into the details, letâs warm our brains up with something simple. People alwa
èè ã®Martin Grabmülleræ°ã«è¨±å¯ãããã ãã¾ããã®ã§ã Haskellã¢ãããã©ã³ã¹ãã©ã¼ãã¼ã®ãã¥ã¼ããªã¢ã«ã翻訳ãããã®ãå ¬éãã¾ãã ã¿ã¤ãã誤訳ãããã°ã©ã ã®ãã¹çããã¾ãããã Twitterå®@bicycle1885ãã³ã¡ã³ãæ¬ã¾ã§ãé£çµ¡é ããã¨ãããããã§ãã å ã®ããã¹ããããã°ã©ã ã¯ä»¥ä¸ã®ãªã³ã¯ããå¾ããã¾ãã Monad Transformers Step by Step [2012/12/19] 誤ãã夿°è¨æ£ãã¾ãããid:qtamakiããããããã¨ããããã¾ãã [2014/6/19] 誤ãã2ç¹è¨æ£ãã¾ãããid:daimatzãããid:hitotakuchanããããããã¨ããããã¾ãã Monad Transformers Step by Step Martin Grabmüller Oct 16 2006 æ¦è¦(Abstract) ãã®
Written April 17, 2013 updated: May 20, 2013 Here's a simple value: And we know how to apply a function to this value: Simple enough. Lets extend this by saying that any value can be in a context. For now you can think of a context as a box that you can put a value in: Now when you apply a function to this value, you'll get different results depending on the context. This is the idea that Functors
Interpreters Good programmers decompose data from the interpreter that processes that data. Compilers exemplify this approach, where they will typically represent the source code as an abstract syntax tree, and then pass that tree to one of many possible interpreters. We benefit from decoupling the interpreter and the syntax tree, because then we can interpret the syntax tree in multiple ways. For
å®¶ã®ãªããæ£®ã«ããããã¨ããæ¬²æ ä»å¹´ã¯ãªãã ãè¦³èæ¤ç©ã®è¦³å¯ã楽ãããæ¬æ¥ã¯æ¤ç©ã«ã¤ãã¦ã®è¨äºã§ãããåãæ ¹ã£ããªã©ã®ç»åãããã®ã§è¦æãªæ¹ã¯é¿ãã¦ãã ãããã ãã£ã«ã¹ã»ã¦ã³ãã©ã¼ã¿ ãã¡ã®ã¡ã¤ã³çåå¨ã¯ãã£ã«ã¹ã»ã¦ã³ãã©ã¼ã¿ãã¦ã³ã殿ãæãå®¶ã«ãã£ã¦ããã®ã¯2020å¹´5æãã³ããç¦åâ¦
The document describes how to build a parser for Backus-Naur Form (BNF) grammars in Haskell using the attoparsec parsing library. It defines types and parsers to represent BNF syntax, rules, expressions, lists and terms. The parsers use functions like spaces, string, text from attoparsec to parse individual components and combine them using operators like <*>, <|> to build up the full BNF grammar
ãã®è¨äºã¯ãMonad ã§ã¤ã¾ã¥ãã Haskeller ã®ããã® Monad åå ¥éã§ãã Monadã¨ã¯ä½ã§ããï¼ Monad ã¨ã¯ãåãªãåã¯ã©ã¹ã®ä¸ã¤ã§ããé£ããã¨ãã風è©ãããã¾ããããã以ä¸ã§ããã以ä¸ã§ãããã¾ããã ãã®åã¯ã©ã¹ã®ã¡ã½ããã¯ãreturn 㨠>>= ã§ãã class Monad m where (>>=) :: m a -> (a -> m b) -> m b return :: a -> m a ã¤ã¾ãã以ä¸ãæºããåã®éåã Monad ã§ãã m a ã§è¡¨ç¾ã§ããããã«ä¸ã¤ã®å夿°ãæ ¼ç´ããã³ã³ããå >>= 㨠return ãå®è£ return ã¯æ°ããã³ã³ãããä½ãã>>= ã¯äºã¤ã®ã³ã³ãããåæãã¾ãã Monad ã®ã¤ã³ã¹ã¿ã³ã¹ã¯å¤±æç³»ã¨ç¶æ ç³»ã«å¤§å¥ã§ãã¾ãã以ä¸ã«ä»£è¡¨çãªã¤ã³ã¹ã¿ã³ã¹ã示ãã¾ãã 失æç³»: Maybeã[] (ãªã¹ã)
ãã®è¨äºã®ç®çã¯ãApplicative ä¿¡è ã«ãã Applicative ã¹ã¿ã¤ã«ã®å¸æã§ãã ç°¡æ½ã«çµè«ãè¿°ã¹ãã¨ã foo = do a <- m1 b <- m2 return (f a b) ã®ãããªã³ã¼ããæ¸ããããªã£ãã foo = f <$> m1 <*> m2 ã¨æ¸ãã¾ãããã¨ãããã¨ã åãè¨èã¯ããdo 㨠return ããªããï¼ãã§ãã Functorã¨Monadã®é Functor ãç¹æ®åããåã¯ã©ã¹ãMonadã§ãMonadã®æ¹ãå¼·åã§ãããªããªããã¡ã½ãããå¢ããããã§ãã Functorã®ã¡ã½ããã¯fmapã§ããfmapã®å¥åã (<$>) ã¨ããã¾ãã(ãã®è¨äºã§ã¯ã(<$>) 㨠liftM ãåä¸è¦ãã¾ãã) ããã¦ãMonadã®ã¡ã½ããã¯ããåç¥ã®éã (>>=) 㨠return ã§ãã Functorã¨Monadã®éã«Applicative
ã¢ããã®ãã¹ã¦ Haskell ã«ãããã¢ããããã°ã©ãã³ã°ã®çè«ã¨å®è·µã«é¢ããå æ¬çã¬ã¤ã Version 1.1.0 ãã®ãã¥ã¼ããªã¢ã«ã¯ãã¢ããã®æ¦å¿µã¨ãã®é¢æ°ããã°ã©ãã³ã°ã«ãããå¿ç¨ã« ã¤ãã¦ãåä¸ç´ã® Haskell ããã°ã©ãã«ãããããããå©ç¨ä¾¡å¤ããããã㪠解説ããããã¨ãæ¨ã¨ãã¦ãã¾ããèªè 㯠Haskell ã«ãªãã¦ãããã¨ãåæã¨ ãã¾ãããã¢ããã«é¢ããçµé¨ã¯è¦æ±ãã¦ãã¾ããããã®ãã¥ã¼ããªã¢ã«ã¯ãå¤ ãã®é¡æãã«ãã¼ãã¦ãã¾ããå¾åã®ã»ã¯ã·ã§ã³ã§ã¯ãååã®é¡æãããçè§£ã ã¦ãããã¨ãåæã¨ãã¾ããé ããã£ã¦ãã¢ããããã°ã©ãã³ã°ãä¾ç¤ºãããã ã®ãµã³ãã«ã³ã¼ããããããç¨æããã¦ãã¾ããä¸èªã§ããã¹ã¦ã®é¡æãå¸åã ããã¨ããã®ã¯ãå§ãã§ãã¾ããã ãã®ãã¥ã¼ããªã¢ã«ã¯ 3 ã¤ã®é¨åã§æ§æããã¦ãã¾ããæåã®é¨åã¯ã 颿°ããã°ã©ãã³ã°ã«ãããã¢ããã®åºæ¬ç
æå¾ã«åºããä¾ã§ããã module Main where main :: IO () main = getLine >>= putStrLn . reverse ã¢ããã§æããã²ããããã®ãªã - å³ã§ããã(?)ã¢ãã ããã»ã©ã®ã¨ã³ããªã®å³ãå ¨é¨ãããã°ã以ä¸ã®ãããªå³ãæ¸ãã¾ãããreverseãfmapã§æã¡ä¸ãã¦æ©ãæ¶ããè½ã¡ã¦ããputStrã®å·¦ç«¯ã>>=ã§åããä¸ãã¾ãããã®å³ã§ã§ããIO StringããIO ()ã¸ã®é¢æ°ã¯ãã¢ããã®æ§è³ª(â坿æ§)ãããããããããã¨ã«æåã®å³ã§ã§ãã颿°ã¨åãã«ãªãã¾ãã ãã®å³ããã以ä¸ã®ã³ã¼ããæ¸ãã¾ãã module Main where main :: IO () main = fmap reverse getLine >>= putStrLn Haskellã§ã¯é¢æ°éã®åãããããã«ã³ã¼ãã£ã³ã°ããããã¨ãå¤ãã¨æãã¾ããã
åè«ã®æå¤§ã®æ¦å¨ã¯ãã¤ã¢ã°ã©ã ãªã®ã§ãã¢ããã§æããã²ããããã®ãªããã¤ã¢ã°ã©ã ã使ãã°ããããããªãã§ããããã ãã¤ã¢ã°ã©ã ã®æ¸ãæ¹ ä¾ãã°ãã f :: a -> b ãã¨ããlength :: [a] -> Intãã¯ä»¥ä¸ã®ããã«æ¸ãã¾ããåãç¹ã§ã颿°ãç¢å°ã§æ¸ãã¾ãã ãã¤ã¢ã°ã©ã ã®å©ç¹ã¯ãfãlengthã®ä¸èº«ãå¿ãã¦ç°¡ç¥åãããã¨ãã§ãããã¨ã§ãã人éã®è³ãã§ãããã¨ã«ã¯éããããã®ã§ã注ç®ããæ å ±ãå°ãªãæ¹ãçè§£ãããããªãã£ã¦ã¹ã³ãã¼ã§ãã ãªãã åæ g . f ã¯å³ç¤ºããæã«é ãéã«ãªãã®ã§æ°ãã¤ãã¦ä¸ãããããã¯ãåæé¢æ°ã®é©ç¨ã g ( f x ) ã¨æ¸ãããã¨ã«ç±æ¥ãã¦ã¾ããã¾ãfãé©ç¨ããæ¬¡ã«gãé©ç¨ããã¨ãããã¨ã§ãã return 㨠>>= ã®å³ç¤º ä»åã®ãã¤ã¢ã°ã©ã ã®ç´æã¨ãã¦ãå ã¨ãªãå(Bool, Char, Int ç)ã¯æä¸æ®µã«æ¸ãã¾ããã
ããã«ååã®ç¶ãã§ããããã§æå¾ã Stateã¢ããã«ããã >>= ã®èª¬æã¨ã颿°çãªã¤ã¡ã¼ã¸ã解説ããã¤ãããªã®ã§ããã»ã»ã»ã ãã¼ãããããã説æã®ä»æ¹ãã¨ã¦ããããªãã§ãã(æ±ã解説ã«é¢ãã¦ããã£ã¨ããããããããã«ãªãã³ã¸ããæ¹ãããããããã¾ããã ã¨ãããããèªåã®åå¼·ã¨ãã¦ã¯ã¢ããã®çµµçãªã¤ã¡ã¼ã¸ãæ´ããã®ã§ããã£ãã§ãã
ååã®ç¶ãã§ããï¼åã§çµããã¾ããã§ããorz ä»åã¯ãStateã¢ããã®å¤ã®èª¬æã¨ãreturnã®å®ç¾©ã§ãã ã¢ãã=Stateã¢ããã¨ããã¢ãã=IOã¢ãããªã©ã¨æãã®ã¯å±éºã§ãããStateã¢ããã¯ãã¢ããã¤ã³ã¿ãã§ã¼ã¹ã®å®è£ ä¾ããããã«è§£éããã®ãããã¨æãã¾ãã
3å¹´åã«çè§£ãããã¨ãã¦æ¨æãã*1Haskellã®Stateã¢ããã®è§£èª¬ã«ããªãã³ã¸ãããã¨æãã¾ããåè«ãã¡ãã£ã¨ã¯ããã£ãã®ã§ãä»åº¦ããã¾ã¨ããªè§£èª¬ãã§ããã¯ãã ã¨è¨ããã¨ã§ãä»åã¯åç·¨ã§ããåè«ã®ç¥èã¯åæã¨ã¯ãã¦ãªãã§ãããéåã¨ååã«ã¢ã¬ã«ã®ã¼ãããã¨ãã¤ãããããã¾ããã *1:3å¹´åã®æå ã¯ãåãSetsã ã¨æãè¾¼ãã§ãä¸ã«é¢æããååãååã«ç§»ãååãã ã¨èª¤è§£ãã¦ããã¨ã§ããããã
ã©ã³ãã³ã°
ã©ã³ãã³ã°
ã¡ã³ããã³ã¹
ãªãªã¼ã¹ãé害æ å ±ãªã©ã®ãµã¼ãã¹ã®ãç¥ãã
ææ°ã®äººæ°ã¨ã³ããªã¼ã®é ä¿¡
å¦çãå®è¡ä¸ã§ã
j次ã®ããã¯ãã¼ã¯
kåã®ããã¯ãã¼ã¯
lãã¨ã§èªã
eã³ã¡ã³ãä¸è¦§ãéã
oãã¼ã¸ãéã
{{#tags}}- {{label}}
{{/tags}}