RubyGems - halunke - Versions diffs - 0.3.1 → 0.4.0 - Mend

halunke 0.3.1 → 0.4.0

Files changed (33) hide show

checksums.yaml +4 -4
data/Gemfile.lock +1 -1
data/docs/_config.yml +2 -0
data/docs/_layouts/default.html +16 -12
data/docs/array.md +65 -0
data/docs/class.md +103 -0
data/docs/dictionary.md +48 -0
data/docs/function.md +18 -0
data/docs/index.md +12 -6
data/docs/number.md +106 -0
data/docs/stdio.md +62 -0
data/docs/string.md +74 -0
data/docs/true-false.md +68 -0
data/docs/web.md +32 -0
data/examples/counter.hal +22 -0
data/examples/hello.hal +1 -1
data/examples/stdio.hal +13 -0
data/lib/halunke/grammar.y +15 -13
data/lib/halunke/interpreter.rb +1 -1
data/lib/halunke/lexer.rb +6 -6
data/lib/halunke/lexer.rl +1 -1
data/lib/halunke/parser.rb +40 -53
data/lib/halunke/runtime.rb +1 -1
data/lib/halunke/runtime/false.hal +3 -0
data/lib/halunke/runtime/harray.rb +10 -4
data/lib/halunke/runtime/hdictionary.rb +15 -6
data/lib/halunke/runtime/hnumber.rb +13 -1
data/lib/halunke/runtime/hstdio.rb +22 -0
data/lib/halunke/runtime/hstring.rb +3 -0
data/lib/halunke/runtime/true.hal +3 -0
data/lib/halunke/version.rb +1 -1
metadata +14 -3
data/lib/halunke/runtime/hstdout.rb +0 -16

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cf23103f236d1d5c248fe1bf071db2e49873fe1
-  data.tar.gz: 03a326bb35a35d4a6711b5e72ab11cd6f55fec40
+  metadata.gz: d378d2686f483584090e764b7d90eeb13b18614c
+  data.tar.gz: 7f280aa4dfe247d55b37b863a8766bf9113fb80f
 SHA512:
-  metadata.gz: dba700ccf46564d88034913a3ff10168cbb6acb0d50abbcf9d3a0f32cdcdb12ccf594b877f0e20fce4d70f1f50df69095ffedfb1ccccefcb07d811c885d66bd8
-  data.tar.gz: 7d641c828755558b4581fccdd536a82bf8ac4434c667c3731d74ad0404f64d31f602f9c66a00d346cc88b07c4a15719fdacd1676345c0d825c734ccf3eafbd4d
+  metadata.gz: 5d1721feb87183a3be4cb3efd2420cb1b4ca5263fcc525413c64ee1884420441761200227f200572a38f24d9b12e1b12f29ccfcafae05d7498cc3179a9a0dd41
+  data.tar.gz: ae52853223039380e48c35eb867f693a88b257f8510b9d79c67e4e0641d89df3489a3104ebffadc0bcdc5a9edcf588dae68f218e82c36a930f0d5e421bdb1340

data/Gemfile.lock CHANGED Viewed

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    halunke (0.3.1)
+    halunke (0.4.0)
       rack (~> 2.0.4)
 GEM

data/docs/_config.yml CHANGED Viewed

@@ -7,5 +7,7 @@ title: Halunke!
 description: >-
   Halunke is a dynamic, object-oriented language that has a simple grammar inspired by Smalltalk and Lisp
+baseurl: "/halunke"
 # Build settings
 markdown: kramdown

data/docs/_layouts/default.html CHANGED Viewed

@@ -10,41 +10,41 @@
   <body>
     <div class="container">
       <nav class="navbar navbar-expand-lg  navbar-dark bg-dark">
-        <a class="navbar-brand" href="#">Halunke!</a>
+        <a class="navbar-brand" href="/halunke">Halunke!</a>
         <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
           <span class="navbar-toggler-icon"></span>
         </button>
-        <div class="collapse navbar-collapse">
+        <div class="collapse navbar-collapse" id="navbarNav">
           <ul class="navbar-nav">
             <li class="nav-item">
-              <a class="nav-link" href="/">Intro</a>
+              <a class="nav-link" href="/halunke">Intro</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/number">Number</a>
+              <a class="nav-link" href="/halunke/number">Number</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/string">String</a>
+              <a class="nav-link" href="/halunke/string">String</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/array">Array</a>
+              <a class="nav-link" href="/halunke/array">Array</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/dictionary">Dictionary</a>
+              <a class="nav-link" href="/halunke/dictionary">Dictionary</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/true-false">True & False</a>
+              <a class="nav-link" href="/halunke/true-false">True & False</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/function">Function</a>
+              <a class="nav-link" href="/halunke/function">Function</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/class">Class</a>
+              <a class="nav-link" href="/halunke/class">Class</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/true-false">Stdio</a>
+              <a class="nav-link" href="/halunke/stdio">Stdio</a>
             </li>
             <li class="nav-item">
