Skip to content

Commit d8debd3

Browse files
morr0nemorr0ne
committed
Add eveluator and setup final parsing logic
1 parent ca41b90 commit d8debd3

File tree

5 files changed

+56
-46
lines changed

5 files changed

+56
-46
lines changed

‎src/glazed_corn.gleam‎

Lines changed: 13 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,21 @@
1+
import glazed_corn/error
2+
import glazed_corn/evaluator
3+
import glazed_corn/lexer
4+
import glazed_corn/parser
15
import glazed_corn/value.{type Value}
26
import gleam/bit_array
7+
import gleam/result
38

4-
pub type ParseError {
5-
InvalidFormat
6-
InvalidLength
7-
UnexpectedToken(String)
8-
}
9+
pub fn parse(source: String) -> Result(Value, error.ParseError) {
10+
use tokens <- result.try(source |> lexer.new |> lexer.tokenize)
11+
use ast <- result.try(tokens |> parser.parse)
912

10-
pub fn parse(source: String) -> Result(Value, ParseError) {
11-
parse_bits(bit_array.from_string(source))
13+
ast |> evaluator.evaluate
1214
}
1315

14-
pub fn parse_bits(source: BitArray) -> Result(Value, ParseError) {
15-
case parse_value(source) {
16-
Ok(#(value, <<>>)) -> Ok(value)
17-
Ok(#(_, _)) -> Error(InvalidLength)
18-
Error(error) -> Error(error)
16+
pub fn parse_bits(source: BitArray) -> Result(Value, error.ParseError) {
17+
case source |> bit_array.to_string {
18+
Ok(str) -> str |> parse
19+
Error(_) -> Error(error.InvalidFormat)
1920
}
2021
}
21-
22-
pub fn parse_value(source: BitArray) -> Result(#(Value, BitArray), ParseError) {
23-
Error(InvalidLength)
24-
}

‎src/glazed_corn/error.gleam‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
pub type ParseError {
2+
InvalidFormat
3+
InvalidLength
4+
UnexpectedToken(String)
5+
UnexpectedEof
6+
}

‎src/glazed_corn/evaluator.gleam‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
import glazed_corn/error
2+
import glazed_corn/parser.{type Root}
3+
import glazed_corn/value.{type Value}
4+
5+
pub fn evaluate(_root: Root) -> Result(Value, error.ParseError) {
6+
Error(error.InvalidLength)
7+
}

‎src/glazed_corn/lexer.gleam‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
import glazed_corn
1+
import glazed_corn/error
22
import glazed_corn/token.{
33
type Token, Boolean, Chain, CloseBrace, CloseBracket, Comment, Eof, Equals,
44
Float, In, InputName, Integer, Key, Let, Literal, Null, OpenBrace, OpenBracket,
@@ -91,22 +91,22 @@ fn advance(lexer: Lexer, source: String) -> Lexer {
9191
Lexer(..lexer, source:)
9292
}
9393

94-
pub fn tokenize(lexer: Lexer) -> Result(List(Token), glazed_corn.ParseError) {
94+
pub fn tokenize(lexer: Lexer) -> Result(List(Token), error.ParseError) {
9595
do_tokenize(lexer, [])
9696
}
9797

9898
fn do_tokenize(
9999
lexer: Lexer,
100100
tokens: List(Token),
101-
) -> Result(List(Token), glazed_corn.ParseError) {
101+
) -> Result(List(Token), error.ParseError) {
102102
case lexer |> advance(lexer.source |> string.trim_start) |> next {
103103
Ok(#(Eof, _)) -> Ok(tokens |> list.reverse)
104104
Ok(#(token, lexer)) -> do_tokenize(lexer, [token, ..tokens])
105105
Error(error) -> Error(error)
106106
}
107107
}
108108

109-
fn next(lexer: Lexer) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
109+
fn next(lexer: Lexer) -> Result(#(Token, Lexer), error.ParseError) {
110110
case lexer.source {
111111
"" -> #(Eof, lexer) |> Ok
112112

@@ -153,7 +153,7 @@ fn next(lexer: Lexer) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
153153
let #(input, rest) = lex_input_name(name, "")
154154
Ok(#(InputName(input), lexer |> advance(rest)))
155155
}
156-
False -> Error(glazed_corn.InvalidFormat)
156+
False -> Error(error.InvalidFormat)
157157
}
158158
}
159159

@@ -181,7 +181,7 @@ fn next(lexer: Lexer) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
181181
fn lex_quoted_key(
182182
lexer: Lexer,
183183
acc: String,
184-
) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
184+
) -> Result(#(Token, Lexer), error.ParseError) {
185185
let #(before, split, after) =
186186
lexer.quoted_key_splitter |> splitter.split(lexer.source)
187187

@@ -194,7 +194,7 @@ fn lex_quoted_key(
194194
fn lex_literal(
195195
lexer: Lexer,
196196
acc: String,
197-
) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
197+
) -> Result(#(Token, Lexer), error.ParseError) {
198198
let #(before, split, after) =
199199
lexer.string_splitter |> splitter.split(lexer.source)
200200

@@ -376,7 +376,7 @@ fn lex_num_radix(
376376
lexer: Lexer,
377377
negative: Bool,
378378
radix: Int,
379-
) -> Result(#(Token, Lexer), glazed_corn.ParseError) {
379+
) -> Result(#(Token, Lexer), error.ParseError) {
380380
let #(before, split, after) =
381381
lexer.float_splitter |> splitter.split(lexer.source)
382382

@@ -386,7 +386,7 @@ fn lex_num_radix(
386386

387387
float.parse(before <> "." <> num)
388388
|> result.map(fn(f) { #(Float(f), lexer |> advance(rest)) })
389-
|> result.replace_error(glazed_corn.InvalidFormat)
389+
|> result.replace_error(error.InvalidFormat)
390390
}
391391
_ -> {
392392
let #(num, rest) = lexer.source |> extract_number("")
@@ -398,7 +398,7 @@ fn lex_num_radix(
398398
True -> Ok(#(Integer(-num), lexer |> advance(rest)))
399399
}
400400
}
401-
_ -> Error(glazed_corn.InvalidFormat)
401+
_ -> Error(error.InvalidFormat)
402402
}
403403
}
404404
}

‎src/glazed_corn/parser.gleam‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
import glazed_corn
1+
import glazed_corn/error
22
import glazed_corn/token.{type Token}
33
import gleam/dict.{type Dict}
44
import gleam/list
@@ -29,34 +29,34 @@ pub type PairOrSpread {
2929
ObjectSpread(String)
3030
}
3131

32-
pub fn parse_tokens(tokens: List(Token)) -> Result(Root, glazed_corn.ParseError) {
32+
pub fn parse(tokens: List(Token)) -> Result(Root, error.ParseError) {
3333
case tokens {
3434
[token.Let, token.OpenBrace, ..rest] -> {
3535
use #(inputs, rest) <- result.try(parse_inputs(rest, dict.new()))
3636
use #(object, rest) <- result.try(do_parse_object(rest, []))
3737

3838
case rest |> list.is_empty {
3939
True -> Ok(Root(inputs:, object:))
40-
False -> Error(glazed_corn.InvalidFormat)
40+
False -> Error(error.InvalidFormat)
4141
}
4242
}
4343
[token.OpenBrace, ..rest] -> {
4444
use #(object, rest) <- result.try(do_parse_object(rest, []))
4545

4646
case rest |> list.is_empty {
4747
True -> Ok(Root(inputs: dict.new(), object:))
48-
False -> Error(glazed_corn.InvalidFormat)
48+
False -> Error(error.InvalidFormat)
4949
}
5050
}
5151

52-
_ -> Error(glazed_corn.InvalidFormat)
52+
_ -> Error(error.InvalidFormat)
5353
}
5454
}
5555

5656
fn parse_inputs(
5757
tokens: List(Token),
5858
inputs: Dict(String, Entry),
59-
) -> Result(#(Dict(String, Entry), List(Token)), glazed_corn.ParseError) {
59+
) -> Result(#(Dict(String, Entry), List(Token)), error.ParseError) {
6060
case tokens {
6161
[token.CloseBrace, token.In, token.OpenBrace, ..rest] ->
6262
#(inputs, rest) |> Ok
@@ -66,14 +66,14 @@ fn parse_inputs(
6666
parse_inputs(rest, inputs |> dict.insert(key, value))
6767
}
6868
[token.Comment(_), ..rest] -> parse_inputs(rest, inputs)
69-
[] -> Error(glazed_corn.UnexpectedEof)
70-
[token, ..] -> Error(glazed_corn.UnexpectedToken(token.to_string(token)))
69+
[] -> Error(error.UnexpectedEof)
70+
[token, ..] -> Error(error.UnexpectedToken(token.to_string(token)))
7171
}
7272
}
7373

7474
fn parse_entry(
7575
tokens: List(Token),
76-
) -> Result(#(Entry, List(Token)), glazed_corn.ParseError) {
76+
) -> Result(#(Entry, List(Token)), error.ParseError) {
7777
case tokens {
7878
[token.Literal(lit), ..rest] -> #(String(lit), rest) |> Ok
7979
[token.Integer(int), ..rest] -> #(Integer(int), rest) |> Ok
@@ -84,14 +84,14 @@ fn parse_entry(
8484
[token.Null, ..rest] -> #(Null, rest) |> Ok
8585
[token.InputName(input), ..rest] -> #(Input(input), rest) |> Ok
8686
[token.Comment(_), ..rest] -> parse_entry(rest)
87-
[] -> Error(glazed_corn.UnexpectedEof)
88-
[token, ..] -> Error(glazed_corn.UnexpectedToken(token.to_string(token)))
87+
[] -> Error(error.UnexpectedEof)
88+
[token, ..] -> Error(error.UnexpectedToken(token.to_string(token)))
8989
}
9090
}
9191

9292
fn parse_object(
9393
tokens: List(Token),
94-
) -> Result(#(Entry, List(Token)), glazed_corn.ParseError) {
94+
) -> Result(#(Entry, List(Token)), error.ParseError) {
9595
case do_parse_object(tokens, []) {
9696
Ok(#(object, rest)) -> #(object |> list.reverse |> Object, rest) |> Ok
9797
Error(err) -> Error(err)
@@ -101,7 +101,7 @@ fn parse_object(
101101
fn do_parse_object(
102102
tokens: List(Token),
103103
object: List(PairOrSpread),
104-
) -> Result(#(List(PairOrSpread), List(Token)), glazed_corn.ParseError) {
104+
) -> Result(#(List(PairOrSpread), List(Token)), error.ParseError) {
105105
case tokens {
106106
[token.CloseBrace, ..rest] -> #(object, rest) |> Ok
107107
[token.Key(key), ..rest] -> {
@@ -113,28 +113,28 @@ fn do_parse_object(
113113
[token.Spread, token.InputName(input), ..rest] ->
114114
do_parse_object(rest, [ObjectSpread(input), ..object])
115115
[token.Comment(_), ..rest] -> do_parse_object(rest, object)
116-
[] -> Error(glazed_corn.UnexpectedEof)
117-
[token, ..] -> Error(glazed_corn.UnexpectedToken(token.to_string(token)))
116+
[] -> Error(error.UnexpectedEof)
117+
[token, ..] -> Error(error.UnexpectedToken(token.to_string(token)))
118118
}
119119
}
120120

121121
fn parse_key_chain(
122122
tokens: List(Token),
123123
keys: List(String),
124-
) -> Result(#(List(String), List(Token)), glazed_corn.ParseError) {
124+
) -> Result(#(List(String), List(Token)), error.ParseError) {
125125
case tokens {
126126
[token.Equals, ..rest] -> #(keys |> list.reverse, rest) |> Ok
127127
[token.Chain, token.Key(key), ..rest] ->
128128
parse_key_chain(rest, [key, ..keys])
129129
[token.Comment(_), ..rest] -> parse_key_chain(rest, keys)
130-
[] -> Error(glazed_corn.UnexpectedEof)
131-
[token, ..] -> Error(glazed_corn.UnexpectedToken(token.to_string(token)))
130+
[] -> Error(error.UnexpectedEof)
131+
[token, ..] -> Error(error.UnexpectedToken(token.to_string(token)))
132132
}
133133
}
134134

135135
fn parse_array(
136136
tokens: List(Token),
137-
) -> Result(#(Entry, List(Token)), glazed_corn.ParseError) {
137+
) -> Result(#(Entry, List(Token)), error.ParseError) {
138138
case do_parse_array(tokens, []) {
139139
Ok(#(array, rest)) -> #(array |> list.reverse |> Array, rest) |> Ok
140140
Error(err) -> Error(err)
@@ -144,7 +144,7 @@ fn parse_array(
144144
fn do_parse_array(
145145
tokens: List(Token),
146146
array: List(EntryOrSpread),
147-
) -> Result(#(List(EntryOrSpread), List(Token)), glazed_corn.ParseError) {
147+
) -> Result(#(List(EntryOrSpread), List(Token)), error.ParseError) {
148148
case tokens {
149149
[token.CloseBracket, ..rest] -> #(array, rest) |> Ok
150150
[token.Spread, token.InputName(input), ..rest] ->

0 commit comments

Comments
 (0)