The entrypoint of a non-interactive HLogo. Takes as input a list of HLogo procedure names (as strings) to run in sequence. The program exits either when the last procedure stops, or when a program exception occurs.

NOTE TO SELF: cannot have run take procedures as values of 'CIO ()', possibly for the same reason as breeds_own, i.e. _GHC stage restriction_. It has to take either a list of strings or a list of symbol names (this was chosen).

Internal, used only in Test code.

Takes a 2-length list, with 1st element the plural name of the breeds (e.g. "wolves") and as 2nd element the singlular form (e.g. "wolf").

NB: breed agents share the same who counter (same namespace). The agentset turtles returns all turtle-like agents (both turtles and any-breeds).

Creates a directed-linkbreed. The arguments behave the same as breeds.

Creates an undirected-linkbreed. The arguments behave the same as breeds.

globals macro takes a list of variable names (as strings) and creates top-level global variables. Global variables have type Double and are initialized to 0.

patches_own macro takes a list of variable names (as strings) and creates corresponding field variables for each patch agent. This user-declared patch-field variables have type Double and are initialized to 0.

turtles_own macro takes a list of variable names (as strings) and creates corresponding field variables for each turtle agent. This user-declared turtle-field variables have type Double and are initialized to 0.

NB: turtle fields are inherited to all turtle-like agents, i.e. both the turtle agents as well as all any-breed agents.

links_own macro takes a list of variable names (as strings) and creates corresponding field variables for each link agent. This user-declared link-field variables have type Double and are initialized to 0.

NB: link fields are inherited to all link-like agents, i.e. both the link agents as well as all any-linkbreed agents.

breeds_own macro takes a list of variable names (as strings) and creates corresponding field variables for each breed-exact agent. A specific breed must be declared with breeds. This user-declared breed-field variables have type Double and are initialized to 0.

NOTE TO SELF: also applies for linkbreeds_own: this cannot become "wolves_own", etc. because of the _GHC stage restriction_. This means that the keywords breeds and breeds_own have to be defined in separate Haskell modules.

Like breeds_own but for linkbreeds, which are declared with directed_link_breed or undirected_link_breed.

Reports this turtle or patch.

"self" and "myself" are very different. "self" is simple; it means "me". "myself" means "the turtle or patch who asked me to do what I'm doing right now." When an agent has been asked to run some code, using myself in that code reports the agent (turtle or patch) that did the asking. NB: Implemented for ask, of, with

Reports an agentset which is the same as the input agentset but omits this agent.

Reports the number of agents in the given agentset.

This is a special value which some primitives such as turtle, one-of, max-one-of, etc. report to indicate that no agent was found. Also, when a turtle dies, it becomes equal to nobody.

It can be returned from all primitives that normally return 1 agent. It can also be returned from a turtle reference that got died or the turtle primitive to a dead agent,, like implicitly nullifying the agent.

Reports the heading from this agent to the given agent.

Reports a subset of the given agentset that includes only the agents on the patches the given distances away from this agent. The distances are specified as a list of two-item lists, where the two items are the x and y offsets. If the caller is the observer, then the points are measured relative to the origin, in other words, the points are taken as absolute patch coordinates. If the caller is a turtle, the points are measured relative to the turtle's exact location, and not from the center of the patch under the turtle.

Reports the heading from the turtle or patch towards the point (x,y).

This reporter lets you give a turtle a "cone of vision" in front of itself.

Runs the given commands only if it's been more than number seconds since the last time this agent ran them in this context. Otherwise, the commands are skipped. | NB: Works differently than NetLogo, in that only the calling thread is suspended, not the whole simulation

Wait the given number of seconds. (This needn't be an integer; you can specify fractions of seconds.) Note that you can't expect complete precision; the agent will never wait less than the given amount, but might wait slightly more. | NB: Works differently than NetLogo, in that only the calling thread is suspended, not the whole simulation

Runs commands1. If a runtime error occurs inside commands1, NetLogo won't stop and alert the user that an error occurred. It will suppress the error and run commands2 instead.

Reports an agentset containing all the turtles on the caller's patch (including the caller itself if it's a turtle).

Reports an agentset containing the turtles on the patch (dx, dy) from the caller. (The result may include the caller itself if the caller is a turtle.)

