A little esoteric os

open System

(* Petrovich provides two methods of influencing its behaviour: rewards and punishments. 
Whenever Petrovich does something the user doesn't approve of, the user can punish it. 
Conversely, whenever Petrovich does something useful, the user can reward it. 
Petrovich then adapts its behaviour to avoid punishment and enjoy more rewards. *)
type Action = 
    | DoSmth                    //Causes Petrovich to do something. 
    | DoSmthWithFile of string  //Causes Petrovich to do something using the named file. 
    | Punish                    //Punishes Petrovich. 
    | Reward                    //Rewards Petrovich. 
    | Exit                      

let print a = a >> printfn "%A"

(Do Something Actions Realization)
let doSmthActions = [
    beep
    print get100Numbers
    print getDate 
    print getTimeZoneInfo 
    print sortArray
    sleep
]

(Do Something With File Actions Realization)
//Attention! Don't try this at home, especially with some important files! =)
let doSmthWithFileActions = [
    getCreationTime
    print getPath
    writeGuid
    delete
    read
]

type DecisionList<'a>(list: 'a list) =
    (private fields)
    member i.Choose() = (...)
    member i.Reward() = (...)
    member i.Punish() = (...)                 

type OS() =
    let doSmth = new DecisionList<_>(doSmthActions)
    let doSmthWithFile = new DecisionList<_>(doSmthWithFileActions)

    let printLine = printfn "Petrovich> %s"
    (* MailboxProcessor with 2 states: 
        - 'command' to make it do something
        - 'response' to formulate a reflex *)
    let core =
        MailboxProcessor.Start(fun inbox ->
            let rec command() =
                async { let! msg = inbox.Receive()
                    match msg with
                    | DoSmth -> 
                        printLine "do something"
                        doSmth.Choose()()
                        return! response doSmth.Punish doSmth.Reward
                    | DoSmthWithFile fileName ->
                        printLine <| "do something with " + fileName
                        doSmthWithFile.Choose() fileName
                        return! response doSmthWithFile.Punish doSmthWithFile.Reward
                    | Exit ->
                        printLine "exit" 
                        return ()
                    | _ -> return! command()
                }
            and response (*on punish*)p (*on reward*)r =
                async { let! msg = inbox.Receive()
                    match msg with
                    | Punish ->
                        printLine "punish"; p()
                        return! command()
                    | Reward ->
                        printLine "reward"; r()
                        return! command()
                    | Exit ->
                        printLine "exit" 
                        return ()
                    | _ -> return! response p r
                }
            command())

    member i.DoSomething() = core.Post DoSmth
    member i.DoSomethingWithFile fName = core.Post << DoSmthWithFile <| fName
    member i.Reward() = core.Post Reward
    member i.Punish() = core.Post Punish
    member i.Exit() = core.Post Exit

//time to test:
let petrovich = new OS()
petrovich.DoSomething()
petrovich.DoSomethingWithFile "test.txt"
petrovich.Reward()
petrovich.Punish()
petrovich.Exit()