Une langue doit implémentant Monades être statiquement typé?

StackOverflow https://stackoverflow.com/questions/394709

Question

Je suis le style d'apprentissage de la programmation fonctionnelle. Ne craignez pas les monades , Brian Beckman a donné une brillante introduction sur Monad. Il a mentionné que Monad est sur la composition des fonctions de manière à répondre à la complexité.

  

A Monade comprend une fonction de unit qui transfère type T à un M de type amplifié (T); et une fonction de Bind que, compte tenu de la fonction de T à M (U), transforme le type M (T) à un autre type M (U). (U peut être T, mais pas nécessairement).

Dans ma compréhension, la langue mise en œuvre monade doit être vérifié type statique. Dans le cas contraire, les erreurs de type ne peuvent pas être trouvées lors de la compilation et la « complexité » ne sont pas contrôlées. Est-ce que je comprends bien?

Était-ce utile?

La solution

Il y a beaucoup de mises en œuvre de monades dans les langues dynamiquement typés:

En général, l'Eglise-Turing-thèse nous dit que tout ce qui peut être fait dans un langue peut également être fait dans tous les langue.

Comme vous pouvez probablement dire de la sélection des exemples ci-dessus, je suis (la plupart du temps) un programmeur Ruby. Alors, comme une blague, je pris l'un des exemples ci-dessus et il réimplémenté dans une langue que je connais absolument rien à propos, ce qui est généralement considéré comme un langage pas très puissant, et que semble être la seule langue de programmation sur la planète pour laquelle je ne pouvais pas trouver un tutoriel Monad. Puis-je vous présenter ... la Monade Identity en PHP: 

<?php
class Identity {
  protected $val;
  public function __construct($val) { $this->val = $val; }
  public static function m_return($a) { return new Identity($a); }
  public static function m_bind($id_a, $f) { return $f($id_a->val); }
}

var_dump(Identity::m_bind(
  Identity::m_return(1), function ($x) {
    return Identity::m_return($x+1);
  }
));
?>

Aucun type statique, pas de médicaments génériques, pas de fermeture nécessaire.

Maintenant, si vous voulez vraiment vérifier statiquement monades, alors vous avez besoin d'un système de type statique. Mais cela est plus ou moins une tautologie: si vous voulez vérifier statiquement types, vous avez besoin d'un vérificateur de type statique. Duh.

En ce qui concerne votre question:

  

Dans ma compréhension, la langue mise en œuvre monade doit être vérifié type statique. Dans le cas contraire, les erreurs de type ne peuvent pas être trouvées lors de la compilation et la « complexité » ne sont pas contrôlées. Est-ce que je comprends bien?

Vous avez raison, mais cela n'a rien à voir avec monades. Ceci est juste au sujet de la vérification de type statique en général, et applique aussi bien à des tableaux, des listes ou même des entiers ennuyeux plaine.

Il y a aussi un hareng saur ici: si vous regardez par exemple à des implémentations monade en C #, Java ou C, ils sont beaucoup plus et beaucoup plus complexe que, par exemple, l'exemple ci-dessus PHP. En particulier, il y a tonnes des types partout, donc il a certainement regarde impressionnant. Mais la vérité est laide: C # 's, les systèmes de Java et le type de C ne sont pas en fait assez puissant pour exprimer le type de Monad. En particulier, Monad est un rang 2 de type polymorphes, mais C # et Java ne supporte que Polym rang 1orphisme (ils l'appellent « génériques », mais c'est la même chose) et C ne fonctionne même pas.

Alors, monades sont en fait pas de type vérifié statiquement en C #, Java et C. (C'est par exemple la raison pour laquelle les compréhensions monade LINQ sont définis comme un modèle et non pas comme un type: parce que vous ne pouvez pas exprimer le type en C #.) Tout le système de type statique ne, est de rendre la mise en œuvre beaucoup plus complexe, sans réellement aider. Il a besoin d'un système de type beaucoup plus sophistiqués tels que Haskell de, pour obtenir type sécurité réelle pour monades.

Note: ce que je l'ai écrit ci-dessus que applique le type de monad générique lui-même, comme @Porges souligne. Vous pouvez certainement exprimer le type d'une spécifique monade, comme List ou Maybe, mais vous ne pouvez pas exprimer le type de Monad lui-même. Et cela signifie que vous ne pouvez pas saisir vérifier le fait que « List IS-A Monad », et vous ne pouvez pas saisir vérifier les opérations génériques qui fonctionnent sur toutes les instances de Monad.

(Notez que la vérification que Monad obéit aussi aux monade lois , en plus de se conformer à la monade type est sans doute trop même pour le système de type de Haskell. Vous auriez probablement besoin types dépendants et peut-être même un théorème automatique complet prouveur pour cela.)

Autres conseils

Il est certainement pas le cas qu'une langue mise en œuvre monades doit statiquement typé, comme le titre de votre question demande. Il peut être une bonne idée, pour les raisons que vous les grandes lignes, mais des erreurs défaut à détecter au moment de la compilation n'a jamais cessé de personne. Il suffit de regarder combien de gens écrivent PHP.

Vous avez besoin de fermeture pour la monade de l'Etat. Je l'ai cherché, PHP a fermetures depuis 5.3. Donc, ce ne serait pas un problème.

Non, en php, il est impossible de mettre en œuvre monades. Vous avez besoin de fermeture pour cela. Jamais le moins, le concept de Peut-être peut être encore utile, lorsque vous simulez modèle correspondant à des classes: 

abstract class Maybe {
        abstract public function isJust();
        public function isNothing(){
                return !$this->isJust();
        }
}

class Just extends Maybe {
        protected $val = null;
        public function __construct($val){
                $this->val = $val;

        }
        public function isJust(){
                return true;
        }
        public function getVal(){
                return $this->val;
        }

}
class Nothing extends Maybe {
        protected $val = null;
        public function __construct(){

        }
        public function isJust(){
                return false;
        }
}

function just(){
        print "isJust";
}
function nothing(){
        print "nothing";
}
function MaybeFunc(Maybe $arg){
        if(get_class($arg) == 'Just'){
                print "Just";
        } else {
                print "Nothing";
        }
}

MaybeFunc(new Just(5));
MaybeFunc(new Nothing());
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top