O que são mônadas gratuitas?

Eu vi o termo gratuito Mônada pop up a cada agora e , em seguida, por algum tempo, mas todo mundo só parece usar / discuti-los sem dar uma explicação sobre o que são. Então: o que são mônadas gratuitas? (Eu diria que estou familiarizado com as mônadas e os conceitos básicos de Haskell, mas tenho apenas um conhecimento muito rudimentar da teoria das categorias.)

A resposta de Edward Kmett é obviamente ótima. Mas, é um pouco técnico. Aqui está uma explicação talvez mais acessível.

Mônadas livres são apenas uma maneira geral de transformar functores em mônadas. Ou seja, dado que qualquer functor f Free fé uma mônada. Isso não seria muito útil, exceto se você obtiver um par de funções

liftFree :: Functor f => f a -> Free f a
foldFree :: Functor f => (f r -> r) -> Free f r -> r

o primeiro deles permite que você "entre" em sua mônada, e o segundo fornece uma maneira de "sair" dela.

De maneira mais geral, se X é um Y com algumas coisas extras P, então um "X livre" é uma maneira de passar de um Y para um X sem ganhar nada extra.

Exemplos: um monóide (X) é um conjunto (Y) com estrutura extra (P) que basicamente diz que possui uma operação (você pode pensar em adição) e alguma identidade (como zero).

assim

class Monoid m where
   mempty  :: m
   mappend :: m -> m -> m

Agora, todos nós sabemos listas

data [a] = [] | a : [a]

Bem, dado qualquer tipo t, sabemos que [t]é um monóide

instance Monoid [t] where
  mempty   = []
  mappend = (++)

e assim as listas são o "monóide livre" sobre os conjuntos (ou nos tipos Haskell).

Ok, então mônadas gratuitas são a mesma ideia. Pegamos um functor e devolvemos uma mônada. De fato, como as mônadas podem ser vistas como monóides na categoria de endofunitores, a definição de uma lista

data [a] = [] | a : [a]

parece muito com a definição de mônadas livres

data Free f a = Pure a | Roll (f (Free f a))

e a Monadinstância tem uma semelhança com a Monoidinstância para listas

--it needs to be a functor
instance Functor f => Functor (Free f) where
  fmap f (Pure a) = Pure (f a)
  fmap f (Roll x) = Roll (fmap (fmap f) x)

--this is the same thing as (++) basically
concatFree :: Functor f => Free f (Free f a) -> Free f a
concatFree (Pure x) = x
concatFree (Roll y) = Roll (fmap concatFree y)

instance Functor f => Monad (Free f) where
  return = Pure -- just like []
  x >>= f = concatFree (fmap f x)  --this is the standard concatMap definition of bind

agora, temos nossas duas operações

-- this is essentially the same as \x -> [x]
liftFree :: Functor f => f a -> Free f a
liftFree x = Roll (fmap Pure x)

-- this is essentially the same as folding a list
foldFree :: Functor f => (f r -> r) -> Free f r -> r
foldFree _ (Pure a) = a
foldFree f (Roll x) = f (fmap (foldFree f) x)

Aqui está uma resposta ainda mais simples: Uma Mônada é algo que "calcula" quando o contexto monádico é recolhido join :: m (m a) -> m a(lembrando que >>=pode ser definido como x >>= y = join (fmap y x)). É assim que as Mônadas carregam o contexto através de uma cadeia seqüencial de cálculos: porque em cada ponto da série, o contexto da chamada anterior é recolhido com o próximo.

Uma mônada livre satisfaz todas as leis da Mônada, mas não entra em colapso (isto é, computação). Ele apenas cria uma série aninhada de contextos. O usuário que cria um valor monádico gratuito é responsável por fazer algo com esses contextos aninhados, para que o significado de uma composição possa ser adiado até depois que o valor monádico for criado.

Um foo livre passa a ser a coisa mais simples que satisfaz todas as leis 'foo'. Isto é, satisfaz exatamente as leis necessárias para ser um foo e nada extra.

Um functor esquecido é aquele que "esquece" parte da estrutura à medida que passa de uma categoria para outra.

Dado functors F : D -> C, e G : C -> D, dizemos F -| G, Fé deixado adjacente a G, ou Gé adjacente a todo momento em Fque todos a, b: F a -> bé isomórfico para a -> G b, onde as setas vêm das categorias apropriadas.

Formalmente, um functor livre fica adjacente a um functor esquecido.

O Monóide Livre

Vamos começar com um exemplo mais simples, o monóide livre.

Dê uma monoid, que é definida por um conjunto transportador T, uma função binário para esmagar um par de elementos juntos f :: T → T → T, e uma unit :: T, de modo que você tem uma lei associativa, e uma lei de identidade: f(unit,x) = x = f(x,unit).

Você pode fazer um functor Uda categoria de monoids (onde flechas são homomorphisms monoid, isto é, garantir que eles mapear unita unitdo outro monoid, e que você pode compor antes ou após o mapeamento para o outro monoid sem alterar o significado) à categoria de conjuntos (onde as setas são apenas setas funcionais) que 'esquecem' da operação e unit, e apenas fornecem o conjunto da transportadora.

Em seguida, você pode definir um functor Fda categoria de conjuntos para a categoria de monoides que fica adjacente a esse functor. Esse functor é o functor que mapeia um conjunto apara o monóide [a], onde unit = [], e mappend = (++).

Então, para revisar nosso exemplo até agora, em pseudo-Haskell:

U : Mon → Set -- is our forgetful functor
U (a,mappend,mempty) = a

F : Set → Mon -- is our free functor
F a = ([a],(++),[])