-              <a class="nav-link" href="/true-false">Web</a>
+              <a class="nav-link" href="/halunke/web">Web</a>
             </li>
           </ul>
         </div>
@@ -57,5 +57,9 @@
         {{ content }}
       </main>
     </div>
+    <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
+    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
   </body>
 </html>

data/docs/array.md ADDED Viewed

@@ -0,0 +1,65 @@
+---
+title: Array
+---
+In Halunke arrays are collections of objects. The objects do not
+need to be of the same class. Arrays are sorted. They are
+surrounded by square brackets. The items are separated by
+whitespace.
+```
+["a" 1 "b"]
+[
+  "a"
+  5
+]
+```
+It can answer to the following messages:
+## `=`
+Compares to arrays. If they have the same length and each item from
+the first array returns true on the `=` message for the according
+item from the second list, it returns true. Otherwise, it returns
+false. This can also be used to destructure an array.
+**Example:**
+```
+(["a" 1] = ["a" 1]) /* => true */
+(['a 2] = [1 2]) /* => true */
+/* a is now 2 */
+```
+## `map`
+Calls the provided function for each element. Returns a new array of the same
+length with the results of the function calls.
+**Example:**
+```
+([0 1 2] map { |'x| (x + 1) }) /* => [1 2 3] */
+```
+## `to_s`
+This returns a string to represent the array in output.
+**Example:**
+```
+([0 1 2] to_s) /* => "0\n1\n2" */
+```
+## `inspect`
+This returns a string to represent the array for debugging.
+**Example:**
+```
+([0 1 2] inspect) /* => "[0 1 2]" */
+```

data/docs/class.md ADDED Viewed

@@ -0,0 +1,103 @@
+---
+title: Class
+---
+In Halunke, Classes are objects. They consist of a dictionary that
+maps message names to functions. Objects are a wrapper around a
+dictionary. The dictionary contains the attributes of the object.
+The object knows its class, and when messages are send to the
+object, it will look up the according function in its class and
+call it.
+Classes are created by sending a message to the Class object. One
+of these messages is `new attributes methods`. Let's create a
+class:
+```
+(Class new 'Counter
+    attributes ["value"]
+    methods @[
+        "value" { |'self|
+            (self @ "value" else 0)
+        }
+    ]
+)
+```
+To create an instance of the class, we send the `new` message to
+the class with a dictionary that represents the attributes:
+```
+('counter = (Counter new @["value" 0]))
+```
+Now we can send the `value` message to our counter, and we will
+receive 0:
+```
+(counter value)
+```
+In our class definition, we first gave an array of attributes. You
+can imagine it as kind of whitelist for attributes: The attribute
+dictionary you pass to new can only have keys that are on this
+list. Now let's look at the function that is called when you send
+the value message:
+```
+{ |'self| (self @ "value" else 0) }
+```
+Every function that is used as a method receives the object itself
+as its first argument. This can be used to send messages to the
+object itself. Each object can receive the `@ else` message. This
+is used to look up attributes in the dictionary. Our function
+therefore returns the value attribute or 0, if it was not set.
+Now let's add a method to increase the counter. Remember that objects
+are immutable. So we need to return a new counter with the value
+that is one higher than our current value:
+```
+"increase" { |'self|
+    (Counter new @["value" ((self value) + 1)])
+}
+```
+We can use it like this:
+```
+('counter = (Counter new @["value" 0]))
+('increased_counter = (counter increase))
+```
+The `'increased_counter` will return `1` as its value.
+Now you might want to have a custom constructor that needs less typing and is
+more expressive. You can do that by introducing a class method that calls the
+`new` method. Class methods receive the class as the first parameter.
+```
+(Class new 'Counter
+    attributes ["value"]
+    methods @[
+      "value" { |'self|
+          (self @ "value" else 0)
+      }
+      "increase" { |'self|
+          (Counter new @["value" ((self value) + 1)])
+      }
+    ]
+    class_methods @[
+      "from" { |'self 'value|
+        (self new @["value" value])
+      }
+    ]
+)
+```
+Now we can create a counter like this:
+```
+('counter = (Counter from 5))
+```

data/docs/dictionary.md ADDED Viewed