Reports an agentset containing all the turtles that are on the given patch or patches, or standing on the same patch as the given turtle or turtles.

The turtle moves forward by number units all at once (rather than one step at a time as with the forward command).

The turtle sets its x-coordinate to x and its y-coordinate to y.

The turtle moves forward by number steps, one step at a time. (If number is negative, the turtle moves backward.)

alias for forward

The turtle moves backward by number steps. (If number is negative, the turtle moves forward.)

alias for back

Reports the agentset consisting of all turtles.

Reports the turtle with the given who number, or nobody if there is no such turtle. For breeded turtles you may also use the single breed form to refer to them.

Reports an agentset containing all of the turtles anywhere in any of the inputs. NB: HLogo no support for nested turtle_set concatenation/flattening

Set the caller's heading towards agent.

This is a built-in turtle variable. It holds the current x coordinate of the turtle.

This is a built-in turtle variable. It indicates the direction the turtle is facing.

This is a built-in turtle variable. It holds the current y coordinate of the turtle.

This is a built-in turtle variable. It holds the turtle's "who number" or ID number, an integer greater than or equal to zero. You cannot set this variable; a turtle's who number never changes.

This is a built-in turtle variable. It holds the turtle's "who number" or ID number, an integer greater than or equal to zero. You cannot set this variable; a turtle's who number never changes.

