...

6 files changed, 333 insertions, 197 deletions

diff --git a/elm.json b/elm.json
index 923a948..7bb17ea 100644
--- a/elm.json
+++ b/elm.json
@@ -11,6 +11,7 @@
             "elm/html": "1.0.0",
             "elm/http": "2.0.0",
             "elm/json": "1.1.2",
+            "elm/random": "1.0.0",
             "elm/time": "1.0.0",
             "elm/url": "1.0.0"
         },
diff --git a/src/Struct/Model.elm b/src/Struct/Model.elm
index b9c8d61..cf4d475 100644
--- a/src/Struct/Model.elm
+++ b/src/Struct/Model.elm
@@ -31,6 +31,6 @@ type alias Type =
 new : Type
 new =
    {
-      tonkadur = (Tonkadur.Types.new_state),
+      tonkadur = (Tonkadur.Types.new_state 42),
       ui = (Struct.UI.new)
    }
diff --git a/src/Tonkadur/Compute.elm b/src/Tonkadur/Compute.elm
index 2a3410f..149f37d 100644
--- a/src/Tonkadur/Compute.elm
+++ b/src/Tonkadur/Compute.elm
@@ -18,15 +18,24 @@ add_text_effect : (
       Tonkadur.Types.State ->
       String ->
       (List Tonkadur.Types.Computation) ->
+      (List Tonkadur.Types.Computation) ->
       Tonkadur.Types.Value
    )
 add_text_effect state name parameters content =
