| dbo:abstract
|
- En programació funcional una mònada és un TAD sense tipus concrets, corresponent a una estructura algebraica d'un sol element (d'aquí el nom de mònada), on la finalitat de les operacions és modelar la composició i la seqüencialitat de les computacions (accions amb efectes) mitjançant l'encadenament, separant la composició temporal, de l'execució, així com incorporar el resultat de cada operació sobre l'entorn. La mònada modela una computació i pot ser vista com una acció amb efecte (un canvi), que produeix un resultat. Les mònades es poden compondre, mitjançant l'encadenament, amb operacions sobre el resultat de la precedent (que poden incloure efectes col·laterals), estalviant, respecte de la programació imperativa, les variables locals emprades per aquesta per desar resultats.
* (return v) representa una computació elemental que ofereix v com a resultat. return és el generador de la mònada.
* (>>=), anomenada bind, és la composició de computacions, encadenant una acció amb la següent en forma de funció sobre el resultat de la precedent. En notació Haskell: -- generador d'una computació simple, que retorna una expressió de tipus `a` com a resultatreturn :: a -> efecte a-- composició de computacions per encadenament amb el resultat(>>=) :: efecte a -> (a -> efecte b) -> efecte b -- compon amb una altra, com a funció del resultat de la precedent . -- tipus de l'accióacció :: efecte tipusDelResultat-- exemple d'ús amb els operadors canònics:acció = return 5 -- acció simple que ofereix el valor com a resultatacció = acció1 >>= funcAcció2 -- retorna el resultat de la darrera acció-funció -- que s'aplica al resultat de la primera -- exemple amb niuament progressiu per retornar una expressió de resultats precedentsacció = acció1 >>= \resultat1 -> (acció2 >>= \resultat2 -> return expressió_de_resultats_precedents)-- el mateix amb notació monàdica (sintaxi especial) denotant la precedència temporalacció = do resultat1 <- acció1 -- sintaxi: resultat "<-" acció_d'efectes resultat2 <- acció2 ... let resultatNou = expressió_de_resultats_precedents return resultatNou -- acció simple que retorna el valor La mònada (signatura) s'implementa per a un tipus (estructura) que pot ser vist com un contenidor d'un sol element que pot ser el resultat, però no sempre és el resultat tot sol. aparella com a valor el resultat i un element combinable (un Monoide). conté com a valor una funció de tipus (entorn -> resultat). conté com a valor una altra tipus de funció (estat -> (resultat, nouEstat)). Té aplicació en llenguatges de programació no-estrictes, on l'ordre de les operacions és indeterminat, principalment al Haskell i també en altres àmbits, en entorns on l'ordre de les operacions no està garantit, com ara encadenament de transaccions en memòria (mònada a Haskell i a OCaml), encadenament d'operacions asíncrones (mònada Par a Haskell, Asynchronous Workflows a F#), etc. Això facilita als lleng. funcionals complementar la part funcional pura, amb efectes com ara operacions d'entrada/sortida, ops. sobre l'entorn exterior, canvis d'estat, i també el preprocés i optimització de les operacions abans de la seva execució. Les lleis de la mònada.
* Al llenguatge Haskell la classe de tipus Monad descriu la signatura de les operacions descrites, a banda d'altres mètodes amb motius pràctics: class Monad efecte where -- generador return :: a -> efecte a -- generador d'una "computació" a partir -- d'un valor de tipus ''a'' interpretable com a resultat {- encadenament (ang.: ''bind'') encadena un efecte amb una funció efecte sobre el seu resultat -} (>>=) :: efecte a -> (a -> efecte b) -> efecte b -- exemple: getline >>= putStrLn -- imprimeix la línia introduïda (resultat de l'efecte precedent) {- la classe Monad també incorpora els següents mètodes, per qüestions pràctiques però que no fan falta per la descripció teòrica: -} {-| (>>) modela un encadenament que ignora el resultat de la computació precedent. -} (>>) :: efecte a -> efecte b -> efecte b m_x >> m_y = m_x >>= (\_ -> m_y) -- implementació per defecte -- el mètode `fail` per disparar error cas de fallar l'encaix a la variable del resultat -- A partir de GHC 8.8 desapareix de Monad i obliga que els encaixos siguin irrefutables -- Per a l'ús de patrons refutables als encaixos caldrà que la mònada implementi MonadFail fail :: String -> IO a fail missatge La funció `fail` s'utilitza en la sintaxi específica de blocs d'encadenaments monàdics, els , per disparar una excepció en cas que falli l'encaix del patró del paràmetre de la funció d'efectes, però serà expulsada de la classe Mònada a GHC 8.8, cap a una classe específica MonadFail de Control.Monad.Fail. L'ús de patrons en l'encadenament requerirà que la mònada implementi MonadFail evitant les petades per l'ús de patrons en mònades que no els suporten. Fase final de la proposta implementada a GHC 8.8. En Haskell podem expressar (>>=), en termes de fmap i join, doncs la classe Monad actualment deriva de la classe Applicative que deriva al seu torn de Functor. El nom "flatMap" que (>>=) pren en altres llenguatges (Scala, Java8) ve de l'ús d'aquests conceptes: -- ''join'' aplana el tipus.join :: Monad efecte => efecte (efecte a) -> efecte a-- Si l'efecte implementa l'estructura Functorfmap :: Functor efecte => (a -> b) -> efecte a -> efecte b-- (>>=) :: efecte a -> (a -> efecte b) -> efecte b m_a >>= f = (join. fmap f) m_a -- d'aquí el nom de flatMap en altres llenguatges
* Al llenguatge OCaml: Mònada per a les computacions IO no blocants.(* De la biblioteca Light Weight Threads. A l'OCaml els tipus s'apliquen en sentit invers (de dreta a esq.) *)module LWT = sig type +'a t (* The type of threads returning a result of type 'a. *) val return : 'a -> 'a t val (>>=) : 'a t -> ('a -> 'b t) -> 'b t val fail : exn -> 'a t ...end ;;
* A Scala la mònada és el substrat de les llistes per comprensió: Vegeu més avall.trait FilterMonadic[+A, +Repr] extends Any { // flatMap: encadenament (equivalent del Haskell (>>=)) abstract def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That // la transformació final en una llista per comprensió requereix que implementi Functor // l'aplicació del mètode (map f) converteix la coŀleció Repr en una del tipus de sortida That abstract def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[Repr, B, That]): That abstract def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Repr] abstract def foreach[U](f: (A) ⇒ U): Unit}
* A Java8 la classe d'objectes Optional implementa operacions similars a les de Scala:Class Optional<T> public static <T> Optional<T> of(T value) // equivalent del Haskell (return) public <U> Optional<U> flatMap(Function super T, Optional<U>> mapper) // equivalent del Haskell (>>=) public <U> Optional<U> map(Function super T, ? extends U> mapper) // equivalent del Haskell (fmap) Optional<T> filter(Predicate super T> predicate) ... (ca)
- Monáda je funktoriální datový typ vybavený dvěma přirozenými transformacemi umožňujícími asociativní skládání operací nad monádami. Formálně je monáda monoidem v kategorii endofunktorů v kategorii typů (v Haskellu kategorie Hask). Obecně je-li tenzorová kategorie (kde je bifunktor a ), monády jsou monoidy v . Přirozené transformace jsou u každé monády multiplikace a jednotka splňující a . Ve funkcionálním programování se tyto operace zpravidla nazývají join a unit. Příkladem monády je kontinuace, kde je funkcí z do definovaná jako aspeciální operace vázání je ,přičemž je . Monády umožňují formulovat kód s vedlejšími efekty tak, aby byl referenčně transparentní, a tedy „čistý“ (ve funkcionálním smyslu). Monády jsou zpravidla generické a jejich druh je . Z každého endofunktoru lze vytvořit volnou monádu. (cs)
- Στον συναρτησιακό προγραμματισμό ηλεκτρονικών υπολογιστών, μια μονάδα (Αγγλικά: monad) είναι μια δομή η οποία αναπαριστά τους υπολογισμούς οι οποίοι ορίζονται σε μια σειρά από βήματα. Ο τύπος της δομής μονάδας ορίζει αυτή την σειρά εφαρμογής υπολογισμών ή μια κλήση ενθυλακωμένων συναρτήσεων του ίδιου τύπου. Αυτή η δομή επιτρέπει στον προγραμματιστή να δημιουργεί (με τεχνικές σωλήνωσης (Αγγλικά: pipelining)) επεξεργασίες οι οποίες επεξεργάζονται δεδομένα με βήματα. Σε κάθε ενέργεια υπάρχουν περαιτέρω κανόνες επεξεργασίας οι οποίες παρέχονται από την μονάδα. (el)
- In der funktionalen Programmierung sind Monaden ein abstrakter Datentyp. Wesentliche Eigenschaft von Monaden ist die Fähigkeit der Übertragung von Werten und Berechnungen eines „einfacheren“ Typs zu Berechnungen eines „höheren“ Typs, der mittels eines aus dem einfacheren Typ hervorgeht, sowie die Verknüpfung mehrerer solcher Übertragungen zu einer einzigen. (de)
- En théorie des langages fonctionnels typés, une monade est un patron de conception qui combine des éléments de langages fonctionnels avec des méthodologies propres aux langages impératifs. En pratique, les valeurs retournées par des portions de programme (qui peuvent être vus comme des fonctions) sont englobées en un type pour être enchaînées ultérieurement en d'autres computations. Il s'agit alors d'avoir une représentation simulant exactement des notions telles que les exceptions ou les effets de bords, tout en conservant la logique propre à la programmation fonctionnelle. L'usage des monades présente plusieurs intérêts : analyses statiques et preuves de programmes plus simples, usage de l'appel par nécessité, optimisations (déforestation, mémoïsation de valeurs, parallélisation, (en)). (fr)
- In functional programming, a monad is a software design pattern with a structure that combines program fragments (functions) and wraps their return values in a type with additional computation. In addition to defining a wrapping monadic type, monads define two operators: one to wrap a value in the monad type, and another to compose together functions that output values of the monad type (these are known as monadic functions). General-purpose languages use monads to reduce boilerplate code needed for common operations (such as dealing with undefined values or fallible functions, or encapsulating bookkeeping code). Functional languages use monads to turn complicated sequences of functions into succinct pipelines that abstract away control flow, and side-effects. Both the concept of a monad and the term originally come from category theory, where a monad is defined as a functor with additional structure. Research beginning in the late 1980s and early 1990s established that monads could bring seemingly disparate computer-science problems under a unified, functional model. Category theory also provides a few formal requirements, known as the , which should be satisfied by any monad and can be used to verify monadic code. Since monads make semantics explicit for a kind of computation, they can also be used to implement convenient language features. Some languages, such as Haskell, even offer pre-built definitions in their core libraries for the general monad structure and common instances. (en)
- En la programación funcional , una mónada (monad en inglés), es un patrón de diseño que representa cálculos definidos como una secuencia de pasos, permitiendo componer funciones con tipos incompatibles encapsulándolos en un tipo monádico. Un tipo de dato con una estructura mónada define lo que simboliza en un bloque de código, o anida funciones del mismo tipo. Esto le permite al programador crear tuberías informáticas que procesan datos en pasos, a los cuales se les asocia un decorador con reglas de proceso adicionales provistas por la mónada. Por lo tanto, las mónadas han sido descritas como un “punto y coma programable”; un punto y coma, siendo el operador usado para unir varias declaraciones en la programación imperativa, en consecuencia la expresión implica que código extra será ejecutado entre las declaraciones de una tubería. Las mónadas también han sido explicadas con un metáfora física, donde se comportan como una línea de ensamblaje, en las que un objeto transporta datos entre unidades funcionales que la van transformando un paso a la vez. También se las puede ver como un patrón de diseño funcional para construir tipos genéricos. Los programas puramente funcionales pueden usar las mónadas para estructurar procedimientos que incluyan operaciones en secuencia como aquellos encontrados en la programación estructurada.Muchos conceptos de programación comunes pueden ser descritos en términos de estructuras de mónadas, incluyendo los efectos secundarios, la Entrada/salida, asignación de variables, el manejo de excepciones, el analizador sintáctico, la programación no determinística, concurrencia y continuaciones. Esto permite que tales conceptos sean definidos en maneras puramente funcionales sin el uso de extensiones a la semántica del lenguaje. Los lenguajes como Haskell proveen mónadas en el núcleo estándar, permitiendo a los programadores reutilizar largas partes de su definición formal y aplicar en diversas librerías las mismas interfaces para combinar funciones. Formalmente , una mónada consiste de un constructor de tipo M y dos operaciones , unir y retorno (donde retorno es a veces conocido como unidad). Las operaciones deben cumplir con ciertas propiedades para permitir la composición correcta de funciones mónadicas (es decir, funciones que usen valores de la mónada como sus argumentos o valores de retorno). La operación retorno toma una valor de un tipo plano y lo pone en un contenedor mónadico usando el constructor, creando así un valor mónadico. La operación unir realiza el proceso inverso, extrayendo el valor original del contenedor y pasándolo a la siguiente función asociada en la tubería, posiblemente con chequeos adicionales y transformaciones. Dado que una mónada puede insertar operaciones adicionales en el dominio lógico del programa, se les puede considerar como un tipo de programación orientada a aspectos. La lógica de negocio puede ser definida por la programación de aplicaciones en la tubería, mientras que las operaciones a ser repetidas muchas veces pueden ser operadas por una mónada predefinida construida previamente . El nombre y concepto viene del epónimo (mónada) en la teoría de categorías, donde las mónadas son un tipo de funtor, o sea un mapeo entre categorías; aunque el término mónada en el contexto de la programación funcional es usualmente tomado como correspondiente al término mónada fuerte en la teoría de categorías. (es)
- Nella programmazione funzionale, una monade è una struttura che esprime una classe di computazioni concatenabili. Con l'ausilio di questa struttura, è possibile compiere, anche nei linguaggi puramente funzionali, operazioni in sequenza, un po' come avviene nei linguaggi imperativi o procedurali. Infatti, possono essere espresse, con l'ausilio delle monadi, fenomeni come gli effetti collaterali, l'IO, gestione dell'eccezioni. In Haskell, la classe Monad viene espressa come segue: class Monad m where (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b -- non strettamente necessaria return :: a -> m a fail :: String -> m a -- non strettamente necessaria (it)
- 関数型プログラミングにおいて、モナドはプログラムを構造化するための汎用的な抽象概念である。対応したプログラム言語では、ボイラープレート的なコードでもモナドを使って除去することが可能となる。これはモナドが、特定の形をした計算を表すデータ型と、それに関する生成と合成の2つの手続きを提供することによって実現されている。生成は任意の基本型の値をモナドに包んでモナド値を生成する手続きであり、合成はモナド値を返す関数(モナド関数)たちを合成する手続きである。 広い範囲の問題をモナドを使うことで単純化できる。例えば、Maybeモナドを使えばへの対処が簡単になり、Listモナドを使えばリストに入った値を柔軟に扱うことができる。複雑に組み合わさった関数は、モナドを使えば、補助データの管理や制御構造や副作用を除去した簡単なパイプライン構造に置き換えることができる。 モナドの概念や用語は圏論から来ている。圏論においては、モナドは追加の構造を持つ関手として定義されている。1980年代の後半に研究され始め、1990年代前半には、一見無関係な計算機科学上の問題がモナドによって統一的で関数的にモデル化できることが分かってきた。圏論はモナドの満たすべき形式的な条件を与え、これはモナド則と呼ばれている。モナド則はモナド的なコードの形式的検証にも使用可能である。 ある種の計算では、その計算の意味をモナドで明確に表現できることを利用して、プログラム言語の便利機能の実装にモナドを使うことができる。Haskellのように、標準ライブラリですでに汎用のモナド構造といくつかのインスタンスを定義している言語もある。 (ja)
- Monada – w programowaniu funkcyjnym: rodzaj abstrakcyjnego typu danych, który implementuje funkcje wiązania (ang. bind) oraz jednostki (ang. unit). Pojęcie to wywodzi się z teorii kategorii, gdzie omawiany abstrakt stanowi monadę nad kategorią typów z funkcjami jako morfizmami. Jednostka określa operację tworzenia singletonu czy też akcji, której wynikiem jest zadana wartość. Wiązanie (w niektórych językach określane jako flat map) buduje na podstawie wyniku poprzedniego obliczenia nowe obliczenie, zachowując przy tym jego formę. Jedną z głównych cech monad jest to, że pozwalają wynieść pewne mechanizmy i zachowania do abstrakcji, zwalniając tym samym programistę z konieczności ręcznej obsługi kontekstu. Przykładowo, działając na (jakkolwiek zdefiniowanych) zbiorach można opisać jednostkę jako oraz wiązanie jako by potem w sposób generyczny budować potoki danych w kompletnym oderwaniu od wewnętrznej implementacji czy nawet interpretacji. Dla przykładu konstruowanie iloczynu kartezjańskiego dwóch zbiorów mogłoby przebiegać tak: Istotne w tym przykładzie to, że przy definiowaniu operacji prod ani razu nie skorzystano z faktu, że nośnikiem danych jest matematyczny zbiór. Będzie ona zatem działać dla każdej monady, bez względu na jej wewnętrzną reprezentację. To podejście stanowi popularny wzorzec projektowy, który ma szerokie zastosowanie przy definiowaniu obliczeń zawierających dodatkowe reguły przetwarzające, jak chociażby transformowanie stanu, współbieżność, obsługę wejścia-wyjścia lub wyjątków. (pl)
- Мона́да — особый тип данных в функциональных языках программирования, для которого возможно задать императивную последовательность выполнения некоторых операций над хранимыми значениями. Монады позволяют задавать последовательность выполнения операций, производить операции с побочными эффектами и другие действия, которые сложно или вовсе невозможно реализовать в функциональной парадигме программирования другими способами. Концепция монады и термин изначально происходят из теории категорий, где она определяется как функтор с дополнительной структурой. Исследования, начатые в конце 1980-х — начале 1990-х годов, установили, что монады могут привнести, казалось бы, разрозненные проблемы компьютерной науки в единую функциональную модель. Теория категорий также выдвигает несколько формальных требований[каких?], так называемых монадических законов, которые должны соблюдаться любой монадой и могут быть использованы для верификации монадического кода. (ru)
- Деякі із функційних мов програмування[які?] використовують монади для структурування програм, що містять операції, що мають виконуватись в певному порядку. Назва походить із теорії категорій, розділу математики, що описує шаблони, які можуть бути застосовані до різних розділів математики. Основними застосуваннями монад у функційному програмуванні є визначення операцій вводу/виводу (I/O) та зміни в станах без використання засобів мов програмування, що чинять побічні ефекти. Принцип дії монад полягає в тому, що, хоча функція і не може робити побічний ефект напряму, вона може створювати значення, що описує бажаний побічний ефект, і яке можна використати коли потрібно. Однак, I/O та керування станом в жодному разі не є єдиними способами використання монад. Вони корисні тоді, коли розробник бажає описати обчислення в чисто функційному стилі, виконуючи паралельно інші обчислення. Функційна мова програмування Гаскель інтенсивно використовує монади та має синтаксичні конструкції для полегшення роботи з ними. (uk)
- 在函数式编程中，单子（monad）是一种抽象，它允许以泛型方式构造程序。支持它的语言可以使用单子来抽象出程序逻辑需要的。为了达成这个目标，单子提供它们自己的数据类型（每种类型的单子都有特定的类型），它表示一种特殊形式计算，与之在一起的有两个过程，一个过程用来包装单子内“任何”基本类型的值（产生单子值），另一个过程用来那些输出单子值的函数（叫做单子函数）。 单子的概念和术语二者最初都来自范畴论，这里的单子被定义为具有额外结构的函子。开始于1980年代晚期和1990年代早期的研究，确立了单子可以将看似完全不同的计算机科学问题置于一个统一的函数式模型之下。范畴论还提供了叫做单子定律的一些形式要求，任何单子都应当满足它并可以用它来验证单子代码。 通过单子，编程者可以把复杂的函数序列变成简洁的管道，它抽象出了辅助数据管理、控制流或副作用。单子可以简化范围宽广的问题，比如处理潜在（通过Maybe单子），或将值保持在一个灵活而形式正确的列表中（使用List单子）。因为单子使得某种计算的语义明确，它们还可以用来实现便捷的语言特征。一些语言比如Haskell，甚至在它们的核心库中为通用单子结构提供预制的定义和常用实例。 (zh)
|
| rdfs:comment
|
- Στον συναρτησιακό προγραμματισμό ηλεκτρονικών υπολογιστών, μια μονάδα (Αγγλικά: monad) είναι μια δομή η οποία αναπαριστά τους υπολογισμούς οι οποίοι ορίζονται σε μια σειρά από βήματα. Ο τύπος της δομής μονάδας ορίζει αυτή την σειρά εφαρμογής υπολογισμών ή μια κλήση ενθυλακωμένων συναρτήσεων του ίδιου τύπου. Αυτή η δομή επιτρέπει στον προγραμματιστή να δημιουργεί (με τεχνικές σωλήνωσης (Αγγλικά: pipelining)) επεξεργασίες οι οποίες επεξεργάζονται δεδομένα με βήματα. Σε κάθε ενέργεια υπάρχουν περαιτέρω κανόνες επεξεργασίας οι οποίες παρέχονται από την μονάδα. (el)
- In der funktionalen Programmierung sind Monaden ein abstrakter Datentyp. Wesentliche Eigenschaft von Monaden ist die Fähigkeit der Übertragung von Werten und Berechnungen eines „einfacheren“ Typs zu Berechnungen eines „höheren“ Typs, der mittels eines aus dem einfacheren Typ hervorgeht, sowie die Verknüpfung mehrerer solcher Übertragungen zu einer einzigen. (de)
- En théorie des langages fonctionnels typés, une monade est un patron de conception qui combine des éléments de langages fonctionnels avec des méthodologies propres aux langages impératifs. En pratique, les valeurs retournées par des portions de programme (qui peuvent être vus comme des fonctions) sont englobées en un type pour être enchaînées ultérieurement en d'autres computations. Il s'agit alors d'avoir une représentation simulant exactement des notions telles que les exceptions ou les effets de bords, tout en conservant la logique propre à la programmation fonctionnelle. L'usage des monades présente plusieurs intérêts : analyses statiques et preuves de programmes plus simples, usage de l'appel par nécessité, optimisations (déforestation, mémoïsation de valeurs, parallélisation, (en)). (fr)
- 在函数式编程中，单子（monad）是一种抽象，它允许以泛型方式构造程序。支持它的语言可以使用单子来抽象出程序逻辑需要的。为了达成这个目标，单子提供它们自己的数据类型（每种类型的单子都有特定的类型），它表示一种特殊形式计算，与之在一起的有两个过程，一个过程用来包装单子内“任何”基本类型的值（产生单子值），另一个过程用来那些输出单子值的函数（叫做单子函数）。 单子的概念和术语二者最初都来自范畴论，这里的单子被定义为具有额外结构的函子。开始于1980年代晚期和1990年代早期的研究，确立了单子可以将看似完全不同的计算机科学问题置于一个统一的函数式模型之下。范畴论还提供了叫做单子定律的一些形式要求，任何单子都应当满足它并可以用它来验证单子代码。 通过单子，编程者可以把复杂的函数序列变成简洁的管道，它抽象出了辅助数据管理、控制流或副作用。单子可以简化范围宽广的问题，比如处理潜在（通过Maybe单子），或将值保持在一个灵活而形式正确的列表中（使用List单子）。因为单子使得某种计算的语义明确，它们还可以用来实现便捷的语言特征。一些语言比如Haskell，甚至在它们的核心库中为通用单子结构提供预制的定义和常用实例。 (zh)
- En programació funcional una mònada és un TAD sense tipus concrets, corresponent a una estructura algebraica d'un sol element (d'aquí el nom de mònada), on la finalitat de les operacions és modelar la composició i la seqüencialitat de les computacions (accions amb efectes) mitjançant l'encadenament, separant la composició temporal, de l'execució, així com incorporar el resultat de cada operació sobre l'entorn. La mònada modela una computació i pot ser vista com una acció amb efecte (un canvi), que produeix un resultat. En notació Haskell: . Les lleis de la mònada. (ca)
- Monáda je funktoriální datový typ vybavený dvěma přirozenými transformacemi umožňujícími asociativní skládání operací nad monádami. Formálně je monáda monoidem v kategorii endofunktorů v kategorii typů (v Haskellu kategorie Hask). Obecně je-li tenzorová kategorie (kde je bifunktor a ), monády jsou monoidy v . Přirozené transformace jsou u každé monády multiplikace a jednotka splňující a . Ve funkcionálním programování se tyto operace zpravidla nazývají join a unit. Příkladem monády je kontinuace, kde je funkcí z do definovaná jako aspeciální operace vázání je ,přičemž je . (cs)
- En la programación funcional , una mónada (monad en inglés), es un patrón de diseño que representa cálculos definidos como una secuencia de pasos, permitiendo componer funciones con tipos incompatibles encapsulándolos en un tipo monádico. Un tipo de dato con una estructura mónada define lo que simboliza en un bloque de código, o anida funciones del mismo tipo. Esto le permite al programador crear tuberías informáticas que procesan datos en pasos, a los cuales se les asocia un decorador con reglas de proceso adicionales provistas por la mónada. Por lo tanto, las mónadas han sido descritas como un “punto y coma programable”; un punto y coma, siendo el operador usado para unir varias declaraciones en la programación imperativa, en consecuencia la expresión implica que código extra será ejec (es)
- In functional programming, a monad is a software design pattern with a structure that combines program fragments (functions) and wraps their return values in a type with additional computation. In addition to defining a wrapping monadic type, monads define two operators: one to wrap a value in the monad type, and another to compose together functions that output values of the monad type (these are known as monadic functions). General-purpose languages use monads to reduce boilerplate code needed for common operations (such as dealing with undefined values or fallible functions, or encapsulating bookkeeping code). Functional languages use monads to turn complicated sequences of functions into succinct pipelines that abstract away control flow, and side-effects. (en)
- 関数型プログラミングにおいて、モナドはプログラムを構造化するための汎用的な抽象概念である。対応したプログラム言語では、ボイラープレート的なコードでもモナドを使って除去することが可能となる。これはモナドが、特定の形をした計算を表すデータ型と、それに関する生成と合成の2つの手続きを提供することによって実現されている。生成は任意の基本型の値をモナドに包んでモナド値を生成する手続きであり、合成はモナド値を返す関数(モナド関数)たちを合成する手続きである。 広い範囲の問題をモナドを使うことで単純化できる。例えば、Maybeモナドを使えばへの対処が簡単になり、Listモナドを使えばリストに入った値を柔軟に扱うことができる。複雑に組み合わさった関数は、モナドを使えば、補助データの管理や制御構造や副作用を除去した簡単なパイプライン構造に置き換えることができる。 モナドの概念や用語は圏論から来ている。圏論においては、モナドは追加の構造を持つ関手として定義されている。1980年代の後半に研究され始め、1990年代前半には、一見無関係な計算機科学上の問題がモナドによって統一的で関数的にモデル化できることが分かってきた。圏論はモナドの満たすべき形式的な条件を与え、これはモナド則と呼ばれている。モナド則はモナド的なコードの形式的検証にも使用可能である。 (ja)
- Nella programmazione funzionale, una monade è una struttura che esprime una classe di computazioni concatenabili. Con l'ausilio di questa struttura, è possibile compiere, anche nei linguaggi puramente funzionali, operazioni in sequenza, un po' come avviene nei linguaggi imperativi o procedurali. Infatti, possono essere espresse, con l'ausilio delle monadi, fenomeni come gli effetti collaterali, l'IO, gestione dell'eccezioni. In Haskell, la classe Monad viene espressa come segue: (it)
- Monada – w programowaniu funkcyjnym: rodzaj abstrakcyjnego typu danych, który implementuje funkcje wiązania (ang. bind) oraz jednostki (ang. unit). Pojęcie to wywodzi się z teorii kategorii, gdzie omawiany abstrakt stanowi monadę nad kategorią typów z funkcjami jako morfizmami. Jednostka określa operację tworzenia singletonu czy też akcji, której wynikiem jest zadana wartość. Wiązanie (w niektórych językach określane jako flat map) buduje na podstawie wyniku poprzedniego obliczenia nowe obliczenie, zachowując przy tym jego formę. oraz wiązanie jako (pl)
- Мона́да — особый тип данных в функциональных языках программирования, для которого возможно задать императивную последовательность выполнения некоторых операций над хранимыми значениями. Монады позволяют задавать последовательность выполнения операций, производить операции с побочными эффектами и другие действия, которые сложно или вовсе невозможно реализовать в функциональной парадигме программирования другими способами. (ru)
- Деякі із функційних мов програмування[які?] використовують монади для структурування програм, що містять операції, що мають виконуватись в певному порядку. Назва походить із теорії категорій, розділу математики, що описує шаблони, які можуть бути застосовані до різних розділів математики. Функційна мова програмування Гаскель інтенсивно використовує монади та має синтаксичні конструкції для полегшення роботи з ними. (uk)
|
