Implement booleans

lib/chervil/ast.rb

 module Chervil
   module AST
     require "chervil/ast/application"
+    require "chervil/ast/boolean"
     require "chervil/ast/definition"
     require "chervil/ast/identifier"
     require "chervil/ast/number"

lib/chervil/ast/boolean.rb

+module Chervil::AST
+  class Boolean
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      @value == other.value
+    end
+
+    def evaluate(env)
+      @value
+    end
+  end
+end

lib/chervil/lexer.rb

       when ')'
         advance
         Token.new(:rparen, ")")
+      when '#'
+        advance
+        if current_char == 't'
+          advance
+          Token.new(:boolean, true)
+        elsif current_char == 'f'
+          advance
+          Token.new(:boolean, false)
+        else
+          raise "Unexpected character #{current_char}"
+        end
       when '"', '\''
         delimiter = current_char
         advance

lib/chervil/parser.rb

     end
 
     def expr
-      if [:string, :number].include?(@current_token.type)
+      if [:string, :number, :boolean].include?(@current_token.type)
         constant
       elsif @current_token.type == :identifier
         identifier
       elsif @current_token.type == :lparen
         application
+      else
+        raise "Unexpected token #{@current_token.type}: #{@current_token.value}"
       end
     end
 
       when :string
         token = eat(:string)
         AST::String.new(token.value)
+      when :boolean
+        token = eat(:boolean)
+        AST::Boolean.new(token.value)
       end
     end
 

spec/ast/boolean_spec.rb

+module Chervil
+  RSpec.describe AST::String do
+    it 'evaluates' do
+      expect(AST::Boolean.new(true).evaluate(Env.new)).to eq(true)
+    end
+  end
+end

spec/lexer_spec.rb

         Token.new(:string, 'world')
       )
     end
+
+    it 'lexes booleans' do
+      lexer = Lexer.new("#t #f")
+      expect(lexer.get_next_token).to eq(Token.new(:boolean, true))
+      expect(lexer.get_next_token).to eq(Token.new(:boolean, false))
+    end
   end
 end

spec/parser_spec.rb

         )
       )
     end
+
+    it 'parses booleans' do
+      expect(parse('#t #f')).to eq(
+        [
+          AST::Boolean.new(true),
+          AST::Boolean.new(false),
+        ]
+      )
+    end
   end
 end