Deve una lingua che implementa Monadi essere tipi statici?

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

Domanda

Sto imparando stile di programmazione funzionale. In non temono il Monadi , Brian Beckman ha dato una brillante introduzione su Monade. Egli ha detto che Monade è circa la composizione di funzioni in modo da affrontare la complessità.

  

Un Monade include una funzione unit che trasferisce tipo T a un tipo amplificato M (T); e una funzione Bind che, funzione data da T a M (U), trasforma tipo M (T) ad un altro tipo M (U). (U può essere T, ma non è necessariamente).

Nella mia comprensione, la lingua attuazione monade dovrebbe essere di tipo controllato staticamente. In caso contrario, gli errori di tipo non possono essere trovati durante la compilazione e la "complessità" non è controllato. È la mia comprensione corretta?

È stato utile?

Soluzione

Ci sono un sacco di implementazioni di monadi in lingue dinamicamente tipizzati:

In generale, la Church-Turing-Tesi ci dice che tutto ciò che può essere fatto in una lingua può anche essere fatto in ogni altro lingua.

Come si può probabilmente dire dalla selezione di esempi di cui sopra, io sono (soprattutto) un programmatore Ruby. Così, proprio come uno scherzo, ho preso uno degli esempi di cui sopra e ri-implementato in una lingua che conosco assolutamente nulla su, che di solito è pensato come una lingua non molto potente, e che sembra essere l'unico linguaggio di programmazione del pianeta per il quale non ero in grado di trovare un tutorial Monade. Posso presentarvi ... Monade identità in 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);
  }
));
?>

Non ci sono tipi statici, non generici, senza chiusure necessarie.

Ora, se si vuole realmente controllare staticamente monadi, allora avete bisogno di un sistema di tipo statico. Ma questo è più o meno una tautologia: se si desidera controllare staticamente tipi, è necessario un tipo di controllo statico. Duh.

Per quanto riguarda la tua domanda:

  

Nella mia comprensione, la lingua attuazione monade dovrebbe essere di tipo controllato staticamente. In caso contrario, gli errori di tipo non possono essere trovati durante la compilazione e la "complessità" non è controllato. È la mia comprensione corretta?

Hai ragione, ma questo non ha nulla a che fare con monadi. Questo è solo di controllo di tipo statico, in generale, e si applica altrettanto bene a array, liste o interi addirittura noioso.

C'è anche una falsa pista qui: se si guarda per esempio a implementazioni monade in C #, Java o C, sono molto più lungo e molto più complesso rispetto, ad esempio, l'esempio PHP sopra. In particolare, c'è tonnellate di tipi in tutto il mondo, quindi è certamente Look impressionante. Ma la brutta verità è: C # 's, non sono sistemi di tipo di C di Java e in realtà abbastanza potente per esprimere il tipo di Monad. In particolare, Monad è un tipo polimorfico rango-2, ma C # e Java supportano solo rango-1 Polymorfismo (lo chiamano "generici", ma è la stessa cosa) e C non supporta anche questo.

Quindi, monadi sono infatti non staticamente digitare-check-in C #, Java e C. (Questo è per esempio il motivo per cui le comprensioni monade LINQ sono definiti come un modello e non come un tipo: perché semplicemente non può esprimere tipo in C #.) Tutto il sistema di tipo statico fa, è rendere obbligatoria l'applicazione molto più complessa, senza realmente aiutare. È richiesto un sistema di tipo molto più sofisticato, come Haskell di, per ottenere attuale tipo di sicurezza per monadi.

Nota: quello che ho scritto sopra solo vale per il tipo monad generica sé, come @Porges sottolinea. Si può certamente esprimere il tipo di qualsiasi specifica monade, come List o Maybe, ma non si può esprimere il tipo di Monad stessa. E questo significa che non si può digitare controllare il fatto che "List IS-A Monad", e non si può digitare controllare operazioni generiche che lavorano su tutte le istanze di Monad.

(Si noti che il controllo che Monad obbedisce anche la monade leggi , oltre a conformarsi alla monade tipo è probabilmente troppo anche per il sistema di tipo di Haskell. Si sarebbe probabilmente bisogno di tipi dipendenti e forse anche un dimostratore di teoremi automatica piena regola per farlo.)

Altri suggerimenti

Non è certamente il caso che una lingua monadi attuazione deve essere tipizzato staticamente, come il titolo questione si chiede. Può essere una buona idea, per le ragioni che si delineano, ma gli errori non riuscendo a essere rilevato al momento della compilazione non ha mai smesso di nessuno. Basta guardare quante persone scrivono PHP.

È necessario chiusure per la monade Stato. Ho guardato in su, PHP ha chiusure dal 5.3. In modo che non sarebbe più un problema.

No, in PHP non è possibile implementare monadi. Avete bisogno di chiusure per questo. Non di meno, il concetto di forse può ancora essere utile, quando si simulare pattern matching con le classi: 

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());
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top