Che cos'è la "riflessione monadica"?

Question

Che cos'è la "riflessione monadica"?

Come posso utilizzarlo nel programma F #?

Il significato del termine "riflessione" è lo stesso di .NET-reflection?

Answer 1

ho letto attraverso il primo colpo di Google, alcune diapositive:

http://www.cs.ioc.ee/mpc-amast06/msfp/filinski-slides.pdf

Da questo, sembra che

1. Questo non è lo stesso di riflessione .NET. Il nome sembra riferirsi alla trasformazione dei dati in codice (e viceversa, con reificazione).
2. Il codice utilizza operazioni puramente funzionali standard, quindi l'implementazione dovrebbe essere semplice in F #. (una volta compreso)
3. Non ho idea se ciò sia utile per l'implementazione di una cache immutabile per una funzione ricorsiva. Sembra che tu possa definire operazioni mutevoli e convertirle automaticamente in operazioni immutabili equivalenti? Non capisco davvero le diapositive.

Oleg Kiselyov ha anche an article, ma non ho nemmeno provato a leggerlo. C'è anche un documento da Jonathan Sobel (et al). L'hit numero 5 è questa domanda, quindi ho smesso di occuparmene.

Answer 2

La riflessione monadica è essenzialmente una grammatica per descrivere le monadi con livelli o la stratificazione di monade. Descrivere Haskell significa anche costruire monadi. Questo è un sistema di livello più alto, quindi il codice sembra funzionale ma il risultato è la composizione monad - il che significa che senza le monadi reali (che non sono funzionali) non c'è niente di reale/eseguibile alla fine della giornata. Filinski lo fece originariamente per provare a portare una specie di emulazione di monade a Scheme ma molto più per esplorare aspetti teorici delle monadi.

correzione dal commento - F # ha una Monade equivalente di nome "Computation Expressions"

Filinski's paper at POPL 2010 - nessun codice, ma un sacco di teoria, e, naturalmente, la sua carta originale 1994-Representing Monads. Più uno che ha qualche codice: Monad Transformers and Modular Interpreters (1995)

Oh e per le persone a cui piace il codice - Filinski's code è on-line. Ne elencherò solo uno: andiamo un passo avanti e ne vediamo un altro 7 e leggimi. Anche solo a bit of F# code che afferma di essere ispirato da Filinski

Answer 3

Come le risposte precedenti descrive descrive, Monadic reflection è un concetto di bridge call/cc style and Church style programming. Per descrivere ulteriormente questi due concetti:

F# Computation expressions (= monadi) creati con il tipo di Generatore personalizzato.

Don Syme ha un buon blog post about this. Se scrivo codice per utilizzare un costruttore e utilizzare la sintassi del tipo:

attempt { let! n1 = f inp1 
      let! n2 = failIfBig inp2 
      let sum = n1 + n2 
      return sum } 

la sintassi è tradotto da programmare call/cc "call-with-current-continuation" stile:

attempt.Delay(fun() -> 
    attempt.Bind(f inp1,(fun n1 -> 
    attempt.Bind(f inp2,(fun n2 -> 
     attempt.Let(n1 + n2,(fun sum -> 
     attempt.Return(sum)))))))) 

L'ultimo parametro è il prossimo comando-a-essere-eseguita fino alla fine.

(programmazione in stile Scheme.)

---

F # è basata su OCaml.

F # ha un'applicazione di funzione parziale, ma è anche fortemente digitato e presenta una restrizione di valore.
Ma OCaml non ha limitazioni di valore.

OCaml può essere utilizzato in Chiesa tipo di programmazione, in cui sono utilizzati combinator funzioni di costruire qualsiasi altre funzioni (o programmi):

// S K I combinators: 
let I x = x 
let K x y = x 
let S x y z = x z (y z) 

//examples: 
let seven = S (K) (K) 7 
let doubleI = I I //Won't work in F# 
// y-combinator to make recursion 
let Y = S (K (S I I)) (S (S (K S) K) (K (S I I))) 

Church numerals è un modo per rappresentare i numeri con funzioni pure.

let zero f x = x 
//same as: let zero = fun f -> fun x -> x 
let succ n f x = f (n f x) 
let one = succ zero 
let two = succ (succ zero) 
let add n1 n2 f x = n1 f (n2 f x) 
let multiply n1 n2 f = n2(n1(f)) 
let exp n1 n2 = n2(n1) 

Qui, zero è una funzione che prende due funzioni come parametri: f è applicato zero volte quindi questo rappresenta il numero zero, ed x è usato per funzionare in combinazione altri calcoli (come add). la funzione succ è come plusOne quindi one = zero |> plusOne.

Per eseguire le funzioni, l'ultima funzione chiamerà le altre funzioni con l'ultimo parametro (x) come null.

(programmazione in stile Haskell.)

In F # restrizione valore rende questo duro. Church numerals can be made with C# 4.0 dynamic keyword (che utilizza la riflessione .NET all'interno). Penso che ci siano soluzioni alternative per farlo anche in F #.