AsmGofer Prelude

AsmGofer Prelude

The prelude description is not yet complete.
Under Construction

Content

Lists

First element of the list 
  head :: [a] -> a
Last element of the list 
  last :: [a] -> a
All elements except the first one 
 tail :: [a] -> [a]
All elements except the last one 
  init :: [a] -> [a]
Length of a list 
  length :: [a] -> Int

Sets

instance Eq [a] => Eq {a} where
   Set xs == Set ys = (xs == ys)

instance Ord [a] => Ord {a} ...
Conversion from list to set 
  mkSet :: Ord a => [a] -> {a}
Map function for sets 
  setmap :: Ord b => (a -> b) -> {a} -> {b}
  setmap f xs = { f(x) | x <-: xs }
Combining sets 
  union      :: Ord a => {a} -> {a} -> {a}
  bigUnion   :: Ord a =>  -> {a}
  intersect  :: Ord a => {a} -> {a} -> {a}
  difference :: Ord a => {a} -> {a} -> {a}
Test for empty set 
  empty :: {a} -> Bool
Determine cardinality of a set 
  card :: {a} -> Int
Get one arbitrary element of a set. The function can only be applied to non empty sets. 
  one :: {a} -> a
Fold on non empty sets 
  fold1 :: (a -> a -> a) -> {a} -> a
Convertion from set to list 
  expr2list :: {a} -> [a]

Gofer extensions for ASMs

Fixity declaration
  infixl 0 :=
Skip rule
  skip :: Rule ()
Firing rules 
  fire1     :: Rule () -> IO ()
  fire      :: Int -> Rule () -> IO ()
  fireWhile :: Bool -> Rule () -> IO ()
  fireUntil :: Bool -> Rule () -> IO ()
  fixpoint  :: Rule () -> IO ()
Putting trace information in a rule. The first parameter is the trace action. 
  trace :: IO () -> Rule () -> Rule ()
Creating dynamic functions 
  initVal       :: (Eq a, AsmTerm a) => String -> a -> Dynamic a
  initValStdin  :: String -> Dynamic String
  initValStdout :: Bool -> String -> Dynamic String
  initAssocs    :: (AsmTerm key, AsmTerm val, AsmOrd key, Eq val) =>
                     String -> [(key,val)] -> Dynamic (key -> val)
Predefined dynamic functions 
  stdout :: Dynamic String
  stdout = initValStdout False "stdout"

  stdin  :: Dynamic String
  stdin  = initValStdin "stdin"
Accessing information stored in dynamic functions 
  assocs :: Dynamic (key -> val) -> [(key,val)]
  assocs = primAsmAssocs

  dom :: Dynamic (key -> val) -> {key}
  dom = mkSet . map fst . assocs

  ran :: Dynamic (key -> val) -> {val}
  ran = mkSet . map snd . assocs

  inDom :: key -> Dynamic (key -> val) -> Bool
  inDom = primAsmInDom

  notInDom :: key -> Dynamic (key -> val) -> Bool
  notInDom key fun = not(key `inDom` fun)
Datatypes and instances 
  data Rule a = Skip | Rule ...

  instance Functor Rule where
    map f (Rule m) = Rule (map f m)
    map f Skip     = Skip

  instance Monad Rule where
    result = Rule . result 
    Rule m `bind` f = Rule (m `bind` (\x -> let Rule r = f x in r)) 
    Skip `bind` f   = f (error "skip does not return a value")

  instance Monad0 Rule where
    zero = Skip

  instance MonadPlus Rule where
    a ++ b = do a; b

  class AsmOrd a where
    asmCompare :: a -> a -> Int

  class AsmTerm a where
    (:=) :: Dynamic a -> a -> Rule ()
    asmDefault :: a
    asmDefault = primAsmDefault ()

  instance AsmTerm Bool where
    asmDefault = False

  instance AsmTerm Int
  instance AsmTerm Float
  instance AsmTerm Char
  instance AsmTerm String
  instance AsmTerm a => AsmTerm [a]
  instance (AsmTerm a, AsmTerm b) => AsmTerm (a,b)
  instance (AsmTerm a, AsmTerm b, AsmTerm c) => AsmTerm (a,b, c)
  instance (AsmTerm a, AsmTerm b, AsmTerm c, AsmTerm d) => AsmTerm (a,b, c, d)
  instance AsmTerm a => Eq a where
     (==) = genericEq
  instance AsmTerm a => AsmOrd a where
     asmCompare = genericCmp

Combining rules (only version 1.1)

Sequential execution of rules 
  seq :: Rule () -> Rule () -> Rule ()
The rule x := 1 `seq` x := 2 is equivalent to x := 2, because the second rule overwrites the value of x assigned by the first rule. On the other side, the rule x := 1 `seq` x := x + 1 is equivalent to x := 2, because the second rule uses the value of x assigned by the first rule.

Iteration of a rule until a fixpoint is reached (no further updates) 
  iterate :: Rule () -> Rule ()
There are some nice features
  • iterate skip is equivalent to skip
  • iterate (if cond then r else skip behaves like the normal while loop.
  • iterate (x := 1) is a never ending computation (update set is always non-empty).

Multi agent ASMs (only version 1.1)

Predefined dynamic function holding active agents 
  agents :: Dynamic (Agent -> Bool)
Randomly choosing one rule to fire. 
  multi :: Dynamic (a -> (a -> Rule ())) -> Rule ()
Let acts be a dynamic function from type a to type a -> Rule (). The type a could be an agent. If x is an element of type a in the domain of acts then acts(x) is a function from type a to type Rule ().
The expression multi acts chooses one x in the domain of acts and returns rule (acts x) x.

Index

Last modified on May 30, 2001, Joachim Schmid