@@ -0,0 +1,48 @@
+---
+title: Dictionary
+---
+In Halunke, dictionaries are collections of objects that map values
+to other values. The first entry is the key for the second entry,
+the third for the fourth etc. (the number of elements is therefore
+always even). Like in a real dictionary, you can then look them up
+Like in a real dictionary, you can then look them up. They are
+written in square brackets, prefixed with an `@`.
+```
+@["a" 1 "b" 2]
+```
+It can answer to the following message:
+## `@ else`
+Looks up a value in the dictionary. If the key is not in the
+dictionary, the fallback value is used.
+**Example:**
+```
+(@["a" 1 "b" 2] @ "a" else "Not Found") /* => 1 */
+(@["a" 1 "b" 2] @ "c" else "Not Found") /* => "Not Found" */
+```
+## `to_s`
+This returns a string to represent the dictionary in output.
+**Example:**
+```
+(@["a" 1 "b" 2] to_s) /* => "a 1\nb 2" */
+```
+## `inspect`
+This returns a string to represent the dictionary for debugging.
+**Example:**
+```
+(@["a" 1 "b" 2] inspect) /* => "@[\"a\" 1 \"b\" 2]" */
+```

data/docs/function.md ADDED Viewed

@@ -0,0 +1,18 @@
+---
+title: Function
+---
+This is how you define a function:
+```
+('fn = { |'a 'b| (a + b) })
+```
+This is a function that expects two arguments. Functions in Halunke are
+Objects. If you want to invoke a function, you send them the `call` message
+with an array with the arguments (in our case two):
+```
+(fn call [1 2])
+/* => 6 */
+```

data/docs/index.md CHANGED Viewed

@@ -57,12 +57,13 @@ works like this:
 This will return `"Spelunke!"`. The message we send here is `replace with` and
 the value is `["Ha" "Spe"]`.
-If you want to find out more about the types of objects in Halunke and the
-messages you can send to them, explore the navigation bar at the top. If you
-want to learn more about conditionals, check out the section about [True &
-False](/true-false). If you want to write your own functions, check out
-[Function](/function) and if you want to define your own classes, check out
-[Class](/class).
+If you want to find out more about the types of objects in Halunke
+and the messages you can send to them, explore the navigation bar
+at the top. If you want to learn more about conditionals, check out
+the section about [True & False](/halunke/true-false). If you want
+to write your own functions, check out
+[Function](/halunke/function) and if you want to define your own
+classes, check out [Class](/halunke/class).
 If you want to store an object in a variable, you can do it like this:
@@ -75,3 +76,8 @@ Now you can send messages to `a` like `(a + 2)`. Why is there a `'` though? The
 with a value, and it will assign it. Be aware that you can't reassign. So if
 you assign something to a once, it will stay like this forever (within that
 scope). Reassigning will result in an error.
+The values are also immutable. If you send a message to an object,
+it will not change the object, but it will return an answer to you.
+Comments are written between `/*` and `*/`. They can be multiline.

data/docs/number.md ADDED Viewed

@@ -0,0 +1,106 @@
+---
+title: Number
+---
+In Halunke all numbers are rational. You write them as decimal numbers:
+```
+2
+-3
+2.12
+```
+It can answer to the following messages:
+## `+`
+This adds two numbers.
+**Example:**
+```
+(0.6 + 0.3) /* => 0.9 */
+```
+## `-`
+This subtracts two numbers.
+**Example:**
+```
+(0.6 - 0.3) /* => 0.3 */
+```
+## `/`
+This divides two numbers.
+**Example:**
+```
+(0.6 / 0.3) /* => 2 */
+```
+## `*`
+This multiplies two numbers.
+**Example:**
+```
+(0.6 * 0.3) /* => 0.18 */
+```
+## `<`
+This compares two numbers. It is true, if the first number is smaller than the
+second number. Otherwise, it is false.
+**Example:**
+```
+(0.6 < 0.3) /* => false */
+```
+## `>`
+This compares two numbers. It is true, if the first number is greater than the
+second number. Otherwise, it is false.
+**Example:**
+```
+(0.6 > 0.3) /* => true */
+```
+## `=`
+This compares two numbers. It is true, if the two numbers are equal. Otherwise,
+it is false.
+**Example:**
+```
+(0.6 = 0.3) /* => false */
+```
+## `to_s`
+This returns a string to represent the number in output.
+**Example:**
+```
+(0.6 to_s) /* => "0.6" */
+```
+## `inspect`
+This returns a string to represent the number for debugging.
+**Example:**
+```
+(0.6 inspect) /* => "0.6" */
+```

data/docs/stdio.md ADDED Viewed

