home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / utilities / utilsf / hugs / hs / eliza < prev    next >
Text File  |  1995-02-14  |  10KB  |  266 lines
  1. -- Eliza: an implementation of the classic pseudo-psychoanalyst ---------------
  2. --
  3. -- Hugs version by Mark P. Jones, January 12 1992
  4. --
  5. -- Adapted from a pascal implementation provided as part of an experimental
  6. -- package from James Risner (risner@ms.uky.edu), Univ. of KY. with original
  7. -- pascal code apparently provided by Robert Migliaccio (mig@ms.uky.edu).
  8. -------------------------------------------------------------------------------
  9.  
  10. eliza :: Dialogue
  11. eliza  = interact (("\n\
  12.             \Hi! I'm Eliza. I am your personal therapy computer.\n\
  13.             \Please tell me your problem.\n\
  14.             \\n" ++)
  15.                    . session initial []
  16.                    . filter (not.null)
  17.                    . map (words . trim)
  18.                    . lines)
  19.  
  20. trim  :: String -> String                     -- strip punctuation characters
  21. trim   = foldr cons "" . dropWhile (`elem` punct)
  22.          where x `cons` xs | x `elem` punct && null xs = []
  23.                            | otherwise                 = x : xs
  24.                punct = [' ', '.', '!', '?', ',']
  25.  
  26. -- Read a line at a time, and produce some kind of response -------------------
  27.  
  28. session               :: State -> Words -> [Words] -> String
  29. session rs prev []     = []
  30. session rs prev (l:ls) = response ++ "\n\n" ++ session rs' l ls
  31.                          where (response, rs') | prev == l = repeated rs
  32.                                                | otherwise = answer rs l
  33.  
  34. answer                :: State -> Words -> (String, State)
  35. answer st l            = (response, newKeyTab kt st)
  36.  where (response, kt)         = ans (keyTabOf st)
  37.        e `cons` (r, es)       = (r, e:es)
  38.        ans (e:es) | null rs   = e `cons` ans es
  39.                   | otherwise = (makeResponse a (head rs), (key,as):es)
  40.                          where rs           = replies key l
  41.                                (key,(a:as)) = e
  42.  
  43. -- Find all possible replies (without leading string for given key ------------
  44.  
  45. replies                 :: Words -> Words -> [String]
  46. replies key l            = ( map (conjug l . drop (length key))
  47.                            . filter (prefix key . map ucase)
  48.                            . tails) l
  49.  
  50. prefix                  :: Eq a => [a] -> [a] -> Bool
  51. []     `prefix` xs       = True
  52. (x:xs) `prefix` []       = False
  53. (x:xs) `prefix` (y:ys)   = x==y && (xs `prefix` ys)
  54.  
  55. tails                   :: [a] -> [[a]]          -- non-empty tails of list
  56. tails []                 = []
  57. tails xs                 = xs : tails (tail xs)
  58.  
  59. ucase                   :: String -> String      -- map string to upper case
  60. ucase                    = map toUpper
  61.  
  62. -- Replace keywords in a list of words with appropriate conjugations ----------
  63.  
  64. conjug     :: Words -> Words -> String
  65. conjug d    = unwords . trailingI . map conj . maybe d  -- d is default input
  66.               where maybe d xs = if null xs then d else xs
  67.                     conj  w    = head ([m | (w',m)<-conjugates, uw==w'] ++ [w])
  68.                                  where uw = ucase w
  69.                     trailingI  = foldr cons []
  70.                                  where x `cons` xs | x=="I" && null xs = ["me"]
  71.                                                    | otherwise         = x:xs
  72.  
  73. conjugates :: [(Word, Word)]
  74. conjugates  = prepare (oneways ++ concat [[(x,y), (y,x)] | (x,y) <- bothways])
  75.               where oneways  = [ ("me",   "you") ]
  76.                     bothways = [ ("are",  "am"),     ("we're", "was"),
  77.                 ("you",  "I"),      ("your",  "my"),
  78.                 ("I've", "you've"), ("I'm",   "you're") ]
  79.                     prepare  = map (\(w,r) -> (ucase w, r))
  80.  
  81. -- Response data --------------------------------------------------------------
  82.  
  83. type Word     = String
  84. type Words    = [Word]
  85. type KeyTable = [(Key, Replies)]
  86. type Replies  = [String]
  87. type State    = (KeyTable, Replies)
  88. type Key      = Words
  89.  
  90. repeated          :: State -> (String, State)
  91. repeated (kt, (r:rp))      = (r, (kt, rp))
  92.  
  93. newKeyTab                 :: KeyTable -> State -> State
  94. newKeyTab kt' (kt, rp)     = (kt', rp)
  95.  
  96. keyTabOf                  :: State -> KeyTable
  97. keyTabOf (kt, rp)          = kt
  98.  
  99. makeResponse             :: String -> String -> String
  100. makeResponse ('?':cs) us  = cs ++ " " ++ us ++ "?"
  101. makeResponse ('.':cs) us  = cs ++ " " ++ us ++ "."
  102. makeResponse cs       us  = cs
  103.  
  104. initial     :: State
  105. initial      = ([(words k, cycle rs) | (k,rs) <-respMsgs], cycle repeatMsgs)
  106.  
  107. repeatMsgs   = [ "Why did you repeat yourself?",
  108.          "Do you expect a different answer by repeating yourself?",
  109.          "Come, come, elucidate your thoughts.",
  110.          "Please don't repeat yourself!" ]
  111.  
  112. respMsgs     = [ ("CAN YOU",        canYou),
  113.          ("CAN I",        canI),
  114.          ("YOU ARE",        youAre),
  115.          ("YOU'RE",        youAre),
  116.          ("I DON'T",        iDont),
  117.          ("I FEEL",        iFeel),
  118.          ("WHY DON'T YOU",    whyDont),
  119.          ("WHY CAN'T I",    whyCant),
  120.          ("ARE YOU",        areYou), 
  121.          ("I CAN'T",        iCant),
  122.          ("I AM",        iAm),
  123.          ("I'M",        iAm),
  124.          ("YOU",         you),
  125.          ("YES",        yes),
  126.          ("NO",            no),
  127.          ("COMPUTER",        computer),
  128.          ("COMPUTERS",        computer),
  129.          ("I WANT",        iWant),
  130.          ("WHAT",        question),
  131.          ("HOW",        question),
  132.          ("WHO",        question),
  133.          ("WHERE",        question),
  134.          ("WHEN",        question),
  135.          ("WHY",        question),
  136.          ("NAME",        name),
  137.          ("BECAUSE",        because),
  138.          ("CAUSE",        because),
  139.          ("SORRY",        sorry),
  140.          ("DREAM",        dream),
  141.          ("DREAMS",        dream),
  142.          ("HI",            hello),
  143.          ("HELLO",        hello),
  144.          ("MAYBE",        maybe),
  145.          ("YOUR",        your),
  146.          ("ALWAYS",        always),
  147.          ("THINK",        think),
  148.          ("ALIKE",        alike),
  149.          ("FRIEND",        friend),
  150.          ("FRIENDS",        friend),
  151.          ("",            nokeyMsgs) ]
  152.  where
  153.   canYou     = [ "?Don't you believe that I can",
  154.          "?Perhaps you would like to be able to",
  155.          "?You want me to be able to" ]
  156.   canI         = [ "?Perhaps you don't want to",
  157.          "?Do you want to be able to" ]
  158.   youAre     = [ "?What makes you think I am",
  159.          "?Does it please you to believe I am",
  160.          "?Perhaps you would like to be",
  161.          "?Do you sometimes wish you were" ]
  162.   iDont         = [ "?Don't you really",
  163.          "?Why don't you",
  164.          "?Do you wish to be able to",
  165.          "Does that trouble you?" ]
  166.   iFeel         = [ "Tell me more about such feelings.",
  167.          "?Do you often feel",
  168.          "?Do you enjoy feeling" ]
  169.   whyDont    = [ "?Do you really believe I don't",
  170.          ".Perhaps in good time I will",
  171.          "?Do you want me to" ]
  172.   whyCant    = [ "?Do you think you should be able to",
  173.          "?Why can't you" ]
  174.   areYou     = [ "?Why are you interested in whether or not I am",
  175.          "?Would you prefer if I were not",
  176.          "?Perhaps in your fantasies I am" ]
  177.   iCant         = [ "?How do you know you can't",
  178.          "Have you tried?",
  179.          "?Perhaps you can now" ]
  180.   iAm         = [ "?Did you come to me because you are",
  181.          "?How long have you been",
  182.          "?Do you believe it is normal to be",
  183.          "?Do you enjoy being" ]
  184.   you         = [ "We were discussing you --not me.",
  185.          "?Oh,",
  186.          "You're not really talking about me, are you?" ]
  187.   yes         = [ "You seem quite positive.",
  188.          "Are you Sure?",
  189.          "I see.",
  190.          "I understand." ]
  191.   no         = [ "Are you saying no just to be negative?",
  192.          "You are being a bit negative.",
  193.          "Why not?",
  194.          "Are you sure?",
  195.          "Why no?" ]
  196.   computer   = [ "Do computers worry you?",
  197.          "Are you talking about me in particular?",
  198.          "Are you frightened by machines?",
  199.          "Why do you mention computers?",
  200.          "What do you think machines have to do with your problems?",
  201.          "Don't you think computers can help people?",
  202.          "What is it about machines that worries you?" ]
  203.   iWant         = [ "?Why do you want",
  204.          "?What would it mean to you if you got",
  205.          "?Suppose you got",
  206.          "?What if you never got",
  207.          ".I sometimes also want" ]
  208.   question   = [ "Why do you ask?",
  209.          "Does that question interest you?",
  210.          "What answer would please you the most?",
  211.          "What do you think?",
  212.          "Are such questions on your mind often?",
  213.          "What is it that you really want to know?",
  214.          "Have you asked anyone else?",
  215.          "Have you asked such questions before?",
  216.          "What else comes to mind when you ask that?" ]
  217.   name         = [ "Names don't interest me.",
  218.          "I don't care about names --please go on." ]
  219.   because    = [ "Is that the real reason?",
  220.          "Don't any other reasons come to mind?",
  221.          "Does that reason explain anything else?",
  222.          "What other reasons might there be?" ]
  223.   sorry         =