> {-# LANGUAGE FlexibleInstances #-}

A naive, incomplete and terribly inefficient implementation of BrokerCore.

> module QuicQuid.BrokerCoreNaive(core) where

> import Control.Monad(forever)
> import Control.Concurrent(forkIO)

> import QuicQuid.Log

> import Data.Maybe
> import Control.Concurrent.STM
> import qualified Data.Map as M
> import QuicQuid.Term
> import QuicQuid.Logic
> import QuicQuid.Router
> import QuicQuid.Broker(writeAskChan)
> import QuicQuid.BrokerCore 

> data Broker = Broker {queries::[(Term,Address)],answers::[(Term,Address)]}

> core = newTVarIO $ Broker {queries=[],answers=[]}

> instance BrokerCore (TVar Broker) where
>   answer brk answer answerChan = do
>     st <- atomically $ do
>        st <- readTVar brk
>        writeTVar brk $ st {answers = (answer,answerChan) : answers st}
>        return st
>     return $ catMaybes $ map (\(query,queryChan)   -> fmap (\binding -> (binding,answerChan,queryChan)) (match2 query answer answerChan)) (queries st)
>   ask brk query queryChan = do
>     st <- atomically $ do
>       st <- readTVar brk
>       writeTVar brk $ st {queries = (query,queryChan) : queries st}
>       return st
>     return $ catMaybes $ map (\(answer,answerChan) -> fmap (\binding -> (binding,answerChan,queryChan)) (match2 query answer answerChan)) (answers st)

> -- Simple form of context: specifies only the pattern of the answerer address (needed?) and is applied only to the immediate query, not anything included. 
> match2 (App (Str "context") (Arr [to,q])) answer answerChan  = let ctxBinds = unify1 to (Str answerChan) in 
>                                                             if isJust ctxBinds then unify1 answer (substitute (fromJust ctxBinds) q) else Nothing
> match2 query answer answerCh = unify1 answer query