Então, para mostrar Fé gratuito, precisamos demonstrar que ele fica adjacente a Uum functor esquecido, ou seja, como mencionamos acima, precisamos mostrar que

F a → b é isomórfico para a → U b

Agora, lembre-se de que o alvo de Festá na categoria Monde monóides, onde as setas são homomorfismos monóides; portanto, precisamos mostrar que um homomorfismo monóide de [a] → bpode ser descrito precisamente por uma função de a → b.

Em Haskell, chamamos o lado disso que vive em Set(er, Haska categoria de tipos de Haskell que pretendemos ser Set), just foldMap, que quando especializada de Data.Foldablepara Lists tem tipo Monoid m => (a → m) → [a] → m.

Há conseqüências que se seguem, sendo uma adjunção. Notavelmente, se você esquecer, construa gratuitamente, e esqueça novamente, é como você esqueceu uma vez, e podemos usar isso para criar a junção monádica. desde UFUF~ U(FUF)~ UF, e podemos passar o homomorfismo monóide de identidade de [a]para [a]o isomorfismo que define nossa adjunção, entender que um isomorfismo de lista [a] → [a]é uma função do tipo a -> [a], e isso é apenas um retorno para listas.

Você pode compor tudo isso mais diretamente, descrevendo uma lista nestes termos com:

newtype List a = List (forall b. Monoid b => (a -> b) -> b)

The Free Monad

Então, o que é uma Mônada Livre ?

Bem, fazemos o mesmo que fizemos antes, começamos com um esquecido functor U da categoria de mônadas, onde as flechas são mônadas homomorfismos, até uma categoria de endofuncionadores, onde as flechas são transformações naturais, e procuramos um functor que fica ao lado para isso.

Então, como isso se relaciona com a noção de mônada livre, como costuma ser usada?

Saber que algo é uma mônada livre Free f, diz a você que fornecer uma homônima de mônada Free f -> mé a mesma coisa (isomórfica a) que fornecer uma transformação natural (de um homomorfismo de functor) f -> m. Lembre-se de que F a -> bdeve ser isomórfico para a -> U bque F seja deixado adjacente a U. U aqui mapeou mônadas para functores.

F é pelo menos isomorfo ao Freetipo que eu uso no meu freepacote sobre hackage.

Também podemos construí-lo em analogia mais rigorosa ao código acima para a lista livre, definindo

class Algebra f x where
  phi :: f x -> x

newtype Free f a = Free (forall x. Algebra f x => (a -> x) -> x)

Comonadas Cofree

Podemos construir algo semelhante, observando o anexo correto de um functor esquecido, assumindo que ele existe. Um functor co-livre é simplesmente / diretamente adjunto / a um functor esquecido e, por simetria, saber que algo é uma comonada livre é o mesmo que saber que dar homomorfismo a uma comonada w -> Cofree fé o mesmo que dar uma transformação natural w -> f.

A Mônada Livre (estrutura de dados) é para a Mônada (classe) como a Lista (estrutura de dados) para a Monóide (classe): é a implementação trivial, onde você pode decidir depois como o conteúdo será combinado.

Você provavelmente sabe o que é uma Mônada e que cada Mônada precisa de uma implementação específica (cumprindo a lei) de fmap+ join+ returnou bind+ return.

Vamos supor que você tenha um Functor (uma implementação de fmap), mas o restante depende dos valores e escolhas feitos no tempo de execução, o que significa que você deseja poder usar as propriedades da Mônada, mas depois escolher as funções da Mônada.

Isso pode ser feito usando a Mônada Livre (estrutura de dados), que agrupa o Functor (tipo) de tal maneira que joinseja mais um empilhamento desses functores do que uma redução.

O real returne joinvocê deseja usar agora podem ser dados como parâmetros para a função de redução foldFree:

foldFree :: Functor f => (a -> b) -> (f b -> b) -> Free f a -> b
foldFree return join :: Monad m => Free m a -> m a

Para explicar os tipos, podemos substituir Functor fpor Monad me bpor (m a):

foldFree :: Monad m => (a -> (m a)) -> (m (m a) -> (m a)) -> Free m a -> (m a)

Uma mônada livre de Haskell é uma lista de functores. Comparar:

data List a   = Nil    | Cons  a (List a  )

data Free f r = Pure r | Free (f (Free f r))

Pureé análogo Nile Freeé análogo a Cons. Uma mônada livre armazena uma lista de functores em vez de uma lista de valores. Tecnicamente, você pode implementar mônadas gratuitas usando um tipo de dados diferente, mas qualquer implementação deve ser isomórfica à mencionada acima.

Você usa mônadas gratuitas sempre que precisar de uma árvore de sintaxe abstrata. O functor base da mônada livre é o formato de cada etapa da árvore de sintaxe.

Meu post , que alguém já vinculou, fornece vários exemplos de como criar árvores de sintaxe abstrata com mônadas gratuitas

Eu acho que um exemplo concreto simples ajudará. Suponha que tenhamos um functor

data F a = One a | Two a a | Two' a a | Three Int a a a

com o óbvio fmap. Então Free F aé o tipo de árvores cujas folhas têm tipo ae cujos nós são marcados com One, Two, Two'e Three. One-nodes têm um filho, Two- e Two'-nodes têm dois filhos e Three-nodes têm três e também são marcados com um Int.

Free Fé uma mônada. returnmapeia xpara a árvore que é apenas uma folha com valor x. t >>= folha para cada uma das folhas e as substitui por árvores. Quando a folha tem valor, yela substitui a folha pela árvore f y.

Um diagrama torna isso mais claro, mas eu não tenho as facilidades para desenhar facilmente um!