What is "monadic reflection"?

Wha开发者_StackOverflow中文版t is "monadic reflection"?

How can I use it in F#-program?

Is the meaning of term "reflection" there same as .NET-reflection?

---

Monadic reflection is essentially a grammar for describing layered monads or monad layering. In Haskell describing also means constructing monads. This is a higher level system so the code looks like functional but the result is monad composition - meaning that without actual monads (which are non-functional) there's nothing real / runnable at the end of the day. Filinski did it originally to try to bring a kind of monad emulation to Scheme but much more to explore theoretical aspects of monads.

Correction from the comment - F# has a Monad equivalent named "Computation Expressions"

Filinski's paper at POPL 2010 - no code but a lot of theory, and of course his original paper from 1994 - Representing Monads. Plus one that has some code: Monad Transformers and Modular Interpreters (1995)

Oh and for people who like code - Filinski's code is on-line. I'll list just one - go one step up and see another 7 and readme. Also just a bit of F# code which claims to be inspired by Filinski

---

I read through the first Google hit, some slides:

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

From this, it looks like

1. This is not the same as .NET reflection. The name seems to refer to turning data into code (and vice-versa, with reification).
2. The code uses standard pure-functional operations, so implementation should be easy in F#. (once you understand it)
3. I have no idea if this would be useful for implementing an immutable cache for a recursive function. It look like you can define mutable operations and convert them to equivalent immutable operations automatically? I don't really understand the slides.

Oleg Kiselyov also has an article, but I didn't even try to read it. There's also a paper from Jonathan Sobel (et al). Hit number 5 is this question, so I stopped looking after that.

---

As previous answers links describes, Monadic reflection is a concept to bridge call/cc style and Church style programming. To describe these two concepts some more:

F# Computation expressions (=monads) are created with custom Builder type.

Don Syme has a good blog post about this. If I write code to use a builder and use syntax like:

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

the syntax is translated to call/cc "call-with-current-continuation" style program:

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

The last parameter is the next-command-to-be-executed until the end.

(Scheme-style programming.)

---

F# is based on OCaml.

F# has partial function application, but it also is strongly typed and has value restriction.
But OCaml don't have value restriction.

OCaml can be used in Church kind of programming, where combinator-functions are used to construct any other functions (or programs):

// 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 is a way to represent numbers with pure functions.

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)

Here, zero is a function that takes two functions as parameters: f is applied zero times so this represent the number zero, and x is used to function combination in other calculations (like add). succ function is like plusOne so one = zero |> plusOne.

To execute the functions, the last function will call the other functions with last parameter (x) as null.

(Haskell-style programming.)

In F# value restriction makes this hard. Church numerals can be made with C# 4.0 dynamic keyword (which uses .NET reflection inside). I think there are workarounds to do that also in F#.