Reports the x-increment (the amount by which the turtle's xcor would change) if the turtle were to take one step forward in its current heading.

Reports the y-increment (the amount by which the turtle's ycor would change) if the turtle were to take one step forward in its current heading.

This turtle moves to the origin (0,0). Equivalent to setxy 0 0.

The turtle turns right by number degrees. (If number is negative, it turns left.)

alias for right

The turtle turns left by number degrees. (If number is negative, it turns right.)

alias for left

Moves the turtle to the neighboring patch with the lowest value for patch-variable. If no neighboring patch has a smaller value than the current patch, the turtle stays put. If there are multiple patches with the same lowest value, the turtle picks one randomly. Non-numeric values are ignored. downhill considers the eight neighboring patches

Moves the turtle to the neighboring patch with the lowest value for patch-variable. If no neighboring patch has a smaller value than the current patch, the turtle stays put. If there are multiple patches with the same lowest value, the turtle picks one randomly. Non-numeric values are ignored. downhill4 only considers the four neighbors.

The turtle makes itself invisible.

alias for hide_turtle

The turtle becomes visible again.

alias for show_turtle

The turtle changes modes between drawing lines, removing lines or neither.

alias for pen_down

The turtle changes modes between drawing lines, removing lines or neither.

alias for pen_up

The turtle changes modes between drawing lines, removing lines or neither.

alias for pen_erase

Reports an empty turtle agentset.

This turtle creates number new turtles. Each new turtle inherits of all its variables, including its location, from its parent. (Exceptions: each new turtle will have a new who number)

Reports true if this turtle can move distance in the direction it is facing without violating the topology; reports false otherwise.

Reports the patch at (dx, dy) from the caller, that is, the patch containing the point dx east and dy patches north of this agent.

patch-here reports the patch under the turtle.

Reports the single patch that is the given distance "ahead" of this turtle, that is, along the turtle's current heading.

Reports the agentset consisting of all patches.

Given the x and y coordinates of a point, reports the patch containing that point.

Reports an agentset containing all of the patches anywhere in any of the inputs. NB: HLogo no support for nested patch_set concatenation/flattening

Reports an empty patch agentset.

These are built-in patch variables. They hold the x and y coordinate of the patch. They are always integers. You cannot set these variables, because patches don't move

These are built-in patch variables. They hold the x and y coordinate of the patch. They are always integers. You cannot set these variables, because patches don't mov

Reports an agentset containing the 8 surrounding patches

Reports an agentset containing the 4 surrounding patches

The link makes itself invisible.

The turtle becomes visible again.

Reports the distance between the endpoints of the link.

Given the who numbers of the endpoints, reports the link connecting the turtles. If there is no such link reports nobody. To refer to breeded links you must use the singular breed form with the endpoints.

Reports the agentset consisting of all links.

Report the undirected link between turtle and the caller. If no link exists then it reports nobody. link_with :: [Turtle] -> C Turtle _s' STM [Link] link_with [MkTurtle {who_=x}] = do (MkTurtle {who_=y},_) <- RWS.ask lxy <- link x y lyx <- link y x return $ case (lxy,lyx) of ([Nobody], [Nobody]) -> [Nobody] ([Nobody], _) -> error "directed link" ([LinkRef _ _], [LinkRef _ _]) -> lxy -- return arbitrary 1 of the two link positions (_, [Nobody]) -> error "directed link" _ -> throw DevException link_with a = throw $ TypeException "single turtle"

Report the directed link from turtle to the caller. If no link exists then it reports nobody. in_link_from :: [Turtle] -> C Turtle _s' STM [Link] in_link_from [MkTurtle {who_=x}] = do (MkTurtle {who_=y},_) <- RWS.ask lxy <- link x y lyx <- link y x return $ case (lxy,lyx) of ([Nobody], _) -> [Nobody] (_, [Nobody]) -> lxy ([LinkRef _ _], [LinkRef _ _]) -> error "undirected link" _ -> throw DevException in_link_from a = throw $ TypeException "turtle"

Reports the directed link from the caller to turtle. If no link exists then it reports nobody. out_link_to :: [Turtle] -> C Turtle _s' STM [Link] out_link_to [MkTurtle {who_=x}] = do (MkTurtle {who_=y},_) <- RWS.ask lxy <- link x y lyx <- link y x return $ case (lyx,lxy) of ([Nobody], _) -> [Nobody] (_, [Nobody]) -> lyx ([LinkRef _ _], [LinkRef _ _]) -> error "undirected link" _ -> throw DevException out_link_to a = throw $ TypeException "turtle" (head a)

Reports an agentset of all undirected links connected to the caller.

Reports an agentset of all the directed links going out from the caller to other nodes.

Reports an agentset of all the directed links coming in from other nodes to the caller.

Reports an empty link agentset.

Ties end1 and end2 of the link together. If the link is a directed link end1 is the root turtle and end2 is the leaf turtle. The movement of the root turtle affects the location and heading of the leaf turtle. If the link is undirected the tie is reciprocal so both turtles can be considered root turtles and leaf turtles. Movement or change in heading of either turtle affects the location and heading of the other turtle.

Unties end2 from end1 (sets tie-mode to "none") if they were previously tied together. If the link is an undirected link, then it will untie end1 from end2 as well. It does not remove the link between the two turtles.

Reports an agentset containing all of the links anywhere in any of the inputs. NB: HLogo no support for nested turtle_set concatenation/flattening

Reports a random floating point number from the allowable range of turtle coordinates along the given axis, x .

Reports a random floating point number from the allowable range of turtle coordinates along the given axis, y.

Reports a random integer ranging from min-pxcor to max-pxcor inclusive.

Reports a random integer ranging from min-pycor to max-pycor inclusive.

If number is positive, reports a random integer greater than or equal to 0, but strictly less than number. If number is negative, reports a random integer less than or equal to 0, but strictly greater than number. If number is zero, the result is always 0 as well.

If number is positive, reports a random floating point number greater than or equal to 0 but strictly less than number. If number is negative, reports a random floating point number less than or equal to 0, but strictly greater than number. If number is zero, the result is always 0.

Reports a number suitable for seeding the random number generator. The numbers reported by new-seed are based on the current date and time in milliseconds. Unlike NetLogo's new-seed, HLogo may report the same number twice in succession.

NB: taken from Haskell's random library

random-exponential reports an exponentially distributed random floating point number.

random-gamma reports a gamma-distributed random floating point number as controlled by the floating point alpha and lambda parameters.

random-normal reports a normally distributed random floating point number.

random-poisson reports a Poisson-distributed random integer.

Reports a shade of color proportional to the value of number.

The sum function computes the sum of the numbers of a structure.

Reports true if the given agentset is non-empty, false otherwise.

On lists, reports the value of the item in the given list with the given index.

From an agentset, reports a random agent. If the agentset is empty, reports nobody. From a list, reports a random list item. It is an error for the list to be empty.

Reports a random agent in the agentset that reports the lowest value for the given reporter. If there is a tie, this command reports one random agent that meets the condition. min_one_of :: (Agent b, Foldable t, Ord (Many b b1)) => t b -> C (One b) p IO b1 -> C p p' IO b

Reports the agent in the agentset that has the highest value for the given reporter. If there is a tie this command reports one random agent with the highest value. If you want all such agents, use with-max instead. max_one_of :: (Agent b, Foldable t, Ord (Many b b1)) => t b -> C (One b) p IO b1 -> C p p' IO b

For a list, reports a copy of list with all instances of item removed.

For a list, reports a copy of list with the item at the given index removed.

On a list, replaces an item in that list. index is the index of the item to be replaced, starting with 0.

Reports a new list containing the same items as the input list, but in randomized order.

Reports just a section of the given list or string, ranging between the first position (inclusive) and the second position (exclusive). 0-indexed

Reports just a section of the given list or string, ranging between the first position (inclusive) and the second position (exclusive).

From an agentset, reports an agentset of size size randomly chosen from the input set, with no repeats. From a list, reports a list of size size randomly chosen from the input set, with no repeats. n_of :: Eq a => Int -> [a] -> C s _s' IO [a] n_of n ls | n == 0 = return [] | n < 0 = error "negative index" | otherwise = do o <- one_of ls ns <- n_of (n-1) (delete o ls) return (o:ns)

When used on a list, but-first reports all of the list items of list except the first

but-last reports all of the list items of list except the last.

Reports true if the given list or string is empty, false otherwise.

On a list, reports the first (0th) item in the list.

With a single list, runs the task for each item of list.

Adds item to the beginning of a list and reports the new list.

Extract the last element of a list, which must be finite and non-empty.

Reports a list containing the given items.

Adds value to the end of a list and reports the new list.

map f xs is the list obtained by applying f to each element of xs, i.e.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

For a list, reports true if the given value appears in the given list, otherwise reports false.

On a list, reports the first position of item in list, or false if it does not appear.

Reduces a list from left to right using the given task, resulting in a single value. (foldl)

Reports a copy of list with all duplicate items removed. The first of each item remains in place.

reverse xs returns the elements of xs in reverse order. xs must be finite.

Makes a list out of the values.

Reports a sorted list of numbers, strings, or agents.

If the input is a list, reports a new list containing the same items as the input list, in a sorted order defined by the boolean reporter task.

Reports a list of agents, sorted according to each agent's value for reporter. Ties are broken randomly. sort_on :: Ord a => CSTM a -> [AgentRef] -> CSTM [AgentRef]

Reports the maximum number value in the list. It ignores other types of items.

Reports a list of length size containing values computed by repeatedly running the task.

Concatenates the inputs together and reports the result as a string.

Reports true if either boolean1 or boolean2 is true, but not when both are true.

Mathematical Constant

Reports the cosine of the given angle. Assumes the angle is given in degrees.

Reports the sine of the given angle. Assumes the angle is given in degrees.

Reports the tangent of the given angle.

Reports number1 modulo number2

Reports the arc cosine (inverse cosine) of the given number.

Reports the arc sine (inverse sine) of the given number.

Reports the arc tangent (inverse tangent) of the given number.

Reports the integer part of number -- any fractional part is discarded.

Reports the logarithm of number in base base.

Reports the natural logarithm of number, that is, the logarithm to the base e (2.71828...).

Reports the statistical mean of the numeric items in the given list.

Reports the statistical median of the numeric items of the given list.

Reports a list of the most common item or items in list.

Reports the sample variance of a list of numbers. Ignores other types of items.

Reports the sample standard deviation of a list of numbers. Ignores other types of items.

Computes the difference between the given headings, that is, the number of degrees in the smallest angle by which heading2 could be rotated to produce heading1.

Reports the absolute value of number.

floor x returns the greatest integer not greater than x

ceiling x returns the least integer not less than x

Reports the remainder when number1 is divided by number2.

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

This reporter gives the maximum x-coordinate for patches, which determines the size of the world.

This reporter gives the maximum y-coordinate for patches, which determines the size of the world.

This reporter gives the minimum x-coordinate for patches, which determines the size of the world.

This reporter gives the maximum y-coordinate for patches, which determines the size of the world.

This reporter gives the total width of the NetLogo world.

This reporter gives the total height of the NetLogo world.

Clears every plot in the model.

Clears all lines and stamps drawn by turtles.

alias for clear_drawing

Clears all text from the model's output area, if it has one. Otherwise does nothing.

Kills all turtles. Also resets the who numbering, so the next turtle created will be turtle 0.

alias for clear_turtles

Clears the patches by resetting all patch variables to their default initial values, including setting their color to black.

alias for clear_patches

Kills all links.

Clears the tick counter. Does not set the counter to zero. After this command runs, the tick counter has no value. Attempting to access or update it is an error until reset-ticks is called.

Resets the tick counter to zero, sets up all plots, then updates all plots (so that the initial state of the world is plotted).

Advances the tick counter by one and updates all plots.

Advances the tick counter by number. The input may be an integer or a floating point number. (Some models divide ticks more finely than by ones.) The input may not be negative.

Reports the current value of the tick counter. The result is always a number and never negative.

Histograms the values in the given list Draws a histogram showing the frequency distribution of the values in the list. The heights of the bars in the histogram represent the numbers of values in each subrange.

Runs commands number times.

Immediately exits from the current to-report procedure and reports value as the result of that procedure. report and to-report are always used in conjunction with each other. | NB: IN HLogo, It does not exit the procedure, but it will if the report primitive happens to be the last statement called from the procedure

For an agent, reports the value of the reporter for that agent (turtle or patch). For an agentset, reports a list that contains the value of the reporter for each agent in the agentset (in random order).

Runs the list of commands forever, or until the current procedure exits through use of the stop command or the report command. NB: Report command will not stop it in HLogo, only the stop primitive. This command is only run in IO, bcs the command has been implemented using exceptions and exceptions don't work the same in STM. Also it avoids common over-logging that can happen in STM.

This agent exits immediately from the enclosing to-procedure that was called from ask, or ask-like construct (e.g. crt, hatch, sprout). Only the current procedure stops, not all execution for the agent. Also can exit from a top-level (observer) procedure.

If reporter reports false, exit the loop. Otherwise run commands and repeat. This command is only run in IO, bcs the command has been implemented using exceptions and exceptions don't work the same in STM. Also it avoids common over-logging that can happen in STM.

Prints value in the Command Center, preceded by this agent, and followed by a carriage return.

HLogo-specific: There are no guarantees on which agent will be prioritized to write on the stdout. The only guarantee is that in case of show inside an atomic transaction, no show will be repeated if the transaction is retried. Compared to unsafe_show, the output is not mangled.

Prints value in the Command Center, followed by a carriage return.

HLogo-specific: There are no guarantees on which agent will be prioritized to write on the stdout. The only guarantee is that in case of print inside an atomic transaction, no print will be repeated if the transaction is retried. Compared to unsafe_print, the output is not mangled.

Interprets the given string as if it had been typed in the Command Center, and reports the resulting value.

lifting STM to IO, a wrapper to atomically that optionally (based on a CPP flag) can capture STM statistics

The specified agent or agentset runs the given commands.

Tells each patch to give equal shares of (number * 100) percent of the value of patch-variable to its eight neighboring patches. number should be between 0 and 1. Regardless of topology the sum of patch-variable will be conserved across the world. (If a patch has fewer than eight neighbors, each neighbor still gets an eighth share; the patch keeps any leftover shares.) can be done better, in a single sequential atomic diffuse :: CSTM Double -> (Double -> CSTM ()) -> Double -> C Observer () IO () diffuse gettervar settervar perc = ask (do ns <- neighbors cns <- count ns g <- atomic gettervar let pg = g * perc / 8 ask (atomic (do ng <- gettervar settervar (ng + pg))) ns atomic $ settervar (g - (pg * fromIntegral cns)) ) =<< patches

A class to allow certain NetLogo builtin primitives to be used both atomic-wrapped as well without atomic, since their semantics are preserved.

Mostly applies to Observer and IO-related commands. Also the implementation takes advantage of the faster readTVarIO. The correct lifting (STM or IO) is left to type inference.

Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.

Catches an Exception in STM monad

Catches an Exception in IO monad

Evaluate the argument to weak head normal form.

evaluate is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them.

evaluate only evaluates to weak head normal form. If deeper evaluation is needed, the force function from Control.DeepSeq may be handy:

evaluate $ force x

There is a subtle difference between evaluate x and return $! x, analogous to the difference between throwIO and throw. If the lazy value x throws an exception, return $! x will fail to return an IO action and will throw an exception instead. evaluate x, on the other hand, always produces an IO action; that action will throw an exception upon execution iff x throws an exception upon evaluation.

The practical implication of this difference is that due to the imprecise exceptions semantics,

(return $! error "foo") >> error "bar"

may throw either "foo" or "bar", depending on the optimizations performed by the compiler. On the other hand,

evaluate (error "foo") >> error "bar"

is guaranteed to throw "foo".

The rule of thumb is to use evaluate to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use return $! x.

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving (Show, Typeable)

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e
    deriving Typeable

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e
    deriving Typeable

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving (Typeable, Show)

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Arithmetic exceptions.

assert was applied to False.

Asynchronous exceptions.

Thrown when the program attempts to call atomically, from the stm package, inside another call to atomically.

The thread is waiting to retry an STM transaction, but there are no other references to any TVars involved, so it can't ever continue.

There are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only.

This is thrown when the user calls error. The String is the argument given to error.

Thrown when a primitive procedure expected a different *this* context (i.e. the callee inside the context monad transformer).

Used as ContextException ExpectedCalleeAsString GotInsteadAgentRef

A type error thrown when a procedure expected a different type of agent argument. Normally we use the static typing of Haskell, except for AgentRefs, which are checked dynamically on run-time

Used as TypeException ExpectedTypeAsString GotInsteadAgentRef

A type error thrown when a procedure expected a different type of agent argument. Normally we use the static typing of Haskell, except for AgentRefs, which are checked dynamically on run-time

Used as TypeException ExpectedTypeAsString GotInsteadAgentRef

The error thrown by the stop primitive. It is a trick and should be catched in an upper caller primitive.

An agent (subtype of Player) can be asked to do some work or return a value of_ his.

Agents (of the same type, since we are typed) can be checked for Equality (= in NetLogo, == in HLogo), Ordered (>,,=...) and Showed their identiy to screen.

A subtype of Agent is a TurtleLink, i.e. either a Turtle or a Link.

This class is needed since turtle/links have some common attribute names and share certain primitives.

Any HLogo program executes either inside STM or IO side-effectful monad. We wrap these monads around a context mainly for two reasons:

1) to have at runtime the dynamic information of the this-agent (self) and its parent caller (myself). 2) to restrict the types of the NetLogo primitives to specifc contexts, thus turning the NetLogo dynamic language to a statically type-checked eDSL.