-   (TextValue
-      (AugmentedText
+   (Tonkadur.Types.TextValue
+      (Tonkadur.Types.AugmentedText
          {
-            content = (List.map (compute state) content),
+            content =
+               (List.map
+                  (\val ->
+                     (Tonkadur.Types.value_to_text_or_string
+                        (compute state val)
+                     )
+                  )
+                  content
+               ),
             effect_name = name,
-            effect_parameters = parameters
+            effect_parameters = (List.map (compute state) parameters)
          }
       )
    )
@@ -38,13 +47,19 @@ address : (
    )
 address state param =
    case (compute state param) of
-      (PointerValue address) -> (PointerValue address)
-      (StringValue singleton) -> (PointerValue (List.singleton singleton))
-      _ -> (PointerValue [])
+      (Tonkadur.Types.PointerValue address_v) ->
+         (Tonkadur.Types.PointerValue address_v)
+
+      (Tonkadur.Types.StringValue singleton) ->
+         (Tonkadur.Types.PointerValue (List.singleton singleton))
+
+      _ -> (Tonkadur.Types.PointerValue [])
 
 unsupported_cast : String -> String -> Tonkadur.Types.Value
 unsupported_cast from to =
-   (StringValue ("Unsupported cast from " + from + " to " + to + "."))
+   (Tonkadur.Types.StringValue
+      ("Unsupported cast from " ++ from ++ " to " ++ to ++ ".")
+   )
 
 cast : (
       Tonkadur.Types.State ->
@@ -55,68 +70,84 @@ cast : (
    )
 cast state from to param =
    case (compute state param) of
-      (BoolValue bool) ->
+      (Tonkadur.Types.BoolValue bool) ->
          case to of
             "string" ->
                if bool
-               then (StringValue "true")
-               else (StringValue "false")
+               then (Tonkadur.Types.StringValue "true")
+               else (Tonkadur.Types.StringValue "false")
 
             "text" ->
                if bool
-               then (TextValue (StringText "true"))
-               else (TextValue (StringText "false"))
+               then
+                  (Tonkadur.Types.TextValue (Tonkadur.Types.StringText "true"))
+               else
+                  (Tonkadur.Types.TextValue (Tonkadur.Types.StringText "false"))
 
-            "bool" -> (BoolValue bool)
+            "bool" -> (Tonkadur.Types.BoolValue bool)
             _ -> (unsupported_cast from to)
 
-      (FloatValue float) ->
+      (Tonkadur.Types.FloatValue float) ->
          case to of
-            "string" -> (StringValue (String.fromFloat float))
-            "text" -> (TextValue (StringText (String.fromFloat float)))
-            "int" -> (IntValue (Math.floor float))
-            "float" -> (FloatValue float)
+            "string" -> (Tonkadur.Types.StringValue (String.fromFloat float))
+            "text" ->
+               (Tonkadur.Types.TextValue
+                  (Tonkadur.Types.StringText (String.fromFloat float))
+               )
+
+            "int" -> (Tonkadur.Types.IntValue (floor float))
+            "float" -> (Tonkadur.Types.FloatValue float)
             _ -> (unsupported_cast from to)
 
-      (IntValue int) ->
+      (Tonkadur.Types.IntValue int) ->
          case to of
-            "string" -> (StringValue (String.fromInt int))
-            "text" -> (TextValue (StringText (String.fromInt int)))
-            "float" -> (FloatValue (Math.toFloat int))
-            "int" -> (IntValue int)
+            "string" -> (Tonkadur.Types.StringValue (String.fromInt int))
+            "text" ->
+               (Tonkadur.Types.TextValue
+                  (Tonkadur.Types.StringText (String.fromInt int))
+               )
+
+            "float" -> (Tonkadur.Types.FloatValue (toFloat int))
+            "int" -> (Tonkadur.Types.IntValue int)
             _ -> (unsupported_cast from to)
 
-      (TextValue text) ->
-         let as_string = (Tonkadur.Types.value_to_string (TextValue text)) in
+      (Tonkadur.Types.TextValue text_v) ->
+         let
+            as_string =
+               (Tonkadur.Types.value_to_string
+                  (Tonkadur.Types.TextValue text_v)
+               )
+         in
          case to of
-            "string" -> (StringValue as_string)
+            "string" -> (Tonkadur.Types.StringValue as_string)
             "float" ->
                case (String.toFloat as_string) of
                   Nothing -> (unsupported_cast from to)
-                  (Just result) -> (FloatValue result)
+                  (Just result) -> (Tonkadur.Types.FloatValue result)
 
             "int" ->
                case (String.toInt as_string) of
                   Nothing -> (unsupported_cast from to)
-                  (Just result) -> (IntValue result)
+                  (Just result) -> (Tonkadur.Types.IntValue result)
 
-            "text" -> (TextValue text)
+            "text" -> (Tonkadur.Types.TextValue text_v)
             _ -> (unsupported_cast from to)
 
-      (StringValue string) ->
+      (Tonkadur.Types.StringValue string) ->
          case to of
-            "string" -> (StringValue string)
+            "string" -> (Tonkadur.Types.StringValue string)
             "float" ->
-               case (String.fromFloat string) of
+               case (String.toFloat string) of
                   Nothing -> (unsupported_cast from to)
-                  (Just result) -> (FloatValue result)
+                  (Just result) -> (Tonkadur.Types.FloatValue result)
 
             "int" ->
                case (String.toInt string) of
                   Nothing -> (unsupported_cast from to)
-                  (Just result) -> (IntValue result)
+                  (Just result) -> (Tonkadur.Types.IntValue result)
 
-            "text" -> (TextValue (StringText string))
+            "text" ->
+               (Tonkadur.Types.TextValue (Tonkadur.Types.StringText string))
 
             _ -> (unsupported_cast from to)
 
@@ -129,7 +160,22 @@ constant : (
       Tonkadur.Types.Value
    )
 constant state target_type as_string =
-   (cast state "string" target_type as_string)
+   case target_type of
+      "string" -> (Tonkadur.Types.StringValue as_string)
+      "float" ->
+         case (String.toFloat as_string) of
+            Nothing -> (unsupported_cast as_string target_type)
+            (Just result) -> (Tonkadur.Types.FloatValue result)
+
+      "int" ->
+         case (String.toInt as_string) of
+            Nothing -> (unsupported_cast as_string target_type)
+            (Just result) -> (Tonkadur.Types.IntValue result)
+
+      "text" ->
+         (Tonkadur.Types.TextValue (Tonkadur.Types.StringText as_string))
+
+      _ -> (unsupported_cast as_string target_type)
 
 extra_computation : (
       Tonkadur.Types.State ->
@@ -139,7 +185,10 @@ extra_computation : (
    )
 extra_computation state name parameters =
    case name of
-      _ -> (StringValue ("Unsupported extra computation '" + name + "'"))
+      _ ->
+         (Tonkadur.Types.StringValue
+            ("Unsupported extra computation '" ++ name ++ "'")
+         )
 
 if_else : (
       Tonkadur.Types.State ->
@@ -149,21 +198,26 @@ if_else : (
       Tonkadur.Types.Value
    )
 if_else state condition if_true if_false =
-   if (WyrdType.to_boolean (compute state condition))
+   if (Tonkadur.Types.value_to_bool (compute state condition))
    then (compute state if_true)
    else (compute state if_false)
 
 last_choice_index : Tonkadur.Types.State -> Tonkadur.Types.Value
-last_choice_index state = (IntValue state.last_choice_index)
+last_choice_index state = (Tonkadur.Types.IntValue state.last_choice_index)
 
 newline : Tonkadur.Types.State -> Tonkadur.Types.Value
-newline state = (TextValue Newline)
+newline state = (Tonkadur.Types.TextValue Tonkadur.Types.NewlineText)
 
 next_allocable_address : Tonkadur.Types.State -> Tonkadur.Types.Value
 next_allocable_address state =
-   if (List.isEmpty state.freed_addresses)
-   then (PointerValue [(".alloc." ++ (String.fromInt state.allocated_data))])
-   else (PointerValue [state.freed_addresses[0]])
+   case state.freed_addresses of
+      [] ->
+         (Tonkadur.Types.PointerValue
+            [(".alloc." ++ (String.fromInt state.allocated_data))]
+         )
+
+      (available_address :: _) ->
+         (Tonkadur.Types.PointerValue [available_address])
 
 operation : (
       Tonkadur.Types.State ->
@@ -180,11 +234,13 @@ operation state name param0 param1 =
    case name of
       "divide" ->
          case value0 of
-            (IntValue val) ->
-               (IntValue (val // (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue val) ->
+               (Tonkadur.Types.IntValue
+                  (val // (Tonkadur.Types.value_to_int value1))
+               )
 
             _ ->
-               (FloatValue
+               (Tonkadur.Types.FloatValue
                   (
                      (Tonkadur.Types.value_to_float value0)
                      / (Tonkadur.Types.value_to_float value1)
@@ -193,11 +249,13 @@ operation state name param0 param1 =
 
       "minus" ->
          case value0 of
-            (IntValue val) ->
-               (IntValue (val - (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue val) ->
+               (Tonkadur.Types.IntValue
+                  (val - (Tonkadur.Types.value_to_int value1))
+               )
 
             _ ->
-               (FloatValue
+               (Tonkadur.Types.FloatValue
                   (
                      (Tonkadur.Types.value_to_float value0)
                      - (Tonkadur.Types.value_to_float value1)
@@ -205,7 +263,7 @@ operation state name param0 param1 =
                )
 
       "modulo" ->
-         (IntValue
+         (Tonkadur.Types.IntValue
             (modBy
                (Tonkadur.Types.value_to_int value0)
                (Tonkadur.Types.value_to_int value1)
@@ -214,11 +272,13 @@ operation state name param0 param1 =
 
       "plus" ->
          case value0 of
-            (IntValue val) ->
-               (IntValue (val + (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue val) ->
+               (Tonkadur.Types.IntValue
+                  (val + (Tonkadur.Types.value_to_int value1))
+               )
 
             _ ->
-               (FloatValue
+               (Tonkadur.Types.FloatValue
                   (
                      (Tonkadur.Types.value_to_float value0)
                      + (Tonkadur.Types.value_to_float value1)
@@ -227,11 +287,13 @@ operation state name param0 param1 =
 
       "power" ->
          case value0 of
-            (IntValue val) ->
-               (IntValue (val ^ (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue val) ->
+               (Tonkadur.Types.IntValue
+                  (val ^ (Tonkadur.Types.value_to_int value1))
+               )
 
             _ ->
-               (FloatValue
+               (Tonkadur.Types.FloatValue
                   (
                      (Tonkadur.Types.value_to_float value0)
                      ^ (Tonkadur.Types.value_to_float value1)
@@ -240,11 +302,13 @@ operation state name param0 param1 =
 
       "times" ->
          case value0 of
-            (IntValue val) ->
-               (IntValue (val * (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue val) ->
+               (Tonkadur.Types.IntValue
+                  (val * (Tonkadur.Types.value_to_int value1))
+               )
 
             _ ->
-               (FloatValue
+               (Tonkadur.Types.FloatValue
                   (
                      (Tonkadur.Types.value_to_float value0)
                      * (Tonkadur.Types.value_to_float value1)
@@ -252,41 +316,57 @@ operation state name param0 param1 =
                )
 
       "and" ->
-         (BoolValue
-            (and
+         (Tonkadur.Types.BoolValue
+            (
                (Tonkadur.Types.value_to_bool value0)
-               (Tonkadur.Types.value_to_bool value1)
+               && (Tonkadur.Types.value_to_bool value1)
             )
          )
 
-      "not" -> (BoolValue (not (Tonkadur.Types.value_to_bool value0)))
+      "not" ->
+         (Tonkadur.Types.BoolValue (not (Tonkadur.Types.value_to_bool value0)))
 
       "less_than" ->
          case value0 of
-            (BoolValue bool) ->
-               (and (Tonkadur.Types.value_to_bool value1) (not boot))
+            (Tonkadur.Types.BoolValue bool) ->
+               (Tonkadur.Types.BoolValue
+                  ((Tonkadur.Types.value_to_bool value1) && (not bool))
+               )
 
-            (FloatValue float) ->
-               (BoolValue (float < (Tonkadur.Types.value_to_float value1)))
+            (Tonkadur.Types.FloatValue float) ->
+               (Tonkadur.Types.BoolValue
+                  (float < (Tonkadur.Types.value_to_float value1))
+               )
 
-            (IntValue int) ->
-               (BoolValue (int < (Tonkadur.Types.value_to_int value1)))
+            (Tonkadur.Types.IntValue int) ->
+               (Tonkadur.Types.BoolValue
+                  (int < (Tonkadur.Types.value_to_int value1))
+               )
 
-            (StringValue str) ->
-               (BoolValue (str < (Tonkadur.Types.value_to_string value1)))
+            (Tonkadur.Types.StringValue str) ->
+               (Tonkadur.Types.BoolValue
+                  (str < (Tonkadur.Types.value_to_string value1))
+               )
 
-            (PointerValue ptr) ->
-               (BoolValue
+            (Tonkadur.Types.PointerValue ptr) ->
+               (Tonkadur.Types.BoolValue
                   (
                      (Tonkadur.Types.compare_pointers
                         ptr
-                        (Tonadur.Wyrd.value_to_dict value1)
+                        (Tonkadur.Types.value_to_address value1)
                      )
                      > 0
                   )
                )
 
-      "equals" -> (value0 == value1)
+            _ -> (Tonkadur.Types.StringValue ("Not a comparable type."))
+
+      "equals" -> (Tonkadur.Types.BoolValue (value0 == value1))
+
+      other ->
+         (Tonkadur.Types.StringValue
+            ("Unknown operation '" ++ other ++ "'")
+         )
 
 relative_address : (
       Tonkadur.Types.State ->
@@ -295,10 +375,10 @@ relative_address : (
       Tonkadur.Types.Value
    )
 relative_address state base extra =
-   (PointerValue
+   (Tonkadur.Types.PointerValue
       (List.append
-         (Tonkadur.Types.value_to_list (compute state base))
-         (Tonkadur.Types.value_to_list (compute state extra))
+         (Tonkadur.Types.value_to_address (compute state base))
+         (Tonkadur.Types.value_to_address (compute state extra))
       )
    )
 
@@ -308,7 +388,7 @@ size : (
       Tonkadur.Types.Value
    )
 size state computation =
-   (IntValue
+   (Tonkadur.Types.IntValue
       (Dict.size (Tonkadur.Types.value_to_dict (compute state computation)))
    )
 
@@ -321,14 +401,16 @@ text : (
 text state content =
    (List.foldl
       (\addition result ->
-         (TextValue
+         (Tonkadur.Types.TextValue
             (Tonkadur.Types.append_text_content
-               (Tonkadur.Types.value_to_text result)
-               (Tonkadur.Types.value_to_text (compute state addition))
+               (Tonkadur.Types.value_to_text_or_string result)
+               (Tonkadur.Types.value_to_text_or_string (compute state addition))
             )
          )
       )
-      (TextValue (Tonkadur.Types.default_text_data))
+      (Tonkadur.Types.TextValue
+         (Tonkadur.Types.AugmentedText (Tonkadur.Types.default_text_data))
+      )
       content
    )
 
@@ -341,11 +423,14 @@ value_of state computation =
    (List.foldl
       (\next_step object ->
          case (Dict.get next_step (Tonkadur.Types.value_to_dict object)) of
-            Nothing -> (StringValue "Segmentation Fault (incorrect address)")
             (Just value) -> value
+            Nothing ->
+               (Tonkadur.Types.StringValue
+                  "Segmentation Fault (incorrect address)"
+               )
       )
-      (StructureValue state.memory)
-      (Tonkadur.Types.value_to_list (compute state computation))
+      (Tonkadur.Types.StructureValue state.memory)
+      (Tonkadur.Types.value_to_address (compute state computation))
    )
 
 --------------------------------------------------------------------------------
@@ -358,23 +443,28 @@ compute : (
    )
 compute state computation =
    case computation of
-      (AddTextEffect effect_name effect_parameters content) ->
+      (Tonkadur.Types.AddTextEffect effect_name effect_parameters content) ->
          (add_text_effect state effect_name effect_parameters content)
 
-      (Address param) -> (address state param)
-      (Cast from to value) -> (cast state from to value)
-      (Constant true_type as_string) -> (constant state true_type as_string)
-      (ExtraComputation name parameters) ->
+      (Tonkadur.Types.Address param) -> (address state param)
+      (Tonkadur.Types.Cast from to value) -> (cast state from to value)
+      (Tonkadur.Types.Constant true_type as_string) ->
+         (constant state true_type as_string)
+
+      (Tonkadur.Types.ExtraComputation name parameters) ->
          (extra_computation state name parameters)
 
-      (IfElse condition if_true if_false) ->
+      (Tonkadur.Types.IfElse condition if_true if_false) ->
          (if_else state condition if_true if_false)
 
-      LastChoiceIndex -> (last_choice_index state)
-      Newline -> (newline state)
-      NextAllocableAddress -> (next_allocable_address state)
-      (Operation name arg_0 arg_1) -> (operation state name arg_0 arg_1)
-      (RelativeAddress base extra) -> (relative_address state base extra)
-      (Size value) -> (size state value)
-      (Text content) -> (text state content)
-      (ValueOf address) -> (value_of state address)
+      Tonkadur.Types.LastChoiceIndex -> (last_choice_index state)
+      Tonkadur.Types.Newline -> (newline state)
+      Tonkadur.Types.NextAllocableAddress -> (next_allocable_address state)
+      (Tonkadur.Types.Operation name arg_0 arg_1) ->
+         (operation state name arg_0 arg_1)
+      (Tonkadur.Types.RelativeAddress base extra) ->
+         (relative_address state base extra)
+
+      (Tonkadur.Types.Size value) -> (size state value)
+      (Tonkadur.Types.Text content) -> (text state content)
+      (Tonkadur.Types.ValueOf address_c) -> (value_of state address_c)
diff --git a/src/Tonkadur/Execute.elm b/src/Tonkadur/Execute.elm
index cf88968..d302cc5 100644
--- a/src/Tonkadur/Execute.elm
+++ b/src/Tonkadur/Execute.elm
@@ -3,6 +3,7 @@ module Tonkadur.Execute exposing (execute)
 -- Elm -------------------------------------------------------------------------
 import Dict
 import List
+import Random
 
 -- Tonkadur --------------------------------------------------------------------
 import Tonkadur.Types
@@ -18,7 +19,7 @@ import Tonkadur.Compute
 --------------------------------------------------------------------------------
 increment_program_counter : Tonkadur.Types.State -> Tonkadur.Types.State
 increment_program_counter state =
-   {state | program_counter = program_counter + 1}
+   {state | program_counter = state.program_counter + 1}
 
 ---- INSTRUCTIONS --------------------------------------------------------------
 add_event_option : (
@@ -29,7 +30,10 @@ add_event_option : (
    )
 add_event_option name parameters state =
    (Tonkadur.Types.append_option
-      (Event name (List.map (Tonkadur.Compute.compute state) parameters))
+      (Tonkadur.Types.Event
+         name
+         (List.map (Tonkadur.Compute.compute state) parameters)
+      )
       state
    )
 
@@ -40,7 +44,11 @@ add_text_option : (
    )
 add_text_option label state =
    (Tonkadur.Types.append_option
-      (Choice (Tonkadur.Compute.compute label state))
+      (Tonkadur.Types.Choice
+         (Tonkadur.Types.value_to_text_or_string
+            (Tonkadur.Compute.compute state label)
+         )
+      )
       state
    )
 
@@ -61,7 +69,7 @@ display : (
       Tonkadur.Types.Computation ->
       Tonkadur.Types.State ->
       Tonkadur.Types.State
-)
+   )
 display label state =
    -- TODO: where do we put displayed values?
    state
@@ -90,13 +98,15 @@ initialize : (
    )
 initialize type_name address state =
    let
+      address_as_list =
+         (Tonkadur.Types.value_to_address
+            (Tonkadur.Compute.compute state address)
+         )
       new_state =
          {state |
             memory =
                (Tonkadur.Types.apply_at_address
-                  (Tonkadur.Types.value_to_list
-                     (Tonkadur.Compute.compute state address)
-                  )
+                  address_as_list
                   (\last_addr dict ->
                      (Dict.insert
                         last_addr
@@ -109,8 +119,8 @@ initialize type_name address state =
             -- TODO: detect allocated memory for special handling.
          }
    in
-      case address of
-         [single_element] ->
+      case address_as_list of
+         (single_element :: []) ->
             if (String.startsWith ".alloc." single_element)
             then
                if
@@ -144,7 +154,7 @@ prompt_command prompt_data state =
    {state |
       memorized_target = (Tonkadur.Compute.compute state prompt_data.address),
       last_instruction_effect =
-         (PromptCommand
+         (Tonkadur.Types.MustPromptCommand
             (Tonkadur.Compute.compute state prompt_data.min)
             (Tonkadur.Compute.compute state prompt_data.max)
             (Tonkadur.Compute.compute state prompt_data.label)
@@ -160,7 +170,7 @@ prompt_string prompt_data state =
    {state |
       memorized_target = (Tonkadur.Compute.compute state prompt_data.address),
       last_instruction_effect =
-         (PromptString
+         (Tonkadur.Types.MustPromptString
             (Tonkadur.Compute.compute state prompt_data.min)
             (Tonkadur.Compute.compute state prompt_data.max)
             (Tonkadur.Compute.compute state prompt_data.label)
@@ -176,7 +186,7 @@ prompt_integer prompt_data state =
    {state |
       memorized_target = (Tonkadur.Compute.compute state prompt_data.address),
       last_instruction_effect =
-         (PromptInteger
+         (Tonkadur.Types.MustPromptInteger
             (Tonkadur.Compute.compute state prompt_data.min)
             (Tonkadur.Compute.compute state prompt_data.max)
             (Tonkadur.Compute.compute state prompt_data.label)
@@ -190,20 +200,22 @@ remove : (
    )
 remove address state =
    let
+      address_as_list =
+         (Tonkadur.Types.value_to_address
+            (Tonkadur.Compute.compute state address)
+         )
       new_state =
          {state |
             memory =
                (Tonkadur.Types.apply_at_address
-                  (Tonkadur.Types.value_to_list
-                     (Tonkadur.Compute.compute state address)
-                  )
+                  address_as_list
                   (\last_addr dict -> (Dict.remove last_addr dict))
                   state.memory
                )
          }
    in
-      case address of
-         [single_element] ->
+      case address_as_list of
+         (single_element :: []) ->
             if (String.startsWith ".alloc." single_element)
             then
                {new_state |
@@ -217,13 +229,13 @@ remove address state =
 
 resolve_choice : Tonkadur.Types.State -> Tonkadur.Types.State
 resolve_choice state =
-   {state | last_instruction_effect = PromptChoice}
+   {state | last_instruction_effect = Tonkadur.Types.MustPromptChoice}
 
 set_pc : (
       Tonkadur.Types.Computation ->
       Tonkadur.Types.State ->
       Tonkadur.Types.State
-)
+   )
 set_pc value state =
    {state |
       program_counter =
@@ -238,7 +250,7 @@ set_random : (
       Tonkadur.Types.Computation ->
       Tonkadur.Types.State ->
       Tonkadur.Types.State
-)
+   )
 set_random address min max state =
    let
       (value, next_random_seed) =
@@ -246,6 +258,8 @@ set_random address min max state =
             (Random.int
                (Tonkadur.Types.value_to_int
                   (Tonkadur.Compute.compute state min)
+               )
+               (Tonkadur.Types.value_to_int
                   (Tonkadur.Compute.compute state max)
                )
             )
@@ -255,10 +269,10 @@ set_random address min max state =
    {state |
       memory =
          (Tonkadur.Types.apply_at_address
-            (Tonkadur.Types.value_to_list
+            (Tonkadur.Types.value_to_address
                (Tonkadur.Compute.compute state address)
             )
-            (\last_addr dict -> (Dict.insert last_addr (IntValue value) dict))
+            (\last_addr dict -> (Dict.insert last_addr (Tonkadur.Types.IntValue value) dict))
             state.memory
          ),
 
@@ -270,12 +284,12 @@ set : (
       Tonkadur.Types.Computation ->
       Tonkadur.Types.State ->
       Tonkadur.Types.State
-)
+   )
 set address value state =
    {state |
       memory =
          (Tonkadur.Types.apply_at_address
-            (Tonkadur.Types.value_to_list
+            (Tonkadur.Types.value_to_address
                (Tonkadur.Compute.compute state address)
             )
             (\last_addr dict ->
@@ -295,52 +309,59 @@ set address value state =
 execute : (
       Tonkadur.Types.Instruction ->
       Tonkadur.Types.State ->
-      Tonkadur.Types.State ->
+      Tonkadur.Types.State
    )
 execute instruction state =
-   let new_state = {state | last_instruction_effect = Continue} in
+   let
+      new_state =
+         {state | last_instruction_effect = Tonkadur.Types.MustContinue}
+   in
    case instruction of
-      (AddEventOption name parameters) ->
+      (Tonkadur.Types.AddEventOption name parameters) ->
          (increment_program_counter
             (add_event_option name parameters new_state)
          )
 
-      (AddTextOption label) ->
+      (Tonkadur.Types.AddTextOption label) ->
          (increment_program_counter
-            (add_text_option name parameters new_state)
+            (add_text_option label new_state)
          )
 
-      (Assert condition label) ->
+      (Tonkadur.Types.Assert condition label) ->
          (increment_program_counter
             (assert condition label new_state)
          )
 
-      (Display label) ->
+      (Tonkadur.Types.Display label) ->
          (increment_program_counter (display label new_state))
 
-      End -> (end new_state)
-      (ExtraInstruction name parameters) ->
+      Tonkadur.Types.End -> (end new_state)
+      (Tonkadur.Types.ExtraInstruction name parameters) ->
          (extra_instruction name parameters new_state)
 
-      (Initialize type_name address) ->
+      (Tonkadur.Types.Initialize type_name address) ->
          (increment_program_counter
             (initialize type_name address new_state)
          )
-      (PromptCommand prompt_data) ->
+      (Tonkadur.Types.PromptCommand prompt_data) ->
          (increment_program_counter (prompt_command prompt_data new_state))
 
-      (PromptInteger prompt_data) ->
+      (Tonkadur.Types.PromptInteger prompt_data) ->
          (increment_program_counter (prompt_integer prompt_data new_state))
 
-      (PromptString prompt_data) ->
+      (Tonkadur.Types.PromptString prompt_data) ->
          (increment_program_counter (prompt_string prompt_data new_state))
 
-      (Remove address) -> (increment_program_counter (remove address new_state))
-      ResolveChoice -> (increment_program_counter (resolve_choice new_state))
-      (SetPC value) -> (set_pc value new_state)
-      (SetRandom address min max) ->
+      (Tonkadur.Types.Remove address) ->
+         (increment_program_counter (remove address new_state))
+
+      Tonkadur.Types.ResolveChoice ->
+         (increment_program_counter (resolve_choice new_state))
+
+      (Tonkadur.Types.SetPC value) -> (set_pc value new_state)
+      (Tonkadur.Types.SetRandom address min max) ->
          (increment_program_counter (set_random address min max new_state))
 
-      (Set address value) ->
+      (Tonkadur.Types.Set address value) ->
          (increment_program_counter (set address value new_state))
 
diff --git a/src/Tonkadur/Types.elm b/src/Tonkadur/Types.elm
index ec6c3c2..929d848 100644
--- a/src/Tonkadur/Types.elm
+++ b/src/Tonkadur/Types.elm
@@ -1,9 +1,12 @@
 module Tonkadur.Types exposing (..)
 
 -- Elm -------------------------------------------------------------------------
+import Array
 import Dict
 import List
 
+import Random
+
 --------------------------------------------------------------------------------
 -- TYPES -----------------------------------------------------------------------
 --------------------------------------------------------------------------------
@@ -32,20 +35,20 @@ type Value =
 
 type Option =
    Choice RichText
-   | Event (String, (List Value))
+   | Event String (List Value)
 
 type Computation =
-   AddTextEffect (String, (List Computation), (List Computation))
+   AddTextEffect String (List Computation) (List Computation)
    | Address Computation
-   | Cast (String, String, Computation)
-   | Constant (String, String)
-   | ExtraComputation (String, (List Computation))
-   | IfElse (Computation, Computation, Computation)
+   | Cast String String Computation
+   | Constant String String
+   | ExtraComputation String (List Computation)
+   | IfElse Computation Computation Computation
    | LastChoiceIndex
    | Newline
    | NextAllocableAddress
-   | Operation (String, Computation, Computation)
-   | RelativeAddress (Computation, Computation)
+   | Operation String Computation Computation
+   | RelativeAddress Computation Computation
    | Size Computation
    | Text (List Computation)
    | ValueOf Computation
@@ -57,40 +60,41 @@ type alias PromptInstructionData =
       address : Computation,
       label : Computation
    }
+
 type Instruction =
-   AddEventOption (String, (List Computation))
+   AddEventOption String (List Computation)
    | AddTextOption Computation
-   | Assert (Computation, Computation)
+   | Assert Computation Computation
    | Display Computation
    | End
-   | ExtraInstruction (String, (List Computation))
-   | Initialize (String, Computation)
+   | ExtraInstruction String (List Computation)
+   | Initialize String Computation
    | PromptCommand PromptInstructionData
    | PromptInteger PromptInstructionData
    | PromptString PromptInstructionData
    | Remove Computation
    | ResolveChoice
    | SetPC Computation
-   | SetRandom (Computation, Computation, Computation)
-   | Set (Computation, Computation)
+   | SetRandom Computation Computation Computation
+   | Set Computation Computation
 
 type InstructionEffect =
    MustContinue
    | MustEnd
-   | MustPromptCommand (Value, Value, Value)
-   | MustPromptInteger (Value, Value, Value)
-   | MustPromptString (Value, Value, Value)
+   | MustPromptCommand Value Value Value
+   | MustPromptInteger Value Value Value
+   | MustPromptString Value Value Value
    | MustPromptChoice
    | MustDisplay Value
    | MustDisplayError Value
-   | MustExtraEffect (String, (List Value))
+   | MustExtraEffect String (List Value)
 
 type alias State =
    {
       memory : (Dict.Dict String Value),
       user_types : (Dict.Dict String Value),
       sequences : (Dict.Dict String Int),
-      code : (List Instruction),
+      code : (Array.Array Instruction),
       program_counter : Int,
       allocated_data : Int,
       last_choice_index : Int,
@@ -98,7 +102,8 @@ type alias State =
       memorized_target : Value,
 
       last_instruction_effect : InstructionEffect,
-      freed_addresses : (List String)
+      freed_addresses : (List String),
+      random_seed : Random.Seed
    }
 
 --------------------------------------------------------------------------------
@@ -108,13 +113,13 @@ type alias State =
 --------------------------------------------------------------------------------
 -- EXPORTED --------------------------------------------------------------------
 --------------------------------------------------------------------------------
-new_state : State
-new_state =
+new_state : Int -> State
+new_state random_seed =
    {
       memory = (Dict.empty),
       user_types = (Dict.empty),
       sequences = (Dict.empty),
-      code = [],
+      code = (Array.empty),
       program_counter = 0,
       allocated_data = 0,
       last_choice_index = 0,
@@ -122,7 +127,8 @@ new_state =
       memorized_target = (PointerValue [""]),
 
       last_instruction_effect = MustContinue,
-      freed_addresses = []
+      freed_addresses = [],
+      random_seed = (Random.initialSeed random_seed)
    }
 
 value_to_bool : Value -> Bool
@@ -307,3 +313,7 @@ apply_at_address address fun memory =
 
 allow_continuing : State -> State
 allow_continuing state = {state | last_instruction_effect = MustContinue}
+
+compare_pointers : (List String) -> (List String) -> Int
+compare_pointers p0 p1 = 0
+   -- TODO: implement
diff --git a/src/Update/Story.elm b/src/Update/Story.elm
index bee5cc8..4d1bfaa 100644
--- a/src/Update/Story.elm
+++ b/src/Update/Story.elm
@@ -1,6 +1,5 @@
 module Update.Story exposing
    (
-      new,
       select_choice,
       input_string,
       input_integer,
@@ -8,15 +7,19 @@ module Update.Story exposing
    )
 
 -- Elm -------------------------------------------------------------------------
+import Array
 import Html
 
 -- Local Module ----------------------------------------------------------------
 import Struct.Event
 import Struct.Model
+import Struct.UI
 
 import Util.TonkadurToHtml
 
+-- Tonkadur --------------------------------------------------------------------
 import Tonkadur.Execute
+import Tonkadur.Types
 
 --------------------------------------------------------------------------------
 -- TYPES -----------------------------------------------------------------------
@@ -28,20 +31,21 @@ import Tonkadur.Execute
 step : Struct.Model.Type -> Struct.Model.Type
 step model =
    case model.tonkadur.last_instruction_effect of
-      MustContinue ->
-         (step
-            {model |
-               tonkadur =
-                  (Tonkadur.Execute.execute
-                     model.tonkadur.code[model.tonkadur.program_counter]
-                     model.tonkadur
-                  )
-            }
-         )
+      Tonkadur.Types.MustContinue ->
+         case (Array.get model.tonkadur.program_counter model.tonkadur.code) of
+            (Just instruction) ->
+               (step
+                  {model |
+                     tonkadur =
+                        (Tonkadur.Execute.execute instruction model.tonkadur)
+                  }
+               )
+
+            Nothing -> model -- TODO: error
 
-      MustEnd -> model -- TODO
+      Tonkadur.Types.MustEnd -> model -- TODO
 
-      (MustPromptCommand min max label) ->
+      (Tonkadur.Types.MustPromptCommand min max label) ->
          {model |
             tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
             ui =
@@ -52,7 +56,7 @@ step model =
                )
          }
 
-      (MustPromptInteger min max label) ->
+      (Tonkadur.Types.MustPromptInteger min max label) ->
          {model |
             tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
             ui =
@@ -63,7 +67,7 @@ step model =
                )
          }
 
-      (MustPromptString min max label) ->
+      (Tonkadur.Types.MustPromptString min max label) ->
          {model |
             tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
             ui =
@@ -74,21 +78,20 @@ step model =
                )
          }
 
-      MustPromptChoice ->
-         {model |
-            tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
-            ui =
+      Tonkadur.Types.MustPromptChoice ->
+         let (last_ix, new_ui) =
                (List.foldl
                   (\option (ix, ui) ->
                      case option of
-                        (Choice rich_text) ->
+                        (Tonkadur.Types.Choice rich_text) ->
                            (
                               (ix + 1),
                               (Struct.UI.display_choice
                                  ix
                                  (Util.TonkadurToHtml.convert
-                                    (TextValue rich_text)
+                                    (Tonkadur.Types.TextValue rich_text)
                                  )
+                                 ui
                               )
                            )
 
@@ -97,9 +100,13 @@ step model =
                   (0, model.ui)
                   model.tonkadur.available_options
                )
+         in
+         {model |
+            tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
+            ui = new_ui
          }
 
-      (MustDisplay text) ->
+      (Tonkadur.Types.MustDisplay text) ->
          (step
             {model |
                tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
@@ -111,7 +118,7 @@ step model =
             }
          )
 
-      (MustDisplayError text) ->
+      (Tonkadur.Types.MustDisplayError text) ->
          (step
             {model |
                tonkadur = (Tonkadur.Types.allow_continuing model.tonkadur),
@@ -129,11 +136,18 @@ step model =
 -- EXPORTED --------------------------------------------------------------------
 --------------------------------------------------------------------------------
 
-new : Type
-new =
-   {
-      displayed_text = [],
-      displayed_options = []
-   }
+select_choice : Int -> Struct.Model.Type -> Struct.Model.Type
+select_choice ix model = model
+   -- TODO: implement
+
+input_string : String -> Struct.Model.Type -> Struct.Model.Type
+input_string string model = model
+   -- TODO: implement
 
+input_integer : String -> Struct.Model.Type -> Struct.Model.Type
+input_integer string model = model
+   -- TODO: implement
 
+input_command : String -> Struct.Model.Type -> Struct.Model.Type
+input_command string model = model
+   -- TODO: implement