@@ -0,0 +1,62 @@
+---
+title: Stdio
+---
+The object `stdio` is available from everywhere. *This will change in the
+future. Interacting with STDIO is IO and will be isolated.*
+## `puts`
+Prints the object to stdout. To determine how to represent the object, it will
+send the `to_s` message to the object, expecting a string.
+**Example:**
+```
+(stdio puts "Hello World")
+(stdio puts 5.2)
+(stdio puts @["a" 2 "b" 3])
+(stdio puts ["a" "b"])
+(stdio puts true)
+(stdio puts false)
+```
+This will output:
+```
+Hello World
+5.2
+a 2
+b 3
+a
+b
+true
+false
+```
+## `p`
+Prints the object to stdout for debugging. To determine how to represent the
+object, it will send the `inspect` message to the object, expecting a string.
+**Example:**
+```
+(stdio p "Hello World")
+(stdio p 5.2)
+(stdio p @["a" 2 "b" 3])
+(stdio p ["a" "b"])
+(stdio p true)
+(stdio p false)
+```
+This will output:
+```
+"Hello World"
+5.2
+@["a" 2 "b" 3]
+["a" "b"]
+true
+false
+```

data/docs/string.md ADDED Viewed

@@ -0,0 +1,74 @@
+---
+title: String
+---
+In Halunke strings are used to represent all kinds of text
+including single characters. They are surrounded by double quotes
+(single quotes are not allowed).
+```
+"Foo Bar"
+```
+It can answer to the following messages:
+## `reverse`
+Return a reversed version of the String.
+**Example:**
+```
+("hello" reverse) /* => "olleh" */
+```
+## `replace with`
+Replace all occurrences of the first string with the second string.
+**Example:**
+```
+("ababab" replace "a" with "c") /* => "cbcbcb" */
+```
+## `=`
+This compares two strings. It is true, if the two strings are equal. Otherwise,
+it is false.
+**Example:**
+```
+("aaa" = "aaa") /* => true */
+```
+## `+`
+Concatenate two strings.
+**Example:**
+```
+("aaa" + "bbb") /* => "aaabbb" */
+```
+## `to_s`
+This returns the string itself.
+**Example:**
+```
+("aaa" to_s) /* => "aaa" */
+```
+## `inspect`
+This returns a string to represent the string in output. This is done by surrounding it with `"`
+**Example:**
+```
+("aaa" inspect) /* => "\"aaa\"" */
+```

data/docs/true-false.md ADDED Viewed

@@ -0,0 +1,68 @@
+---
+title: True & False
+---
+In Halunke `true` is an instance of the `True` class, and `false`
+is an instance of the `False` class. They are used to realize
+boolean operations (for example `and`) as well as for branching.
+They answer to the same messages. So you could use it like this:
+```
+((5 > 3) then { "yes!" } else { "no!" })
+/* Returns "yes!" */
+```
+## `and`
+Returns true if both the receiver as well as the provided value are
+true.
+**Example:**
+```
+((5 > 3) and (2 < 1)) /* => false */
+```
+## `or`
+Returns true if either the receiver or the provided value are true.
+**Example:**
+```
+((5 > 3) or (2 < 1)) /* => true */
+```
+## `then else`
+If the receiver is true, it will execute the first branch. If it is
+false, it will return the second branch.
+**Example:**
+```
+(true then { "yes" } else { "no" }) /* => "yes" */
+(false then { "yes" } else { "no" }) /* => "no" */
+```
+## `to_s`
+This returns a string to represent true and false in output.
+**Example:**
+```
+(true to_s) /* => "true" */
+(false to_s) /* => "false" */
+```
+## `inspect`
+This returns a string to represent true and false for debugging.
+**Example:**
+```
+(true inspect) /* => "true" */
+(false inspect) /* => "false" */
+```

data/docs/web.md ADDED Viewed

@@ -0,0 +1,32 @@
+---
+title: Web
+---
+The object `web` is available from everywhere. *This will change in the future.
+Interacting with STDIO is IO and will be isolated.*
+You can send the `run on` message to `web`. It expects the first object to be
+your application (more on that later) and the second one the bind address and
+port in the format: `0.0.0.0:3000`.
+Your app needs to be an object that can receive the `call` message. It will be
+called with the environment dictionary that represents the request. It expects
+that your return an array that represents the response.
+## Environment Dictionary
+The environment dictionary has the following keys:
+* `request_method`: The request method in upper case (for example: `"GET"`)
+* `path`: The path that was requested (for example: `"/the/path"`)
+* `query`: The query part of the request (for example: `"foo=bar&beep=boop"`)
+## Response Array
+The response array has three elements:
+1. The first element is the status code as a String (for example: `"200"`)
+2. The second element are the headers as a dictionary (for example: `@[
+   "Content-Type" "text/html" ]`)
+3. The third element is an array of strings that represent the body (for
+   example: `[ "<h1>Halunke!</h1>" ]`)

data/examples/counter.hal ADDED Viewed

@@ -0,0 +1,22 @@
+(Class new 'Counter
+    attributes ["value"]
+    methods @[
+      "value" { |'self|
+          (self @ "value" else 0)
+      }
+      "increase" { |'self|
+          (Counter new @["value" ((self value) + 1)])
+      }
+    ]
+    class_methods @[
+      "from" { |'self 'value|
+        (self new @["value" value])
+      }
+    ]
+)
+('counter = (Counter from 0))
+(stdio puts (counter value))
+('increased_counter = (counter increase))
+(stdio puts (increased_counter value))

data/examples/hello.hal CHANGED Viewed

@@ -16,4 +16,4 @@
 )
 ('greeter = (Greeter for "World"))
-(stdout puts (greeter greet))
+(stdio puts (greeter greet))

data/examples/stdio.hal ADDED Viewed

@@ -0,0 +1,13 @@
+(stdio puts "Hello World")
+(stdio puts 5.2)
+(stdio puts @["a" 2 "b" 3])
+(stdio puts ["a" "b"])
+(stdio puts true)
+(stdio puts false)
+(stdio p "Hello World")
+(stdio p 5.2)
+(stdio p @["a" 2 "b" 3])
+(stdio p ["a" "b"])
+(stdio p true)
+(stdio p false)

data/lib/halunke/grammar.y CHANGED Viewed

@@ -15,27 +15,29 @@ token BAR
 token START_COMMENT
 token END_COMMENT
+options no_result_var
 rule
   Program:
-    Expressions { result = val[0] }
+    Expressions { val[0] }
   ;
   Expressions:
-    /* empty */            { result = Nodes.new([]) }
-  | Expression Expressions { result = Nodes.new([val[0]].concat(val[1].nodes)) }
+    /* empty */            { Nodes.new([]) }
+  | Expression Expressions { Nodes.new([val[0]].concat(val[1].nodes)) }
   ;
   Expression:
-    NUMBER                                                 { result = NumberNode.new(val[0]) }
-  | STRING                                                 { result = StringNode.new(val[0]) }
-  | BAREWORD                                               { result = BarewordNode.new(val[0]) }
-  | UNASSIGNED_BAREWORD                                    { result = UnassignedNode.new(BarewordNode.new(val[0])) }
-  | START_COMMENT Expressions END_COMMENT                  { result = Nodes.new([]) }
-  | OPEN_CURLY Expressions CLOSE_CURLY                     { result = FunctionNode.new(ArrayNode.new([]), val[1]) }
-  | OPEN_CURLY BAR Expressions BAR Expressions CLOSE_CURLY { result = FunctionNode.new(val[2].to_array, val[4]) }
-  | OPEN_PAREN Expression Expressions CLOSE_PAREN          { result = MessageSendNode.new(val[1], val[2].to_message) }
-  | OPEN_BRACKET Expressions CLOSE_BRACKET                 { result = val[1].to_array }
-  | OPEN_DICT_BRACKET Expressions CLOSE_BRACKET            { result = val[1].to_dictionary }
+    NUMBER                                                 { NumberNode.new(val[0]) }
+  | STRING                                                 { StringNode.new(val[0]) }
+  | BAREWORD                                               { BarewordNode.new(val[0]) }
+  | UNASSIGNED_BAREWORD                                    { UnassignedNode.new(BarewordNode.new(val[0])) }
+  | START_COMMENT Expressions END_COMMENT                  { Nodes.new([]) }
+  | OPEN_CURLY Expressions CLOSE_CURLY                     { FunctionNode.new(ArrayNode.new([]), val[1]) }
+  | OPEN_CURLY BAR Expressions BAR Expressions CLOSE_CURLY { FunctionNode.new(val[2].to_array, val[4]) }
+  | OPEN_PAREN Expression Expressions CLOSE_PAREN          { MessageSendNode.new(val[1], val[2].to_message) }
+  | OPEN_BRACKET Expressions CLOSE_BRACKET                 { val[1].to_array }
+  | OPEN_DICT_BRACKET Expressions CLOSE_BRACKET            { val[1].to_dictionary }
   ;
 end

data/lib/halunke/interpreter.rb CHANGED Viewed

@@ -17,7 +17,7 @@ module Halunke
       @root_context["Array"] = Halunke::Runtime::HArray
       @root_context["Dictionary"] = Halunke::Runtime::HDictionary
       @root_context["UnassignedBareword"] = Halunke::Runtime::HUnassignedBareword
-      @root_context["stdout"] = Halunke::Runtime::HStdout.create_instance
+      @root_context["stdio"] = Halunke::Runtime::HStdio.create_instance
       @root_context["web"] = Halunke::Runtime::HWeb.create_instance
       preludes.each do |prelude|

data/lib/halunke/lexer.rb CHANGED Viewed

@@ -99,10 +99,10 @@ self._lexer_trans_actions = [
 	13, 0, 0, 0, 0, 0, 19, 21,
 	0, 15, 29, 17, 31, 5, 9, 0,
 	0, 33, 7, 0, 47, 47, 47, 45,
-	27, 39, 5, 37, 0, 5, 35, 0,
-	35, 25, 39, 23, 37, 0, 0, 0,
-	37, 43, 41, 39, 45, 39, 37, 35,
-	35, 39, 37, 37, 0
+	27, 37, 5, 37, 0, 5, 35, 0,
+	35, 25, 37, 23, 37, 0, 0, 0,
+	37, 43, 41, 39, 45, 37, 37, 35,
+	35, 37, 37, 37, 0
 ]
 class << self
@@ -128,8 +128,8 @@ class << self
 	private :_lexer_eof_trans, :_lexer_eof_trans=
 end
 self._lexer_eof_trans = [
-	50, 51, 0, 58, 53, 58, 60, 57,
-	57, 58, 60, 60
+	50, 51, 0, 52, 53, 60, 60, 57,
+	57, 60, 60, 60
 ]
 class << self

data/lib/halunke/lexer.rl CHANGED Viewed

@@ -5,7 +5,7 @@
   number = ('+'|'-')?[0-9]+('.'[0-9]+)?;
   string = '"' [^"]* '"';
   unassigned_bareword = "'" [a-zA-Z_]+;
-  bareword = [a-zA-Z_]+ | '+' | '-' | '<' | '>' | '=' | '@';
+  bareword = [a-zA-Z_]+ | '+' | '-' | '*' | '/' | '<' | '>' | '=' | '@';
   open_paren = '(';
   close_paren = ')';
   open_curly = '{';

data/lib/halunke/parser.rb CHANGED Viewed

@@ -13,7 +13,7 @@ require "halunke/nodes"
 module Halunke
   class Parser < Racc::Parser
-module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 48)
+module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 50)
 def parse(code)
   @tokens = Lexer.new.tokenize(code)
@@ -124,7 +124,7 @@ racc_token_table = {
 racc_nt_base = 16
-racc_use_result_var = true
+racc_use_result_var = false
 Racc_arg = [
   racc_action_table,
@@ -170,98 +170,85 @@ Racc_debug_parser = false
 # reduce 0 omitted
-module_eval(<<'.,.,', 'grammar.y', 19)
-  def _reduce_1(val, _values, result)
-     result = val[0]
-    result
+module_eval(<<'.,.,', 'grammar.y', 21)
+  def _reduce_1(val, _values)
+     val[0]
   end
 .,.,
-module_eval(<<'.,.,', 'grammar.y', 23)
-  def _reduce_2(val, _values, result)
-     result = Nodes.new([])
-    result
+module_eval(<<'.,.,', 'grammar.y', 25)
+  def _reduce_2(val, _values)
+     Nodes.new([])
   end
 .,.,
-module_eval(<<'.,.,', 'grammar.y', 24)
-  def _reduce_3(val, _values, result)
-     result = Nodes.new([val[0]].concat(val[1].nodes))
-    result
-  end
-.,.,
-module_eval(<<'.,.,', 'grammar.y', 28)
-  def _reduce_4(val, _values, result)
-     result = NumberNode.new(val[0])
-    result
-  end
-.,.,
-module_eval(<<'.,.,', 'grammar.y', 29)
-  def _reduce_5(val, _values, result)
-     result = StringNode.new(val[0])
-    result
+module_eval(<<'.,.,', 'grammar.y', 26)
+  def _reduce_3(val, _values)
+     Nodes.new([val[0]].concat(val[1].nodes))
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 30)
-  def _reduce_6(val, _values, result)
-     result = BarewordNode.new(val[0])
-    result
+  def _reduce_4(val, _values)
+     NumberNode.new(val[0])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 31)
-  def _reduce_7(val, _values, result)
-     result = UnassignedNode.new(BarewordNode.new(val[0]))
-    result
+  def _reduce_5(val, _values)
+     StringNode.new(val[0])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 32)
-  def _reduce_8(val, _values, result)
-     result = Nodes.new([])
-    result
+  def _reduce_6(val, _values)
+     BarewordNode.new(val[0])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 33)
-  def _reduce_9(val, _values, result)
-     result = FunctionNode.new(ArrayNode.new([]), val[1])
-    result
+  def _reduce_7(val, _values)
+     UnassignedNode.new(BarewordNode.new(val[0]))
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 34)
-  def _reduce_10(val, _values, result)
-     result = FunctionNode.new(val[2].to_array, val[4])
-    result
+  def _reduce_8(val, _values)
+     Nodes.new([])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 35)
-  def _reduce_11(val, _values, result)
-     result = MessageSendNode.new(val[1], val[2].to_message)
-    result
+  def _reduce_9(val, _values)
+     FunctionNode.new(ArrayNode.new([]), val[1])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 36)
-  def _reduce_12(val, _values, result)
-     result = val[1].to_array
-    result
+  def _reduce_10(val, _values)
+     FunctionNode.new(val[2].to_array, val[4])
   end
 .,.,
 module_eval(<<'.,.,', 'grammar.y', 37)
-  def _reduce_13(val, _values, result)
-     result = val[1].to_dictionary
-    result
+  def _reduce_11(val, _values)
+     MessageSendNode.new(val[1], val[2].to_message)
+  end
+.,.,
+module_eval(<<'.,.,', 'grammar.y', 38)
+  def _reduce_12(val, _values)
+     val[1].to_array
+  end
+.,.,
+module_eval(<<'.,.,', 'grammar.y', 39)
+  def _reduce_13(val, _values)
+     val[1].to_dictionary
   end
 .,.,
-def _reduce_none(val, _values, result)
+def _reduce_none(val, _values)
   val[0]
 end

data/lib/halunke/runtime.rb CHANGED Viewed

@@ -7,5 +7,5 @@ require "halunke/runtime/hstring"
 require "halunke/runtime/harray"
 require "halunke/runtime/hdictionary"
 require "halunke/runtime/hunassigned_bareword"
-require "halunke/runtime/hstdout"
+require "halunke/runtime/hstdio"
 require "halunke/runtime/hweb"

data/lib/halunke/runtime/false.hal CHANGED Viewed

@@ -9,6 +9,9 @@
     "then else" { |'self 'true_branch 'false_branch|
       (false_branch call [])
     }
+    "to_s" { |'self 'other|
+      "false"
+    }
     "inspect" { |'self 'other|
       "false"
     }

data/lib/halunke/runtime/harray.rb CHANGED Viewed

@@ -4,10 +4,6 @@ module Halunke
       "Array",
       [],
       {
-        "inspect" => HFunction.new([:self], lambda { |context|
-          inspected_members = context["self"].ruby_value.map { |member| member.inspect(context) }
-          HString.create_instance("[#{inspected_members.join(' ')}]")
-        }),
         "=" => HFunction.new([:self, :other], lambda { |context|
           return context["false"] if context["self"].ruby_value.length != context["other"].ruby_value.length
@@ -21,6 +17,16 @@ module Halunke
           return HArray.create_instance(context["self"].ruby_value.map do |x|
             context["fn"].receive_message(context, "call", [HArray.create_instance([x])])
           end)
+        }),
+        "to_s" => HFunction.new([:self], lambda { |context|
+          inspected_members = context["self"].ruby_value.map do |member|
+            member.receive_message(context, "to_s", []).ruby_value
+          end
+          HString.create_instance("#{inspected_members.join("\n")}")
+        }),
+        "inspect" => HFunction.new([:self], lambda { |context|
+          inspected_members = context["self"].ruby_value.map { |member| member.inspect(context) }
+          HString.create_instance("[#{inspected_members.join(' ')}]")
         })
       },
       {},

data/lib/halunke/runtime/hdictionary.rb CHANGED Viewed

@@ -4,6 +4,21 @@ module Halunke
       "Dictionary",
       [],
       {
+        "@ else" => HFunction.new([:self, :search, :fallback], lambda { |context|
+          result = context["self"].ruby_value.find do |key, _value|
+            key.receive_message(context, "=", [context["search"]]).inspect(context) == "true"
+          end
+          result ? result[1] : context["fallback"]
+        }),
+        "to_s" => HFunction.new([:self], lambda { |context|
+          x = []
+          context["self"].ruby_value.each_pair do |key, value|
+            key_s = key.receive_message(context, "to_s", [])
+            value_s = value.receive_message(context, "to_s", [])
+            x.push("#{key_s.ruby_value} #{value_s.ruby_value}")
+          end
+          HString.create_instance(x.join("\n"))
+        }),
         "inspect" => HFunction.new([:self], lambda { |context|
           x = []
           context["self"].ruby_value.each_pair do |key, value|
@@ -11,12 +26,6 @@ module Halunke
             x.push(value.inspect(context))
           end
           HString.create_instance("@[#{x.join(' ')}]")
-        }),
-        "@ else" => HFunction.new([:self, :search, :fallback], lambda { |context|
-          result = context["self"].ruby_value.find do |key, _value|
-            key.receive_message(context, "=", [context["search"]]).inspect(context) == "true"
-          end
-          result ? result[1] : context["fallback"]
         })
       },
       {},

data/lib/halunke/runtime/hnumber.rb CHANGED Viewed

@@ -7,6 +7,15 @@ module Halunke
         "+" => HFunction.new([:self, :other], lambda { |context|
           HNumber.create_instance(context["self"].ruby_value + context["other"].ruby_value)
         }),
+        "-" => HFunction.new([:self, :other], lambda { |context|
+          HNumber.create_instance(context["self"].ruby_value - context["other"].ruby_value)
+        }),
+        "/" => HFunction.new([:self, :other], lambda { |context|
+          HNumber.create_instance(context["self"].ruby_value / context["other"].ruby_value)
+        }),
+        "*" => HFunction.new([:self, :other], lambda { |context|
+          HNumber.create_instance(context["self"].ruby_value * context["other"].ruby_value)
+        }),
         "<" => HFunction.new([:self, :other], lambda { |context|
           if context["self"].ruby_value < context["other"].ruby_value
             context["true"]
@@ -28,10 +37,13 @@ module Halunke
             context["false"]
           end
         }),
-        "inspect" => HFunction.new([:self], lambda { |context|
+        "to_s" => HFunction.new([:self], lambda { |context|
           float_value = context["self"].ruby_value.to_f
           float_value = float_value.to_i if float_value.to_i == float_value
           HString.create_instance(float_value.to_s)
+        }),
+        "inspect" => HFunction.new([:self], lambda { |context|
+          context["self"].receive_message(context, "to_s", [])
         })
       },
       {},

data/lib/halunke/runtime/hstdio.rb ADDED Viewed

@@ -0,0 +1,22 @@
+module Halunke
+  module Runtime
+    HStdio = HClass.new(
+      "Stdio",
+      [],
+      {
+        "puts" => HFunction.new([:self, :obj], lambda { |context|
+          str = context["obj"].receive_message(context, "to_s", [])
+          puts str.ruby_value
+          str
+        }),
+        "p" => HFunction.new([:self, :obj], lambda { |context|
+          str = context["obj"].receive_message(context, "inspect", [])
+          puts str.ruby_value
+          context["obj"]
+        })
+      },
+      {},
+      true
+    )
+  end
+end

data/lib/halunke/runtime/hstring.rb CHANGED Viewed

@@ -24,6 +24,9 @@ module Halunke
         "+" => HFunction.new([:self, :other], lambda { |context|
           HString.create_instance(context["self"].ruby_value + context["other"].ruby_value)
         }),
+        "to_s" => HFunction.new([:self], lambda { |context|
+          context["self"]
+        }),
         "inspect" => HFunction.new([:self], lambda { |context|
           HString.create_instance(context["self"].ruby_value.inspect)
         })

data/lib/halunke/runtime/true.hal CHANGED Viewed

@@ -9,6 +9,9 @@
     "then else" { |'self 'true_branch 'false_branch|
       (true_branch call [])
     }
+    "to_s" { |'self 'other|
+      "true"
+    }
     "inspect" { |'self 'other|
       "true"
     }

data/lib/halunke/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Halunke
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: halunke
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Lucas Dohmen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-02-10 00:00:00.000000000 Z
+date: 2018-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -104,8 +104,19 @@ files:
 - docs/Gemfile.lock
 - docs/_config.yml
 - docs/_layouts/default.html
+- docs/array.md
+- docs/class.md
+- docs/dictionary.md
+- docs/function.md
 - docs/index.md
+- docs/number.md
+- docs/stdio.md
+- docs/string.md
+- docs/true-false.md
+- docs/web.md
+- examples/counter.hal
 - examples/hello.hal
+- examples/stdio.hal
 - examples/web.hal
 - exe/halunke
 - halunke.gemspec
@@ -125,7 +136,7 @@ files:
 - lib/halunke/runtime/hnative_object.rb
 - lib/halunke/runtime/hnumber.rb
 - lib/halunke/runtime/hobject.rb
-- lib/halunke/runtime/hstdout.rb
+- lib/halunke/runtime/hstdio.rb
 - lib/halunke/runtime/hstring.rb
 - lib/halunke/runtime/hunassigned_bareword.rb
 - lib/halunke/runtime/hweb.rb

data/lib/halunke/runtime/hstdout.rb DELETED Viewed

@@ -1,16 +0,0 @@
-module Halunke
-  module Runtime
-    HStdout = HClass.new(
-      "Stdout",
-      [],
-      {
-        "puts" => HFunction.new([:self, :str], lambda { |context|
-          puts context["str"].ruby_value
-          context["str"]
-        })
-      },
-      {},
-      true
-    )
-  end
-end