Comment puis-je créer deux producteurs / consommateurs mutuels avec l'état interne à Haskell?

Question

J'ai un agent qui prend dans les actions des États et des retours, tout en gardant une représentation interne de l'utilité des paires d'état / d'action. J'ai aussi un environnement qui prend en actions et retourne paires Etat / récompense.

Je dois être en mesure de mettre l'agent avec un état de départ puis passez en continu de l'agent - (action) -> Environnement - (Etat, récompense) -> Agent - (action) -> ... Cependant, les états internes (qui doivent être mis à jour chaque itération) doivent rester privées (soit, au sein de l'agent ou de l'environnement). Cela signifie que je ne peux pas appeler simplement l'environnement en fonction au sein de l'agent en utilisant l'état et de l'action comme arguments.

Je suis un peu d'un noobie Haskell, donc je ne suis même pas sûr si cela est possible.

Answer 1

Deux questions:

• Si l'agent doit utiliser un état pour calculer une action, alors comment voulez-vous garder la représentation des Etats secrets de l'agent?

• Si l'environnement prévoit de produire un état (et une récompense) donnée une action, comment comptez-vous garder la représentation des Etats secrets de l'environnement?

Les deux sont possibles, mais chacun doit impliquer une sorte d'abstraction pour créer ou tester les états états. Je n'ai pas un bon sentiment au sujet de cette conception.

Il serait utile de clarifier la question par

• Fournir des signatures de type pour les fonctions d'intérêt

• L'identification à laquelle vous voulez fonctions de la représentation des états pas à exposer.

P.S. Ces difficultés sont tout à fait séparables de Haskell et seraient en cause quel que soit le choix de la langue de mise en œuvre (à condition que les supports linguistiques de mise en œuvre certains forme de la vie privée).

Answer 2

Vous devez décider quel de l'agent et de l'environnement se trouve « sur le dessus. » - supposons que pour le reste de cette réponse qu'il est l'environnement sur l'appel dans l'agent depuis qui fait généralement plus de sens

Vous pouvez conserver des représentations de données de l'agent privé en utilisant le système de modules - simplement exporter le nom de type de données sans qu'aucun de ses internes.

module Agent (AgentState, other_stuff) where

opposd à

module Agent (AgentState(..), other_stuff) where

Si l'agent doit également être passé de l'état de l'environnement (bien que je ne vois aucune raison pour cela serait nécessaire que l'environnement peut garder la trace de celui-ci pour lui-même), puis faire l'agent fonctionne polymorphes afin qu'ils puissent être passé any type d'état -. alors l'environnement peut passer ce qu'il veut dans sa représentation sans être exposé

Il devrait également être possible d'utiliser monades État pour obtenir plus de contrôle sur ce qui se passe à l'état, par exemple la prévention de l'environnement de la duplication d'un état de l'agent qu'il donne et appeler l'agent à plusieurs reprises avec ce même état, mais si vous débutez Haskell il est probablement préférable d'obtenir un peu d'expérience sans monades premier. (Pas que les monades sont particulièrement effrayant ou quoi que ce soit, mais ils détail vous cacherai donc il est plus difficile de voir ce qui se passe.)