The observer is an empty datatype. It cannot be constructed (inhabited by any value), and is only there to restrict the 'self'&'myself' reader Context.

The Turtle datatype is a record with each field being a transactional variable (TVar) holding an attribute value of Turtle, except the who_ attribute which is fixed upon turtle creation.

The Patch datatype follows a similar philosophy with the Turtle (ADT). Each field is a transactional variable (TVar) storing an attribute value of Patch, except the pxcor_ and pycor_ attributes which are fixed upon patch creation.

The Link datatype follows a similar philosophy with the Turtle (ADT). Each field is a transactional variable (TVar) storing an attribute value of Link, except the end1_, end2_, directed attributes which are fixed upon patch creation.

Holds the information for the turtle, if it's pen is up or down.

Compared to NetLogo's string representation, this is an Algebraic Data Type (ADT). NetLogo does not even raise a _runtime error_ for if their pen-mode string is ill-formatted, and assumes that any ill-formatted string, e.g. "downn", UP is the same as "down"

Holds the information for the link, if it ties the two turtles together, i.e. one moving will result with the other moving too.

Compared to NetLogo's string representation, this is an Algebraic Data Type (ADT). NetLogo does not even raise a _runtime error_ for ill-formatted tie-mode strings.

The Patches ADT is an 2d-nested vector with size (max-pxcor-min-pxcor)*(max-pycor-min-pycor) that links the position (Int,Int) of a patch to its transactional attributes (patch variables) of the Patch record.

The vector is pure and is initialized at the start of an HLogo program, upon calling run.

The Turtles ADT is an IntMap from who indices to Turtle data structures

The Links ADT is an ordered map (dictionary) from turtle Int indices (from, to) to Link data structures

forever act repeats the action infinitely.

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

Promote a function to a monad.

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

   liftM2 (+) [0,1] [0,2] = [0,2,1,3]
   liftM2 (+) (Just 1) Nothing = Nothing