Debe un lenguaje que implementa Mónadas ser de tipo estático?

https://stackoverflow.com/questions/394709

23-08-2019
|

Pregunta

Estoy aprendiendo el estilo de programación funcional. En no temas a la Mónadas , Brian Beckman dio una brillante introducción sobre Mónada. Mencionó que Mónada se trata de la composición de funciones con el fin de abordar la complejidad.

A Mónada incluye una función unit que transfiere tipo T a un tipo amplificado M (T); y una función de vinculación que, función dada de T a M (U), transforma tipo M (T) a otro tipo M (U). (U puede ser T, pero no es necesariamente).

A mi entender, el lenguaje de implementación mónada debe ser de tipo comprobado estáticamente. De lo contrario, los errores de tipo no se pueden encontrar durante la compilación y "Complejidad" no es controlado. ¿Es correcta mi entendimiento?

Solución

Hay muchas implementaciones de mónadas en lenguajes de tipado dinámico:

En general, el de Church-Turing-Tesis nos dice que todo lo que se puede hacer en un lenguaje también se puede hacer en todos los demás idioma.

Como seguramente se puede decir de la selección de los ejemplos anteriores, estoy (en su mayoría) un programador Ruby. Por lo tanto, al igual que una broma, tomé uno de los ejemplos anteriores y re-implementado en un lenguaje que yo sepa absolutamente nada sobre, lo que se suele considerar como un lenguaje no muy potente, y que parece ser el único lenguaje de programación en el planeta por lo que no era capaz de encontrar un tutorial Mónada. Les presento a usted ... la identidad Mónada 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);
  }
));
?>

No hay tipos estáticos, no hay genéricos, no hay dispositivos de cierre necesarias.

Ahora, si realmente se quiere comprobar estáticamente mónadas, entonces usted necesita un sistema de tipo estático. Pero eso es más o menos una tautología: si desea comprobar estáticamente tipos, necesita un tipo de electricidad estática. Duh.

Con respecto a su pregunta:

A mi entender, el lenguaje de implementación mónada debe ser de tipo comprobado estáticamente. De lo contrario, los errores de tipo no se pueden encontrar durante la compilación y "Complejidad" no es controlado. ¿Es correcta mi entendimiento?

Tiene usted razón, pero esto no tiene nada que ver con las mónadas. Esto es sólo acerca de la comprobación de tipos estáticos en general, y se aplica igualmente bien a las matrices, listas de números enteros o incluso simplemente aburrido.

También hay una pista falsa aquí: si nos fijamos, por ejemplo, en las implementaciones monad en C #, Java o C, que son mucho más largos y mucho más complejo que, por ejemplo, el ejemplo PHP anteriormente. En particular, hay toneladas de tipos en todas partes, lo que sin duda ve impresionante. Pero la cruda realidad es: C # 's, de los sistemas de tipo C de Java y en realidad no son lo suficientemente potente como para expresar el tipo de Monad. En particular, Monad es un tipo polimórfico rango-2, pero C # y Java sólo admiten rango-1 Polymorfismo (lo llaman "genéricos", pero es la misma cosa) y C no soporta siquiera eso.

Por lo tanto, las mónadas son, de hecho, no estáticamente escribir a cuadros en C #, Java y C (Eso es, por ejemplo, la razón por la cual las comprensiones monad LINQ se definen como un patrón y no como un tipo: ya que simplemente no puede expresar del tipo en C #.) Todo el sistema de tipo estático hace, es hacer que la aplicación mucho más complejo, sin llegar a ayudar. Se requiere un sistema de tipo mucho más sofisticados, como Haskell, para obtener real seguridad de tipos de mónadas.

Nota: lo que he escrito anteriormente solamente se aplica al mismo tipo monad genérico, como @Porges señala. Por supuesto que puede expresar el tipo de cualquier específica mónada, como List o Maybe, pero no se puede expresar el tipo de Monad sí. Y esto significa que no se puede escribir a comprobar el hecho de que "List ES-A Monad", y no se puede escribir a comprobar las operaciones genéricas que funcionan en todas las instancias de Monad.

(Tenga en cuenta que la comprobación de que Monad también obedece a las mónada leyes , además de conforme a la mónada type es probablemente demasiado incluso para el sistema de tipos de Haskell. Usted probablemente necesitará tipos dependientes y tal vez incluso un demostrador de teoremas automática en toda regla para eso.)

Otros consejos

No es ciertamente el caso de que un lenguaje de implementación de mónadas debe ser estático de tipos, como el título de su pregunta se refiere. Puede ser una buena idea, por las razones que esquema, pero los errores en su defecto para ser detectados en tiempo de compilación no ha dejado a nadie. Basta con mirar a cuántas personas escriben en PHP.

Es necesario el cierre de la mónada Estado. Lo busqué, PHP tiene cierres desde 5.3. Por lo que no sería un problema.

No, en php que no es posible llevar a cabo las mónadas. Es necesario para que los cierres. Nunca menos, el concepto de lo mejor puede ser todavía útil, cuando se simula la coincidencia de patrones con las clases:

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());

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow