Create draft of parser in main code.

src/chalk.cr

@@ -1,6 +1,171 @@
 require "./chalk/*"
 
-# TODO: Write documentation for `Chalk`
 module Chalk
-  # TODO: Put your code here
+    lexer = Lexer.new
+    tokens = lexer.lex(File.read("test.txt"))
+
+    def self.create_op(atom, op)
+        pl = PlaceholderParser(Tree).new
+        recurse = atom.then(op).then(pl).transform do |arr|
+            arr = arr.flatten
+            TreeOp.new(
+                arr[1].as(Token).type,
+                arr[0].as(Tree),
+                arr[2].as(Tree)).as(Tree)
+        end
+        pl.parser = either(recurse, atom)
+        return pl
+    end
+
+    def self.create_ops(source, ops)
+        ops.reduce(source) do |previous, current|
+            create_op(previous, current)
+        end
+    end
+
+    def self.create_type
+        either(type(TokenType::KwU0), type(TokenType::KwU8), type(TokenType::KwU12))
+    end
+
+    def self.create_lit
+        dec_parser = type(TokenType::LitDec).transform &.string.to_i64
+        hex_parser = type(TokenType::LitHex).transform &.string.lchop("0x").to_i64(16)
+        bin_parser = type(TokenType::LitBin).transform &.string.lchop("0b").to_i64(2)
+        lit_parser = either(dec_parser, hex_parser, bin_parser).transform { |it| TreeLit.new(it).as(Tree) }
+        return lit_parser
+    end
+
+    def self.create_call(expr)
+        call = type(TokenType::Id).then(char '(').then(delimited(expr, char ',')).then(char ')').transform do |arr|
+            arr = arr.flatten
+            name = arr[0].as(Token).string
+            params = arr[2..arr.size - 2].map &.as(Tree)
+            TreeCall.new(name, params).as(Tree)
+        end
+        return call
+    end
+
+    def self.create_block(statement)
+        block = char('{').then(many(statement)).then(char '}').transform do |arr|
+            arr = arr.flatten
+            params = arr[1..arr.size - 2].map &.as(Tree)
+            TreeBlock.new(params).as(Tree)
+        end
+        return block
+    end
+
+    def self.create_if(expr, block)
+        iff = type(TokenType::KwIf).then(char '(').then(expr).then(char ')').then(block)
+                                   .then(optional(type(TokenType::KwElse).then(block)))
+                                   .transform do |arr|
+            arr = arr.flatten
+            cond = arr[2].as(Tree)
+            code = arr[4].as(Tree)
+            otherwise = arr.size == 7 ? arr[6].as(Tree) : nil
+            TreeIf.new(cond, code, otherwise).as(Tree)
+        end
+        return iff
+    end
+
+    def self.create_while(expr, block)
+        whilee = type(TokenType::KwWhile).then(char '(').then(expr).then(char ')').then(block).transform do |arr|
+            arr = arr.flatten
+            cond = arr[2].as(Tree)
+            code = arr[4].as(Tree)
+            TreeWhile.new(cond, code).as(Tree)
+        end
+        return whilee
+    end
+
+    def self.create_return(expr)
+        returnn = type(TokenType::KwReturn).then(expr).then(char ';').transform do |arr|
+            arr = arr.flatten
+            value = arr[1].as(Tree)
+            TreeReturn.new(value).as(Tree)
+        end
+        return returnn
+    end
+
+    def self.create_func(block, type)
+        func = type(TokenType::KwFun).then(type(TokenType::Id))
+            .then(char '(').then(delimited(type(TokenType::Id), char ',')).then(char ')')
+            .then(char ':').then(type)
+            .then(block).transform do |arr|
+            arr = arr.flatten
+            name = arr[1].as(Token).string
+            params = arr[3..arr.size - 5].map &.as(Token).string
+            code = arr[arr.size - 1].as(Tree)
+            type = arr[arr.size - 2].as(Token).type
+            TreeFunction.new(name, params, code).as(Tree)
+        end
+        return func
+    end
+
+    def self.create_var(expr)
+        var = type(TokenType::KwVar).then(type(TokenType::Id)).then(char '=').then(expr).then(char ';').transform do |arr|
+            arr = arr.flatten
+            name = arr[1].as(Token).string
+            exp = arr[arr.size - 2].as(Tree)
+            TreeVar.new(name, exp).as(Tree)
+        end
+        return var
+    end
+
+    def self.create_assign(expr)
+        assign = type(TokenType::Id).then(char '=').then(expr).then(char ';').transform do |arr|
+            arr = arr.flatten
+            name = arr[0].as(Token).string
+            exp = arr[arr.size - 2].as(Tree)
+            TreeAssign.new(name, exp).as(Tree)
+        end
+        return assign
+    end
+
+    def self.create_basic(expr)
+        basic = expr.then(char ';').transform do |arr|
+            arr.flatten[0].as(Tree)
+        end
+        return basic
+    end
+
+    def self.create_expression
+        expr_place = PlaceholderParser(Tree).new
+        literal = create_lit
+        id = type(TokenType::Id).transform { |it| TreeId.new(it.string).as(Tree) }
+        call = create_call(expr_place)
+        atom = either(literal, call, id)
+
+        ops = [ either(type(TokenType::OpMul), type(TokenType::OpDiv)),
+                either(type(TokenType::OpAdd), type(TokenType::OpSub)),
+                type(TokenType::OpXor),
+                type(TokenType::OpAnd),
+                type(TokenType::OpOr) ]
+        expr = create_ops(atom, ops)
+        expr_place.parser = expr
+
+        return expr
+    end
+
+    def self.create_block
+        expr = create_expression
+
+        statement_place = PlaceholderParser(Tree).new
+        block = create_block(statement_place)
+        iff = create_if(expr, block)
+        whilee = create_while(expr, block)
+        returnn = create_return(expr)
+        var = create_var(expr)
+        assign = create_assign(expr)
+        basic = create_basic(expr)
+        statement = either(basic, var, assign, block, iff, whilee, returnn)
+        statement_place.parser = statement
+
+        return block
+    end
+
+    func = create_func(create_block, create_type)
+    body = many(func)
+
+    final = body
+    final.parse(tokens, 0)[0].each &.accept(PrintVisitor.new)
 end