All language subtitles for Episode 1- A basic expression evaluator

hello friends of darknet I'm in will

hello friends of darknet I'm in will
entereth and you can find me on Twitter

entereth and you can find me on Twitter

entereth and you can find me on Twitter
at Tarot jobs I'm super excited about

at Tarot jobs I'm super excited about

at Tarot jobs I'm super excited about
this event I've rambled about this on

this event I've rambled about this on

this event I've rambled about this on
Twitter I think I was a year ago when I

Twitter I think I was a year ago when I

Twitter I think I was a year ago when I
said how about I do a video series on

said how about I do a video series on

said how about I do a video series on
how to build a compiler from scratch and

how to build a compiler from scratch and

how to build a compiler from scratch and
then I never did anything with that

then I never did anything with that

then I never did anything with that
because it turns out I was super busy

because it turns out I was super busy

because it turns out I was super busy
doing other stuff but thankfully you

doing other stuff but thankfully you

doing other stuff but thankfully you
guys have all pinked me on regular basis

guys have all pinked me on regular basis

guys have all pinked me on regular basis
on Twitter and asked what's going on

on Twitter and asked what's going on

on Twitter and asked what's going on
there I want to see this amazing talk of

there I want to see this amazing talk of

there I want to see this amazing talk of
yours so I finally had the time to put

yours so I finally had the time to put

yours so I finally had the time to put
something together and today is the

something together and today is the

something together and today is the
first episode where we will start

first episode where we will start

first episode where we will start
writing the compiler some of you have

writing the compiler some of you have

writing the compiler some of you have
asked how long will it take to write the

asked how long will it take to write the

asked how long will it take to write the
compiler that's a good question I don't

compiler that's a good question I don't

compiler that's a good question I don't
quite know because my goal is to write

quite know because my goal is to write

quite know because my goal is to write
this live right so the today's episode

this live right so the today's episode

this live right so the today's episode
will be 60 to 90 minutes I will do a

will be 60 to 90 minutes I will do a

will be 60 to 90 minutes I will do a
demo of so I should say I already have

demo of so I should say I already have

demo of so I should say I already have
written the compiler so one of the

written the compiler so one of the

written the compiler so one of the
things that we'll do today is demo what

things that we'll do today is demo what

things that we'll do today is demo what
the end result would look like so you

the end result would look like so you

the end result would look like so you
get an idea whether it's worth you know

get an idea whether it's worth you know

get an idea whether it's worth you know
keeping keeping up with it or whether

keeping keeping up with it or whether

keeping keeping up with it or whether
you want to do something else with your

you want to do something else with your

you want to do something else with your
time yeah before we go into the details

time yeah before we go into the details

time yeah before we go into the details
of a few notes I want to go through it

of a few notes I want to go through it

of a few notes I want to go through it
to make sure we're on the same page so

to make sure we're on the same page so

to make sure we're on the same page so
we will be writing the compiler from

we will be writing the compiler from

we will be writing the compiler from
scratch so there will be no magic

scratch so there will be no magic

scratch so there will be no magic
compiler tools no parser generators is

compiler tools no parser generators is

compiler tools no parser generators is
just plain c-sharp the other thing is I

just plain c-sharp the other thing is I

just plain c-sharp the other thing is I
don't require any computer science

don't require any computer science

don't require any computer science
knowledge even though I have a computer

knowledge even though I have a computer

knowledge even though I have a computer
science degree

science degree

science degree
I think compilers are just you know as

I think compilers are just you know as

I think compilers are just you know as
any other software if you know how to

any other software if you know how to

any other software if you know how to
write it it's just a lot of fun we will

write it it's just a lot of fun we will

write it it's just a lot of fun we will
be using dotnet Korn Visual Studio code

be using dotnet Korn Visual Studio code

be using dotnet Korn Visual Studio code
both are free applications so you should

both are free applications so you should

both are free applications so you should
be able to download them and just follow

be able to download them and just follow

be able to download them and just follow
along without any any major requirements

along without any any major requirements

along without any any major requirements
and the cool thing is also both of them

and the cool thing is also both of them

and the cool thing is also both of them
are cross-platform so even if you're not

are cross-platform so even if you're not

are cross-platform so even if you're not
on Windows you should be able to keep up

on Windows you should be able to keep up

on Windows you should be able to keep up
with the talk um

with the talk um

with the talk um
yeah one thing I should say I am NOT a

yeah one thing I should say I am NOT a

yeah one thing I should say I am NOT a
compiler guy so I work at Microsoft at

compiler guy so I work at Microsoft at

compiler guy so I work at Microsoft at
work on the lunette team so I think of

work on the lunette team so I think of

work on the lunette team so I think of
myself as being a decent developer but I

myself as being a decent developer but I

myself as being a decent developer but I
am definitely not a compiler expert so

am definitely not a compiler expert so

am definitely not a compiler expert so
if you're a compiler expert you might be

if you're a compiler expert you might be

if you're a compiler expert you might be
bored or highly amused I don't know

bored or highly amused I don't know

bored or highly amused I don't know
which game you will fall into

which game you will fall into

which game you will fall into
I'd like to hear your feedback though so

I'd like to hear your feedback though so

I'd like to hear your feedback though so
if you're interested keep watching

so the one thing I would say is the why

so the one thing I would say is the why
do I do this course so my prime

do I do this course so my prime

do I do this course so my prime
motivation is to convince you the

motivation is to convince you the

motivation is to convince you the
compilers of fun because I've written a

compilers of fun because I've written a

compilers of fun because I've written a
few compilers in my spare time and I

few compilers in my spare time and I

few compilers in my spare time and I
think those are cool things to do and

think those are cool things to do and

think those are cool things to do and
there's plenty of stuff that is actually

there's plenty of stuff that is actually

there's plenty of stuff that is actually
very useful in whatever job you are

very useful in whatever job you are

very useful in whatever job you are
doing because turns out compilers are

doing because turns out compilers are

doing because turns out compilers are
really mostly about you know how to

really mostly about you know how to

really mostly about you know how to
handle trees how to walk trees how to do

handle trees how to walk trees how to do

handle trees how to walk trees how to do
interesting stuff with trees and trees

interesting stuff with trees and trees

interesting stuff with trees and trees
are just a very interesting data

are just a very interesting data

are just a very interesting data
structure that if you've never used them

structure that if you've never used them

structure that if you've never used them
you probably should because they're

you probably should because they're

you probably should because they're
really cool so my goal is I will be

really cool so my goal is I will be

really cool so my goal is I will be
streaming every Wednesday 8:00 a.m.

streaming every Wednesday 8:00 a.m.

streaming every Wednesday 8:00 a.m.
Pacific Standard Time which will

Pacific Standard Time which will

Pacific Standard Time which will
probably not work for the entirety of

probably not work for the entirety of

probably not work for the entirety of
the world but hopefully for enough

the world but hopefully for enough

the world but hopefully for enough
people on the world so it makes sense to

people on the world so it makes sense to

people on the world so it makes sense to
do it in a live fashion dependent it

do it in a live fashion dependent it

do it in a live fashion dependent it
doesn't matter where you're watching

doesn't matter where you're watching

doesn't matter where you're watching
whether it's twitch or mixer or youtube

whether it's twitch or mixer or youtube

whether it's twitch or mixer or youtube
I stream to all three of them at the

I stream to all three of them at the

I stream to all three of them at the
same time so just feel free to use the

same time so just feel free to use the

same time so just feel free to use the
chat in there and ask questions and if I

chat in there and ask questions and if I

chat in there and ask questions and if I
don't forget I will actually check the

don't forget I will actually check the

don't forget I will actually check the
chat window every once in a while and

chat window every once in a while and

chat window every once in a while and
try to answer your questions the

try to answer your questions the

try to answer your questions the
recordings of these episodes will go to

recordings of these episodes will go to

recordings of these episodes will go to
YouTube so even if you can't make the

YouTube so even if you can't make the

YouTube so even if you can't make the
life's not you will be able to follow

life's not you will be able to follow

life's not you will be able to follow
later and find the stuff on YouTube as

later and find the stuff on YouTube as

later and find the stuff on YouTube as
well which is super useful yeah of

well which is super useful yeah of

well which is super useful yeah of
course the source code that we going to

course the source code that we going to

course the source code that we going to
write is going to github my goal would

write is going to github my goal would

write is going to github my goal would
be that at the end of every episode I

be that at the end of every episode I

be that at the end of every episode I
have one PR that adds all the code we

have one PR that adds all the code we

have one PR that adds all the code we
wrote in that episode and I think on how

wrote in that episode and I think on how

wrote in that episode and I think on how
much time and how much energy I'm

much time and how much energy I'm

much time and how much energy I'm
willing to spend after the episode

willing to spend after the episode

willing to spend after the episode
hopefully also get some notes so even if

hopefully also get some notes so even if

hopefully also get some notes so even if
it didn't follow the episode or if

it didn't follow the episode or if

it didn't follow the episode or if
you're not a video person you should

you're not a video person you should

you're not a video person you should
still be able to catch up by just

still be able to catch up by just

still be able to catch up by just
reading the notes yeah this brings him

reading the notes yeah this brings him

reading the notes yeah this brings him
back to what's the goal for today so

back to what's the goal for today so

back to what's the goal for today so
today I want to start the project we

today I want to start the project we

today I want to start the project we
want to you know create the github repo

want to you know create the github repo

want to you know create the github repo
get the initial code up and running and

get the initial code up and running and

get the initial code up and running and
then write the first part of it so today

then write the first part of it so today

then write the first part of it so today
what I would like to do is start with

what I would like to do is start with

what I would like to do is start with
something simple like an expression

something simple like an expression

something simple like an expression
evaluator where we handle priorities

evaluator where we handle priorities

evaluator where we handle priorities
already you know basic parsing of basic

already you know basic parsing of basic

already you know basic parsing of basic
structures and then maybe even print the

structures and then maybe even print the

structures and then maybe even print the
parse tree so that we have some

parse tree so that we have some

parse tree so that we have some
foundation that we can play with all

foundation that we can play with all

foundation that we can play with all
right send without further ado let's

right send without further ado let's

right send without further ado let's
just jump into the coding portion of

just jump into the coding portion of

just jump into the coding portion of
this I mean

this I mean

this I mean
really the fun part isn't it so let me

really the fun part isn't it so let me

really the fun part isn't it so let me
first say we need to pick a name as any

first say we need to pick a name as any

first say we need to pick a name as any
given project is and you know I have

given project is and you know I have

given project is and you know I have
type of plenty of names we have been I

type of plenty of names we have been I

type of plenty of names we have been I
wrote the compiler you know tear drops

wrote the compiler you know tear drops

wrote the compiler you know tear drops
compiler in most compiler our compiler

compiler in most compiler our compiler

compiler in most compiler our compiler
and like I've never was really happy if

and like I've never was really happy if

and like I've never was really happy if
you ever considered MIPS

come again have you ever considered

come again have you ever considered
Minsk I'm not entirely sold on the name

Minsk I'm not entirely sold on the name

Minsk I'm not entirely sold on the name
Minsk yet I think maybe we should pick

Minsk yet I think maybe we should pick

Minsk yet I think maybe we should pick
maybe a better name all right fair

maybe a better name all right fair

maybe a better name all right fair
enough fair enough

enough fair enough

enough fair enough
that's not upset the Klingon Minsk it is

that's not upset the Klingon Minsk it is

that's not upset the Klingon Minsk it is
so let's call our compiler and our

so let's call our compiler and our

so let's call our compiler and our
language for now Minsk and then see

language for now Minsk and then see

language for now Minsk and then see
where this leads us so what I have here

where this leads us so what I have here

where this leads us so what I have here
is the visual studio environment for the

is the visual studio environment for the

is the visual studio environment for the
finished product so I want to give you a

finished product so I want to give you a

finished product so I want to give you a
quick demo on what that would look like

quick demo on what that would look like

quick demo on what that would look like
so that you can decide whether you will

so that you can decide whether you will

so that you can decide whether you will
run around the annoying person that I am

run around the annoying person that I am

run around the annoying person that I am
i named it visual minsk because why not

i named it visual minsk because why not

i named it visual minsk because why not
so we have a small program here that we

so we have a small program here that we

so we have a small program here that we
can load and then you have an editor let

can load and then you have an editor let

can load and then you have an editor let
me just maximize this and zoom in a

me just maximize this and zoom in a

me just maximize this and zoom in a
little bit so you have code colorization

little bit so you have code colorization

little bit so you have code colorization
which again is actually done by our

which again is actually done by our

which again is actually done by our
compiler infrastructure you can hover

compiler infrastructure you can hover

compiler infrastructure you can hover
over identifiers and it tells you what

over identifiers and it tells you what

over identifiers and it tells you what
it is so it knows that guesses is a

it is so it knows that guesses is a

it is so it knows that guesses is a
variable of type int so we have type

variable of type int so we have type

variable of type int so we have type
checking going the language that I have

checking going the language that I have

checking going the language that I have
I was very uninspired basically what it

I was very uninspired basically what it

I was very uninspired basically what it
does it's just JavaScript or a little

does it's just JavaScript or a little

does it's just JavaScript or a little
bit of c-sharp maybe I just wanted to

bit of c-sharp maybe I just wanted to

bit of c-sharp maybe I just wanted to
have some language that is something we

have some language that is something we

have some language that is something we
can actually play with like I'm not a

can actually play with like I'm not a

can actually play with like I'm not a
language designer even though I'm going

language designer even though I'm going

language designer even though I'm going
to see sharp language design team I have

to see sharp language design team I have

to see sharp language design team I have
my opinions on what I would like to see

my opinions on what I would like to see

my opinions on what I would like to see
there but for me was mostly about

there but for me was mostly about

there but for me was mostly about
writing the language so I just picked

writing the language so I just picked

writing the language so I just picked
something relatively easy to parse and

something relatively easy to parse and

something relatively easy to parse and
you know we can play with this probably

you know we can play with this probably

you know we can play with this probably
as we're going as well let me open up

as we're going as well let me open up

as we're going as well let me open up
the chat window so that when I'm going I

the chat window so that when I'm going I

the chat window so that when I'm going I
am actually able to see what's going on

am actually able to see what's going on

am actually able to see what's going on
zoom out here there's already plenty of

zoom out here there's already plenty of

zoom out here there's already plenty of
questions

yep all right so one thing so what it

yep all right so one thing so what it
does right now I can actually run this

does right now I can actually run this

does right now I can actually run this
program and I wrote a little guessing

program and I wrote a little guessing

program and I wrote a little guessing
game so you can say I would like to get

game so you can say I would like to get

game so you can say I would like to get
hints and then it will basically say I

hints and then it will basically say I

hints and then it will basically say I
guess that I'm a between 1 and 100 and

guess that I'm a between 1 and 100 and

guess that I'm a between 1 and 100 and
now you know what's your guess and it

now you know what's your guess and it

now you know what's your guess and it
basically does the normal binary search

basically does the normal binary search

basically does the normal binary search
so we can say 50 and then it says well

so we can say 50 and then it says well

so we can say 50 and then it says well
the number is actually higher maybe you

the number is actually higher maybe you

the number is actually higher maybe you
want to get 75 or the number is lower

want to get 75 or the number is lower

want to get 75 or the number is lower
and then eventually hopefully after a

and then eventually hopefully after a

and then eventually hopefully after a
few guesses you get to the actual number

few guesses you get to the actual number

few guesses you get to the actual number
so this is a very basic program here you

so this is a very basic program here you

so this is a very basic program here you
know we have functions in here the

know we have functions in here the

know we have functions in here the
functions take parameters I have the

functions take parameters I have the

functions take parameters I have the
ability to print to the console we have

ability to print to the console we have

ability to print to the console we have
string interpolation going we have basic

string interpolation going we have basic

string interpolation going we have basic
control structures like wire loops and

control structures like wire loops and

control structures like wire loops and
if statements and you can assign

if statements and you can assign

if statements and you can assign
variables and you know what do you were

variables and you know what do you were

variables and you know what do you were
basically expect from a from a from a

basically expect from a from a from a

basically expect from a from a from a
from a boomer decent programming

from a boomer decent programming

from a boomer decent programming
language the idea that we have here is

language the idea that we have here is

language the idea that we have here is
actually it doesn't have code completion

actually it doesn't have code completion

actually it doesn't have code completion
yet although that is something that I

yet although that is something that I

yet although that is something that I
would like to add as well but you get

would like to add as well but you get

would like to add as well but you get
life type checking so if I make this in

life type checking so if I make this in

life type checking so if I make this in
a float you need to get an error message

a float you need to get an error message

a float you need to get an error message
that says this variable here we cannot

that says this variable here we cannot

that says this variable here we cannot
convert float to an int because

convert float to an int because

convert float to an int because
startgame

startgame

startgame
takes an int right you also get some

takes an int right you also get some

takes an int right you also get some
sort of symbol browser here where you

sort of symbol browser here where you

sort of symbol browser here where you
can actually navigate between different

can actually navigate between different

can actually navigate between different
parts of the language so basically what

parts of the language so basically what

parts of the language so basically what
you would expect I guess from anything

you would expect I guess from anything

you would expect I guess from anything
that has the title IDE or something as

that has the title IDE or something as

that has the title IDE or something as
basic as that the other thing that I did

basic as that the other thing that I did

basic as that the other thing that I did
because this is actually compiled so

because this is actually compiled so

because this is actually compiled so
this is literally producing a dotnet

this is literally producing a dotnet

this is literally producing a dotnet
executable so we can actually go to the

executable so we can actually go to the

executable so we can actually go to the
folder here if I remember where I put it

folder here if I remember where I put it

folder here if I remember where I put it
I think it's here under samples yep

I think it's here under samples yep

I think it's here under samples yep
here's our or XE and we can actually

here's our or XE and we can actually

here's our or XE and we can actually
open up this guy you know it's fine

open up this guy you know it's fine

open up this guy you know it's fine
which is actually kind of fun to do

which is actually kind of fun to do

which is actually kind of fun to do
because you know look at the the

because you know look at the the

because you know look at the the
decompiled c-sharp version of our

decompiled c-sharp version of our

decompiled c-sharp version of our
language which is kind of fun so you can

language which is kind of fun so you can

language which is kind of fun so you can
see for example that I use string

see for example that I use string

see for example that I use string
interpolation here but it just compels

interpolation here but it just compels

interpolation here but it just compels
down to a normal string concatenation

down to a normal string concatenation

down to a normal string concatenation
for example right which I think in I

for example right which I think in I

for example right which I think in I
actually call string concatenation

actually call string concatenation

actually call string concatenation
if yeah that's what it does here but you

if yeah that's what it does here but you

if yeah that's what it does here but you
can see it in C sharp of course you can

can see it in C sharp of course you can

can see it in C sharp of course you can
switch to all language because nothing

switch to all language because nothing

switch to all language because nothing
knows about our language right that

knows about our language right that

knows about our language right that
would be maybe even fun to do maybe

would be maybe even fun to do maybe

would be maybe even fun to do maybe
somebody wants to do the D compiler for

somebody wants to do the D compiler for

somebody wants to do the D compiler for
IELTS why for our language that would be

IELTS why for our language that would be

IELTS why for our language that would be
super sweet but that's not what I'm

super sweet but that's not what I'm

super sweet but that's not what I'm
focusing on and the other thing we can

focusing on and the other thing we can

focusing on and the other thing we can
do is we can actually debug there or or

do is we can actually debug there or or

do is we can actually debug there or or
a code so I can actually hit f5 and no I

a code so I can actually hit f5 and no I

a code so I can actually hit f5 and no I
did not write a debugger all it did I

did not write a debugger all it did I

did not write a debugger all it did I
omit a PDB file that actually has

omit a PDB file that actually has

omit a PDB file that actually has
debugging information in it so that

debugging information in it so that

debugging information in it so that
allows us to actually step through our

allows us to actually step through our

allows us to actually step through our
code so all I have to do here now as I

code so all I have to do here now as I

code so all I have to do here now as I
can had f11 and then Visual Studio will

can had f11 and then Visual Studio will

can had f11 and then Visual Studio will
happily load our source file I mean it

happily load our source file I mean it

happily load our source file I mean it
doesn't know anything about our language

doesn't know anything about our language

doesn't know anything about our language
right so there's no syntax highlighting

right so there's no syntax highlighting

right so there's no syntax highlighting
no nothing but I can actually do what

no nothing but I can actually do what

no nothing but I can actually do what
you normally do it you can do an f10 you

you normally do it you can do an f10 you

you normally do it you can do an f10 you
know you can say do I want to jump into

know you can say do I want to jump into

know you can say do I want to jump into
the method ask for hints or they want to

the method ask for hints or they want to

the method ask for hints or they want to
jump over that do an f10 so it asks for

jump over that do an f10 so it asks for

jump over that do an f10 so it asks for
hints I say no and then for the run game

hints I say no and then for the run game

hints I say no and then for the run game
I can decide whether I want to run into

I can decide whether I want to run into

I can decide whether I want to run into
that I can do this and as you can see

that I can do this and as you can see

that I can do this and as you can see
here is we even see the variables

here is we even see the variables

here is we even see the variables
because they are actually part of the of

because they are actually part of the of

because they are actually part of the of
the debug file so the four videos three

the debug file so the four videos three

the debug file so the four videos three
notes what local variables exist of

notes what local variables exist of

notes what local variables exist of
course what you can't do you cannot

course what you can't do you cannot

course what you can't do you cannot
divide expressions in here because again

divide expressions in here because again

divide expressions in here because again
Visual Studio knows nothing about our

Visual Studio knows nothing about our

Visual Studio knows nothing about our
language so there's no expression

language so there's no expression

language so there's no expression
evaluate or anything like that but you

evaluate or anything like that but you

evaluate or anything like that but you
are at least able to debug your code

are at least able to debug your code

are at least able to debug your code
right so long your visual studio

right so long your visual studio

right so long your visual studio
installed but you get the idea right

installed but you get the idea right

installed but you get the idea right
basically we just admitted Samael and

basically we just admitted Samael and

basically we just admitted Samael and
then had a debug information to it and

then had a debug information to it and

then had a debug information to it and
that's all it took all right so that is

that's all it took all right so that is

that's all it took all right so that is
what I want to demo about the actual

what I want to demo about the actual

what I want to demo about the actual
finished product yeah somebody's asking

finished product yeah somebody's asking

finished product yeah somebody's asking
what language is the compiler written in

what language is the compiler written in

what language is the compiler written in
I will be using c-sharp somebody asks

I will be using c-sharp somebody asks

I will be using c-sharp somebody asks
for VB but I don't know VB anymore it's

for VB but I don't know VB anymore it's

for VB but I don't know VB anymore it's
a long time yes somebody was asking what

a long time yes somebody was asking what

a long time yes somebody was asking what
y'all stands for again I'm uninspired

y'all stands for again I'm uninspired

y'all stands for again I'm uninspired
it's yet another language so not really

it's yet another language so not really

it's yet another language so not really
super curiously interesting so I think

super curiously interesting so I think

super curiously interesting so I think
yeah that's pretty much it what we have

yeah that's pretty much it what we have

yeah that's pretty much it what we have
for questions right now so alright let's

for questions right now so alright let's

for questions right now so alright let's
get started so let's actually closed

get started so let's actually closed

get started so let's actually closed
room studio for now and let's actually

room studio for now and let's actually

room studio for now and let's actually
start so let's let's start by creating

start so let's let's start by creating

start so let's let's start by creating
our or bare-bones folder so we have a

our or bare-bones folder so we have a

our or bare-bones folder so we have a
Minsk folder here let me populate this

Minsk folder here let me populate this

Minsk folder here let me populate this
with some basic basic file to you so we

with some basic basic file to you so we

with some basic basic file to you so we
have at least to get attribute to get

have at least to get attribute to get

have at least to get attribute to get
ignore get license let me do it get in

ignore get license let me do it get in

ignore get license let me do it get in
it so we have an actual repository to

it so we have an actual repository to

it so we have an actual repository to
work with and then I think I want to

work with and then I think I want to

work with and then I think I want to
create the Roppongi to make it public

let's do this let's come with what we

let's do this let's come with what we
have initial commit yeah it helps if you

have initial commit yeah it helps if you

have initial commit yeah it helps if you
add everything I know let's just keep

add everything I know let's just keep

add everything I know let's just keep
forgetting yep let's do that ooh yeah so

forgetting yep let's do that ooh yeah so

forgetting yep let's do that ooh yeah so
we have at least the basics well it's

we have at least the basics well it's

we have at least the basics well it's
actually open this folder in Visual

actually open this folder in Visual

actually open this folder in Visual
Studio code maybe the first thing we

Studio code maybe the first thing we

Studio code maybe the first thing we
should actually add is a readme file

should actually add is a readme file

should actually add is a readme file
just so we know what's going on this

just so we know what's going on this

just so we know what's going on this
repo is a compiler maybe we should also

repo is a compiler maybe we should also

repo is a compiler maybe we should also
add have you considered Minsk Worf

add have you considered Minsk Worf

add have you considered Minsk Worf
naming things more details follow up so

naming things more details follow up so

naming things more details follow up so
we at least know what this thing will

we at least know what this thing will

we at least know what this thing will
contain let's add this guy let's add

let's do this alright so nobody at least

let's do this alright so nobody at least
have something to work with so the first

have something to work with so the first

have something to work with so the first
thing I will do is I will create our

thing I will do is I will create our

thing I will do is I will create our
actual project as a set up I'll be using

actual project as a set up I'll be using

actual project as a set up I'll be using
donut core so anybody can follow along

donut core so anybody can follow along

donut core so anybody can follow along
on any operating system so let's say we

on any operating system so let's say we

on any operating system so let's say we
want to get a console app and we want to

want to get a console app and we want to

want to get a console app and we want to
call this MC for the Minsk compiler and

call this MC for the Minsk compiler and

call this MC for the Minsk compiler and
now let's actually open that guy again

now let's actually open that guy again

now let's actually open that guy again
in code alright so here we are

in code alright so here we are

in code alright so here we are
alright so now we have our or basic

alright so now we have our or basic

alright so now we have our or basic
compiler I think I should be able to run

compiler I think I should be able to run

compiler I think I should be able to run
this now maybe not yet yep I wanted on

this now maybe not yet yep I wanted on

this now maybe not yet yep I wanted on
the core environments

yes please I do not want to use the

yes please I do not want to use the
internal console because that never

internal console because that never

internal console because that never
worked well for me so I will use the

worked well for me so I will use the

worked well for me so I will use the
external terminal so for no controller 5

external terminal so for no controller 5

external terminal so for no controller 5
this that will hopefully launch this yep

this that will hopefully launch this yep

this that will hopefully launch this yep
it does that I mean Lee quits all right

it does that I mean Lee quits all right

it does that I mean Lee quits all right
so this is our thing so the first thing

so this is our thing so the first thing

so this is our thing so the first thing
I will do because it's a much easier for

I will do because it's a much easier for

I will do because it's a much easier for
us to work with it's not an actual

us to work with it's not an actual

us to work with it's not an actual
compiler but more like a wrapper right

compiler but more like a wrapper right

compiler but more like a wrapper right
where we enter some expression and then

where we enter some expression and then

where we enter some expression and then
you really get some feedback on that so

you really get some feedback on that so

you really get some feedback on that so
let's do this let's say while true then

let's do this let's say while true then

let's do this let's say while true then
let me say var align I may say just

let me say var align I may say just

let me say var align I may say just
console dot readline and let me say if

console dot readline and let me say if

console dot readline and let me say if
line if spring is null or empty I guess

line if spring is null or empty I guess

line if spring is null or empty I guess
not all white space is also fine line

not all white space is also fine line

not all white space is also fine line
then we just quit otherwise we say if

then we just quit otherwise we say if

then we just quit otherwise we say if
line equals 1 plus 2 times 3 then we say

line equals 1 plus 2 times 3 then we say

line equals 1 plus 2 times 3 then we say
console.writeline 7 actually let me add

console.writeline 7 actually let me add

console.writeline 7 actually let me add
a prompt here console right in this case

so we have something that we can

so we have something that we can
actually see them what the output was

actually see them what the output was

actually see them what the output was
and what the input was else console dot

and what the input was else console dot

and what the input was else console dot
write line invalid

write line invalid

write line invalid
expression

one plus two times three seven Wow I say

one plus two times three seven Wow I say
anything else anybody expression seems

anything else anybody expression seems

anything else anybody expression seems
I've already done it's that easy right

I've already done it's that easy right

I've already done it's that easy right
yeah

yeah

yeah
not quite so let's actually do a little

not quite so let's actually do a little

not quite so let's actually do a little
bit more so the first thing I want to do

bit more so the first thing I want to do

bit more so the first thing I want to do
is when we talk about a compiler right

is when we talk about a compiler right

is when we talk about a compiler right
the first thing that a compiler does if

the first thing that a compiler does if

the first thing that a compiler does if
you just look at this source snippet

you just look at this source snippet

you just look at this source snippet
here is it will break this thing from

here is it will break this thing from

here is it will break this thing from
characters into verts so if you think

characters into verts so if you think

characters into verts so if you think
about the parser the parts that doesn't

about the parser the parts that doesn't

about the parser the parts that doesn't
actually deal with individual characters

actually deal with individual characters

actually deal with individual characters
the parts that deals with verts right so

the parts that deals with verts right so

the parts that deals with verts right so
you can think of the first part of the

you can think of the first part of the

you can think of the first part of the
compiler is the lexer which creates

compiler is the lexer which creates

compiler is the lexer which creates
words and then there's the parser who

words and then there's the parser who

words and then there's the parser who
creates sentences and sentences are

creates sentences and sentences are

creates sentences and sentences are
usually entry form so the very first

usually entry form so the very first

usually entry form so the very first
thing I'm going to do is do that and so

thing I'm going to do is do that and so

thing I'm going to do is do that and so
in our case because we you know lets us

in our case because we you know lets us

in our case because we you know lets us
start with the class lexer which

start with the class lexer which

start with the class lexer which
basically will actually does this work

basically will actually does this work

basically will actually does this work
here sort of extra string text okay we

here sort of extra string text okay we

here sort of extra string text okay we
need a field oh god no once that naming

need a field oh god no once that naming

need a field oh god no once that naming
convention underscores for the win I

convention underscores for the win I

convention underscores for the win I
cannot stand this so the first thing we

cannot stand this so the first thing we

cannot stand this so the first thing we
need probably a position right so let's

need probably a position right so let's

need probably a position right so let's
say private in position and then we have

say private in position and then we have

say private in position and then we have
say syntax token next token let's say

say syntax token next token let's say

say syntax token next token let's say
right so now the question is what's the

right so now the question is what's the

right so now the question is what's the
syntax token

syntax token

syntax token
that it's basically what represents a

that it's basically what represents a

that it's basically what represents a
vert in our language right so in our

vert in our language right so in our

vert in our language right so in our
case it would say that starts simple and

case it would say that starts simple and

case it would say that starts simple and
say we have what do we need what would

say we have what do we need what would

say we have what do we need what would
be useful I guess what we sold is the

be useful I guess what we sold is the

be useful I guess what we sold is the
position in the input file and maybe the

position in the input file and maybe the

position in the input file and maybe the
text and maybe the kind like is it a

text and maybe the kind like is it a

text and maybe the kind like is it a
number or is it an operator right like

number or is it an operator right like

number or is it an operator right like
that sort of thing syntax kind kind and

that sort of thing syntax kind kind and

that sort of thing syntax kind kind and
let me just say our syntax kind is just

let me just say our syntax kind is just

let me just say our syntax kind is just
an enum for now

an enum for now

an enum for now
we have nothing in it and then it's just

we have nothing in it and then it's just

we have nothing in it and then it's just
initialize properties for those guys so

initialize properties for those guys so

initialize properties for those guys so
we can actually store them alright this

we can actually store them alright this

we can actually store them alright this
should get us going so so the idea here

should get us going so so the idea here

should get us going so so the idea here
is that this guy like every time you

is that this guy like every time you

is that this guy like every time you
call next token we basically yep you

call next token we basically yep you

call next token we basically yep you
know at the current position in the file

know at the current position in the file

know at the current position in the file
and if you find the next word take that

and if you find the next word take that

and if you find the next word take that
return that and keep going

return that and keep going

return that and keep going
so in our case so what we'll be looking

so in our case so what we'll be looking

so in our case so what we'll be looking
for so what we were looking for a fun

for so what we were looking for a fun

for so what we were looking for a fun
expression evaluator our numbers right I

expression evaluator our numbers right I

expression evaluator our numbers right I
guess plus minus times divided and of

guess plus minus times divided and of

guess plus minus times divided and of
course you know white space right space

course you know white space right space

course you know white space right space
let's just call this white space right

let's just call this white space right

let's just call this white space right
these are the three kinds of words that

these are the three kinds of words that

these are the three kinds of words that
maybe parentheses would also be great of

maybe parentheses would also be great of

maybe parentheses would also be great of
what we can detect for now so how about

what we can detect for now so how about

what we can detect for now so how about
we start with numbers so we say if char

actually before we do that maybe what we

actually before we do that maybe what we
should do is public you know private

should do is public you know private

should do is public you know private
char current which basically says the

char current which basically says the

char current which basically says the
current character let's start with

current character let's start with

current character let's start with
something like so if the position is

basically outside the bounds of the text

basically outside the bounds of the text
then we return this guy here which is

then we return this guy here which is

then we return this guy here which is
basically the zero Terminator second

basically the zero Terminator second

basically the zero Terminator second
tensional I guess for most systems to

tensional I guess for most systems to

tensional I guess for most systems to
say if it's invalid you return that guy

say if it's invalid you return that guy

say if it's invalid you return that guy
otherwise you return text position so

otherwise you return text position so

otherwise you return text position so
this gives us the current character and

this gives us the current character and

this gives us the current character and
then we probably want another method

then we probably want another method

then we probably want another method
avoid next which basically just does

avoid next which basically just does

avoid next which basically just does
this like we just increment the position

this like we just increment the position

this like we just increment the position
so no we can say if char is letter or

so no we can say if char is letter or

so no we can say if char is letter or
digit no sorry it's digit current then

digit no sorry it's digit current then

digit no sorry it's digit current then
what we will do is we will remember

what we will do is we will remember

what we will do is we will remember
where we are

where we are

where we are
tomorr start is position we say wild

tomorr start is position we say wild

tomorr start is position we say wild
char is digit current next and then we

char is digit current next and then we

char is digit current next and then we
say okay a lengthy I guess it's not

say okay a lengthy I guess it's not

say okay a lengthy I guess it's not
really nice that we have this leaky

really nice that we have this leaky

really nice that we have this leaky
abstraction here and we have a position

abstraction here and we have a position

abstraction here and we have a position
on them kind of to know what's going on

on them kind of to know what's going on

on them kind of to know what's going on
but let's deal with that for now so we

but let's deal with that for now so we

but let's deal with that for now so we
say in length would be position minus

say in length would be position minus

say in length would be position minus
start and then we can save our text is

start and then we can save our text is

start and then we can save our text is
text substring for start and length so

text substring for start and length so

text substring for start and length so
basically the idea here is that we will

basically the idea here is that we will

basically the idea here is that we will
keep reading numbers and then at the end

keep reading numbers and then at the end

keep reading numbers and then at the end
we just create the word that represents

we just create the word that represents

we just create the word that represents
the number so we would say var so I

the number so we would say var so I

the number so we would say var so I
returned news and text token no not like

returned news and text token no not like

returned news and text token no not like
that so I cannot type this morning

that so I cannot type this morning

that so I cannot type this morning
what's going on here ah I see what's

what's going on here ah I see what's

what's going on here ah I see what's
going on all right

going on all right

going on all right
look at a new subjects token we say the

look at a new subjects token we say the

look at a new subjects token we say the
syntax kind would be it's called as

syntax kind would be it's called as

syntax kind would be it's called as
number token for now and let me say the

number token for now and let me say the

number token for now and let me say the
position is starred and then the text is

position is starred and then the text is

position is starred and then the text is
text let's generate the enum member all

text let's generate the enum member all

text let's generate the enum member all
right so now we have the number as text

right so now we have the number as text

right so now we have the number as text
which is probably for later faces not

which is probably for later faces not

which is probably for later faces not
super useful so normally what you do for

super useful so normally what you do for

super useful so normally what you do for
tokens as well as you would say the

tokens as well as you would say the

tokens as well as you would say the
lecture is the party that is responsible

lecture is the party that is responsible

lecture is the party that is responsible
for actually you know reading it into

for actually you know reading it into

for actually you know reading it into
the actual value so let's do this let's

the actual value so let's do this let's

the actual value so let's do this let's
just say in tryparse

just say in tryparse

just say in tryparse
on the text

on the text

on the text
and let me say out of our value and we

and let me say out of our value and we

and let me say out of our value and we
don't really I don't really care right

don't really I don't really care right

don't really I don't really care right
now whether it succeeds or not of course

now whether it succeeds or not of course

now whether it succeeds or not of course
we need to add error handling boy we'll

we need to add error handling boy we'll

we need to add error handling boy we'll
do this later so let me actually go here

do this later so let me actually go here

do this later so let me actually go here
and that's actually object value let's

and that's actually object value let's

and that's actually object value let's
accept this guy as well so we had the

accept this guy as well so we had the

accept this guy as well so we had the
actual representation I'd use object for

actual representation I'd use object for

actual representation I'd use object for
now because we probably have other

now because we probably have other

now because we probably have other
shapes later that we want to have like

shapes later that we want to have like

shapes later that we want to have like
strings or floats so type in this is in

strings or floats so type in this is in

strings or floats so type in this is in
this probably not going to be a winning

this probably not going to be a winning

this probably not going to be a winning
proposition all right then we can say

proposition all right then we can say

proposition all right then we can say
okay bar is white space let's say

okay bar is white space let's say

okay bar is white space let's say
current and then this guy basically

current and then this guy basically

current and then this guy basically
repeats we do something like that again

repeats we do something like that again

repeats we do something like that again
say as long as this guy's white space

say as long as this guy's white space

say as long as this guy's white space
keep reading and then we say white space

keep reading and then we say white space

keep reading and then we say white space
token for now and I think I just lost

token for now and I think I just lost

token for now and I think I just lost
the light yeah I may have run out of

the light yeah I may have run out of

the light yeah I may have run out of
battery so if later on it might get

battery so if later on it might get

battery so if later on it might get
darker a lot my face that might not be

darker a lot my face that might not be

darker a lot my face that might not be
my mood or depending on how the last you

my mood or depending on how the last you

my mood or depending on how the last you
because it might be my mood we'll see

because it might be my mood we'll see

because it might be my mood we'll see
all right so now we have the white

all right so now we have the white

all right so now we have the white
spaces covered which gives us most of

spaces covered which gives us most of

spaces covered which gives us most of
them we need and then I think you only

them we need and then I think you only

them we need and then I think you only
have the special cases now if current

have the special cases now if current

have the special cases now if current
equals let's say plus then we do

equals let's say plus then we do

equals let's say plus then we do
something much much simpler we would say

position let's just cheat here c-sharp

position let's just cheat here c-sharp
for the win position plus plus text is

for the win position plus plus text is

for the win position plus plus text is
this guy and we don't have any value and

this guy and we don't have any value and

this guy and we don't have any value and
we call this the plus token

and then it's handled - as well while we

and then it's handled - as well while we
edit and then let's do actually let's do

edit and then let's do actually let's do

edit and then let's do actually let's do
them all while we edit / open paren

them all while we edit / open paren

them all while we edit / open paren
close paren and then we call this guy

close paren and then we call this guy

close paren and then we call this guy
the - token

the - token

the - token
it's called this star token this guy

it's called this star token this guy

it's called this star token this guy
would be the slash token this guy would

would be the slash token this guy would

would be the slash token this guy would
be the open / and this is token if I get

be the open / and this is token if I get

be the open / and this is token if I get
this ever ride I suck at typing that's

this ever ride I suck at typing that's

this ever ride I suck at typing that's
why intelligence is such an important

why intelligence is such an important

why intelligence is such an important
thing for me I just wish I had

thing for me I just wish I had

thing for me I just wish I had
intelligence for English all right so

intelligence for English all right so

intelligence for English all right so
now we have most of these guys I think

now we have most of these guys I think

now we have most of these guys I think
and of course we screwed up the text

and of course we screwed up the text

and of course we screwed up the text
yeah of course I could use the original

yeah of course I could use the original

yeah of course I could use the original
text on the input but you know what for

text on the input but you know what for

text on the input but you know what for
these kind of tokens it feels wasteful

these kind of tokens it feels wasteful

these kind of tokens it feels wasteful
to do the substring operations because

to do the substring operations because

to do the substring operations because
they are you know fixed and the nice

they are you know fixed and the nice

they are you know fixed and the nice
thing with literals is that they're all

thing with literals is that they're all

thing with literals is that they're all
in turn so you don't actually allocating

in turn so you don't actually allocating

in turn so you don't actually allocating
your string objects for that quite handy

your string objects for that quite handy

your string objects for that quite handy
all right so now the questions if you

all right so now the questions if you

all right so now the questions if you
get to this point then we probably found

get to this point then we probably found

get to this point then we probably found
something that we don't know what we

something that we don't know what we

something that we don't know what we
should do with that and so one thing

should do with that and so one thing

should do with that and so one thing
that you can do is you can just say new

that you can do is you can just say new

that you can do is you can just say new
syntax token syntax

syntax token syntax

syntax token syntax
kind it's called this bat token and yeah

kind it's called this bat token and yeah

kind it's called this bat token and yeah
I guess at this point we should have I

I guess at this point we should have I

I guess at this point we should have I
guess yeah I guess we can achieve again

guess yeah I guess we can achieve again

guess yeah I guess we can achieve again
bad language semantics for the win so we

bad language semantics for the win so we

bad language semantics for the win so we
can say this would be text position

can say this would be text position

can say this would be text position
minus one because this guy has already

minus one because this guy has already

minus one because this guy has already
been incremented so we go back yeah I

been incremented so we go back yeah I

been incremented so we go back yeah I
guess we didn't need to do a substring

guess we didn't need to do a substring

guess we didn't need to do a substring
here

here

here
sub-string for the previous position

sub-string for the previous position

sub-string for the previous position
only one character and then we have no

only one character and then we have no

only one character and then we have no
value I guess this is a comma not a

value I guess this is a comma not a

value I guess this is a comma not a
semicolon

all right they're talking we add to our

all right they're talking we add to our
list all right now we have our lecture

list all right now we have our lecture

list all right now we have our lecture
that can recognize numbers + - / +

that can recognize numbers + - / +

that can recognize numbers + - / +
whitespace so before we go ahead let's

whitespace so before we go ahead let's

whitespace so before we go ahead let's
actually make our repple just print it

actually make our repple just print it

actually make our repple just print it
back to us so we actually know what's

back to us so we actually know what's

back to us so we actually know what's
going on

going on

going on
so let's actually allocate a lecturer no

so let's actually allocate a lecturer no

so let's actually allocate a lecturer no
lecturer for the line and then we say

lecturer for the line and then we say

lecturer for the line and then we say
while tool bar a token enclosed excerpt

while tool bar a token enclosed excerpt

while tool bar a token enclosed excerpt
reads good how do we call it next okay

reads good how do we call it next okay

reads good how do we call it next okay
all right next token oh yeah one thing

all right next token oh yeah one thing

all right next token oh yeah one thing
we should probably do that's also

we should probably do that's also

we should probably do that's also
conventional is that there's this magic

conventional is that there's this magic

conventional is that there's this magic
token called end of file so at the very

token called end of file so at the very

token called end of file so at the very
beginning we should probably say if the

beginning we should probably say if the

beginning we should probably say if the
position is text length or larger than

position is text length or larger than

position is text length or larger than
that then we just return the magic new

that then we just return the magic new

that then we just return the magic new
syntax token and we call this in kind

syntax token and we call this in kind

syntax token and we call this in kind
and of file token the position is the

and of file token the position is the

and of file token the position is the
end of file it has no text well I guess

end of file it has no text well I guess

end of file it has no text well I guess
we could cheat and say this is the magic

we could cheat and say this is the magic

we could cheat and say this is the magic
thing here and let me say has no value

thing here and let me say has no value

thing here and let me say has no value
so this is effectively done by pretty

so this is effectively done by pretty

so this is effectively done by pretty
much any parser in the universe because

much any parser in the universe because

much any parser in the universe because
it allows the reader to know when

it allows the reader to know when

it allows the reader to know when
there's no more stuff coming so this is

there's no more stuff coming so this is

there's no more stuff coming so this is
basically a virtual token it doesn't

basically a virtual token it doesn't

basically a virtual token it doesn't
actually exist in the input file unless

actually exist in the input file unless

actually exist in the input file unless
you think and see and you think the

you think and see and you think the

you think and see and you think the
string is always 0 terminated in which

string is always 0 terminated in which

string is always 0 terminated in which
case you can think of it as the 0

case you can think of it as the 0

case you can think of it as the 0
terminator alright so now we have the

terminator alright so now we have the

terminator alright so now we have the
token now let's put this guy so let's

token now let's put this guy so let's

token now let's put this guy so let's
say console.writeline so i guess we

say console.writeline so i guess we

say console.writeline so i guess we
could say if token

could say if token

could say if token
kind equals syntax kind and a file token

kind equals syntax kind and a file token

kind equals syntax kind and a file token
and we can just say stop it

and we can just say stop it

and we can just say stop it
otherwise obscene otherwise we write the

otherwise obscene otherwise we write the

otherwise obscene otherwise we write the
token kind and yeah let's print the text

token kind and yeah let's print the text

token kind and yeah let's print the text
as well talking text

in fact let's also say if token value is

in fact let's also say if token value is
not now then console right

yeah let's do it into a belated string

yeah let's do it into a belated string
here as well let's say what is that

here as well let's say what is that

here as well let's say what is that
token dot radio and then we can say

token dot radio and then we can say

token dot radio and then we can say
console dot write line so if you're

console dot write line so if you're

console dot write line so if you're
thinking to yourself I know this all

thinking to yourself I know this all

thinking to yourself I know this all
looks horribly inefficient that is kind

looks horribly inefficient that is kind

looks horribly inefficient that is kind
of okay because we still write our

of okay because we still write our

of okay because we still write our
compiler right so we want to not waste

compiler right so we want to not waste

compiler right so we want to not waste
too much time doing stuff we don't care

too much time doing stuff we don't care

too much time doing stuff we don't care
about yet all right so now let's see how

about yet all right so now let's see how

about yet all right so now let's see how
bad I did the moment of truth so let's

bad I did the moment of truth so let's

bad I did the moment of truth so let's
say one plus two times three that's not

say one plus two times three that's not

say one plus two times three that's not
bad so far so we have a number token one

bad so far so we have a number token one

bad so far so we have a number token one
we have a whitespace token we have a

we have a whitespace token we have a

we have a whitespace token we have a
plus token we have a whitespace token

plus token we have a whitespace token

plus token we have a whitespace token
find out the whitespace tokens all have

find out the whitespace tokens all have

find out the whitespace tokens all have
values it seems how did that happen

values it seems how did that happen

values it seems how did that happen
oh because I'm needed because there's

oh because I'm needed because there's

oh because I'm needed because there's
really no reason to parse those guys

so now we're going to say let's say

so now we're going to say let's say
something similar like 123

something similar like 123

something similar like 123
- 456 so now we have one token that is 1

- 456 so now we have one token that is 1

- 456 so now we have one token that is 1
2 3

2 3

2 3
we have whitespace talk we have a -

we have whitespace talk we have a -

we have whitespace talk we have a -
token another whitespace token number

token another whitespace token number

token another whitespace token number
number token and that's the end so

number token and that's the end so

number token and that's the end so
that's pretty good so now we at least

that's pretty good so now we at least

that's pretty good so now we at least
know the detective actual Virts if you

know the detective actual Virts if you

know the detective actual Virts if you
will in the in the input so that's

will in the in the input so that's

will in the in the input so that's
pretty decent but this is obviously not

pretty decent but this is obviously not

pretty decent but this is obviously not
a parser yet so let's check the next

a parser yet so let's check the next

a parser yet so let's check the next
step here so know we had a lecture now

step here so know we had a lecture now

step here so know we had a lecture now
let's do a parser so the lexer produces

let's do a parser so the lexer produces

let's do a parser so the lexer produces
tokens which you can think of the leaves

tokens which you can think of the leaves

tokens which you can think of the leaves
in your tree and then the parser

in your tree and then the parser

in your tree and then the parser
produces the the actual sentences which

produces the the actual sentences which

produces the the actual sentences which
are trees and they're basically syntax

are trees and they're basically syntax

are trees and they're basically syntax
notes

notes

notes
so let's I'm fighting way too much of

so let's I'm fighting way too much of

so let's I'm fighting way too much of
this I don't know why the code folding

this I don't know why the code folding

this I don't know why the code folding
doesn't work the way I want alright

doesn't work the way I want alright

doesn't work the way I want alright
let's do a parser so there's multiple

let's do a parser so there's multiple

let's do a parser so there's multiple
ways you can do parser like if you read

ways you can do parser like if you read

ways you can do parser like if you read
the most of the compiler books from the

the most of the compiler books from the

the most of the compiler books from the
70s or 80s I'd say they actually really

70s or 80s I'd say they actually really

70s or 80s I'd say they actually really
highly optimized for streaming so they

highly optimized for streaming so they

highly optimized for streaming so they
try to not Lex the entire input they

try to not Lex the entire input they

try to not Lex the entire input they
will usually like consume one token at a

will usually like consume one token at a

will usually like consume one token at a
time and then maybe ever look ahead or

time and then maybe ever look ahead or

time and then maybe ever look ahead or
whatever but one of computers are really

whatever but one of computers are really

whatever but one of computers are really
good and so what I just will do is I

good and so what I just will do is I

good and so what I just will do is I
will just say screw this I would just

will just say screw this I would just

will just say screw this I would just
actually in it it's a parser I would

actually in it it's a parser I would

actually in it it's a parser I would
take the text here as well

take the text here as well

take the text here as well
and then what I will do is the first

and then what I will do is the first

and then what I will do is the first
step is I will literally just run the

step is I will literally just run the

step is I will literally just run the
lecture on the entire input so I will

lecture on the entire input so I will

lecture on the entire input so I will
create a lecture here new extra but that

create a lecture here new extra but that

create a lecture here new extra but that
will give the text this is one of those

will give the text this is one of those

will give the text this is one of those
moments where I think I wonder why you a

moments where I think I wonder why you a

moments where I think I wonder why you a
do loop I will probably regret this

do loop I will probably regret this

do loop I will probably regret this
choice because every single time I did

choice because every single time I did

choice because every single time I did
that I later on we voted into a while

that I later on we voted into a while

that I later on we voted into a while
true loop token equals lecture

true loop token equals lecture

true loop token equals lecture
good next next okay I'm bad at naming

good next next okay I'm bad at naming

good next next okay I'm bad at naming
did I mention that yeah next okay and

did I mention that yeah next okay and

did I mention that yeah next okay and
let me say if token let's say is syntax

let me say if token let's say is syntax

let me say if token let's say is syntax
actually no that's the well part right

actually no that's the well part right

actually no that's the well part right
while token kind is not syntax kind and

while token kind is not syntax kind and

while token kind is not syntax kind and
all file we keep doing this now what we

all file we keep doing this now what we

all file we keep doing this now what we
need here is we need a list of tokens so

need here is we need a list of tokens so

need here is we need a list of tokens so
let's say of our tokens equals new list

let's say of our tokens equals new list

let's say of our tokens equals new list
syntax token and then we will just say

syntax token and then we will just say

syntax token and then we will just say
if token kind is not syntax kind

if token kind is not syntax kind

if token kind is not syntax kind
whitespace because really don't care

whitespace because really don't care

whitespace because really don't care
about whitespace for the most part right

about whitespace for the most part right

about whitespace for the most part right
and if it's not a bad token token kind

bad token then we say tokens dot at

bad token then we say tokens dot at
token I'm probably be using for that guy

token I'm probably be using for that guy

token I'm probably be using for that guy
yep all right now let's say tokens

equals tokens to array because why not

equals tokens to array because why not
and then we say create me if we'd only

and then we say create me if we'd only

and then we say create me if we'd only
filled tokens sweet I'll so much the

filled tokens sweet I'll so much the

filled tokens sweet I'll so much the
other one we need a position which is

other one we need a position which is

other one we need a position which is
basically our current token yeah

basically our current token yeah

basically our current token yeah
what's important is if you read this

what's important is if you read this

what's important is if you read this
correctly end of file is part of the

correctly end of file is part of the

correctly end of file is part of the
token list all right so that means I

token list all right so that means I

token list all right so that means I
always know even on an empty input I

always know even on an empty input I

always know even on an empty input I
will always have one token which is end

will always have one token which is end

will always have one token which is end
of file so what we can do is we can say

of file so what we can do is we can say

of file so what we can do is we can say
we have a pub no private private syntax

we have a pub no private private syntax

we have a pub no private private syntax
token let's call this peak end offset

token let's call this peak end offset

token let's call this peak end offset
and I will later on tell you why I think

and I will later on tell you why I think

and I will later on tell you why I think
this is useful so we say index equals

this is useful so we say index equals

this is useful so we say index equals
position plus offset if index is outside

position plus offset if index is outside

position plus offset if index is outside
the bounds we will just return tokens

the bounds we will just return tokens

the bounds we will just return tokens
tokens length minus 1 we just returned

tokens length minus 1 we just returned

tokens length minus 1 we just returned
the last one otherwise we return tokens

the last one otherwise we return tokens

the last one otherwise we return tokens
index so this means I don't have to

index so this means I don't have to

index so this means I don't have to
think too hard when I want to peek ahead

think too hard when I want to peek ahead

think too hard when I want to peek ahead
if you will and then we can say we have

if you will and then we can say we have

if you will and then we can say we have
a private syntax token current which

a private syntax token current which

a private syntax token current which
basically just is peek 0 basically give

basically just is peek 0 basically give

basically just is peek 0 basically give
me the give me what's at position and

me the give me what's at position and

me the give me what's at position and
everything else is just slightly ahead

everything else is just slightly ahead

everything else is just slightly ahead
of that so this is the nice thing and

of that so this is the nice thing and

of that so this is the nice thing and
you legs everything at once because it

you legs everything at once because it

you legs everything at once because it
means you can look ahead at the next

means you can look ahead at the next

means you can look ahead at the next
token to make this

token to make this

token to make this
how you want to parse it the entire

how you want to parse it the entire

how you want to parse it the entire
input file which tends to work pretty

input file which tends to work pretty

input file which tends to work pretty
well all right now so we have a class

well all right now so we have a class

well all right now so we have a class
syntax token yep what we also need is a

syntax token yep what we also need is a

syntax token yep what we also need is a
syntax note right so let's do this so

syntax note right so let's do this so

syntax note right so let's do this so
let's say we have a class syntax note

let's say we have a class syntax note

let's say we have a class syntax note
syntax note and again this guy needs and

syntax note and again this guy needs and

syntax note and again this guy needs and
public abstract syntax kind kind you

public abstract syntax kind kind you

public abstract syntax kind kind you
will need this later to decide what kind

will need this later to decide what kind

will need this later to decide what kind
is this this guy will be abstract

is this this guy will be abstract

is this this guy will be abstract
because it's basically just the base

because it's basically just the base

because it's basically just the base
type for all my syntax notes and all

type for all my syntax notes and all

type for all my syntax notes and all
let's think about how you want to

let's think about how you want to

let's think about how you want to
represent the input so this is some of

represent the input so this is some of

represent the input so this is some of
these areas where maybe a picture would

these areas where maybe a picture would

these areas where maybe a picture would
be more useful so if you have an

be more useful so if you have an

be more useful so if you have an
expression like this right if you say 1

expression like this right if you say 1

expression like this right if you say 1
plus 2 times 3 what you really want is a

plus 2 times 3 what you really want is a

plus 2 times 3 what you really want is a
tree representation which roughly looks

tree representation which roughly looks

tree representation which roughly looks
like this so you have one here you have

like this so you have one here you have

like this so you have one here you have
the plus here and then you based on

the plus here and then you based on

the plus here and then you based on
operator pressure precedences the tree

operator pressure precedences the tree

operator pressure precedences the tree
will look like this right so in other

will look like this right so in other

will look like this right so in other
words you do if you look at this from a

words you do if you look at this from a

words you do if you look at this from a
tree strong I'm actually really bad at

tree strong I'm actually really bad at

tree strong I'm actually really bad at
drawing trees yeah that's not horrible

and then this is two this is three so

and then this is two this is three so
what you see here is basically a tree

what you see here is basically a tree

what you see here is basically a tree
where the leaf node is effectively the

where the leaf node is effectively the

where the leaf node is effectively the
tokens in the input file and then you

tokens in the input file and then you

tokens in the input file and then you
have a binary operator plus in this case

have a binary operator plus in this case

have a binary operator plus in this case
and then so if you want to evaluate this

and then so if you want to evaluate this

and then so if you want to evaluate this
thing you just basically say well plus

thing you just basically say well plus

thing you just basically say well plus
will give me the left value one give me

will give me the left value one give me

will give me the left value one give me
the right value okay that's another

the right value okay that's another

the right value okay that's another
expression 2 times 3 and then you add

expression 2 times 3 and then you add

expression 2 times 3 and then you add
the result right so basically in our

the result right so basically in our

the result right so basically in our
case this would be a node probably

case this would be a node probably

case this would be a node probably
number a number node this would be a

number a number node this would be a

number a number node this would be a
binary operator a node because it has

binary operator a node because it has

binary operator a node because it has
two inputs and everything else is just

two inputs and everything else is just

two inputs and everything else is just
chained together right so if you do

chained together right so if you do

chained together right so if you do
stuff like this it will look even

stuff like this it will look even

stuff like this it will look even
simpler it would look like this right

simpler it would look like this right

simpler it would look like this right
you would have to

I'd so like this is what would happen if

I'd so like this is what would happen if
you just parse this input here so this

you just parse this input here so this

you just parse this input here so this
is the kind of tree you want to produce

is the kind of tree you want to produce

is the kind of tree you want to produce
it will show later how this wool how

it will show later how this wool how

it will show later how this wool how
this will work so for now we need

this will work so for now we need

this will work so for now we need
basically a number a number node which

basically a number a number node which

basically a number a number node which
represents our leaves and then our

represents our leaves and then our

represents our leaves and then our
binary operators which are our interior

nodes for that so let's start with the

nodes for that so let's start with the
fact that given that we will have

fact that given that we will have

fact that given that we will have
expressions and statements later let's

expressions and statements later let's

expressions and statements later let's
just start with an of an expression

just start with an of an expression

just start with an of an expression
syntax which will for now just derive

syntax which will for now just derive

syntax which will for now just derive
from syntax node and does nothing

from syntax node and does nothing

from syntax node and does nothing
special but it does simplify our design

special but it does simplify our design

special but it does simplify our design
a little bit I think and then we have

a little bit I think and then we have

a little bit I think and then we have
actual instances so let's say we have

actual instances so let's say we have

actual instances so let's say we have
the number syntax which is of type

the number syntax which is of type

the number syntax which is of type
expression syntax and now we can say

expression syntax and now we can say

expression syntax and now we can say
let's have a constructor it's called as

let's have a constructor it's called as

let's have a constructor it's called as
number syntax so what does this guy need

number syntax so what does this guy need

number syntax so what does this guy need
well it only needs the syntax token

well it only needs the syntax token

well it only needs the syntax token
which represents the number so that's

which represents the number so that's

which represents the number so that's
the number token that be there we got

the number token that be there we got

the number token that be there we got
all right now let's implement the

all right now let's implement the

all right now let's implement the
abstract class in our case we say this

abstract class in our case we say this

abstract class in our case we say this
would be syntax kind number expression

would be syntax kind number expression

would be syntax kind number expression
again this doesn't exist right now so we

again this doesn't exist right now so we

again this doesn't exist right now so we
edit and then we just store this guy as

edit and then we just store this guy as

edit and then we just store this guy as
monitors the fields let's make this a

monitors the fields let's make this a

monitors the fields let's make this a
property

property

property
[Music]

[Music]

[Music]
okay now let's do a sealed class binary

okay now let's do a sealed class binary

okay now let's do a sealed class binary
expression syntax in fact let's call

expression syntax in fact let's call

expression syntax in fact let's call
this number expression syntax just for

this number expression syntax just for

this number expression syntax just for
consistency reasons and then let's fix

consistency reasons and then let's fix

consistency reasons and then let's fix
the typo we have what did I say

the typo we have what did I say

the typo we have what did I say
expression syntax right so what would

expression syntax right so what would

expression syntax right so what would
this guy need well it would get the left

this guy need well it would get the left

this guy need well it would get the left
expression right so we have an

expression right so we have an

expression right so we have an
expression syntax that represents the

expression syntax that represents the

expression syntax that represents the
left side we have a syntax token that

left side we have a syntax token that

left side we have a syntax token that
represents the OP rate or token and then

represents the OP rate or token and then

represents the OP rate or token and then
we have an expression syntax right and

we have an expression syntax right and

we have an expression syntax right and
again I suck at typing let me fix this

again I suck at typing let me fix this

again I suck at typing let me fix this
so let's store these guys property

so let's store these guys property

so let's store these guys property
property and property oh yeah property

property and property oh yeah property

property and property oh yeah property
explosion alright let's do this as well

explosion alright let's do this as well

explosion alright let's do this as well
and let's say this is syntax kind binary

and let's say this is syntax kind binary

and let's say this is syntax kind binary
expression so the only reason we have

expression so the only reason we have

expression so the only reason we have
these kinds by the way is just so that

these kinds by the way is just so that

these kinds by the way is just so that
we can just switch over them which is

we can just switch over them which is

we can just switch over them which is
slightly more efficient than doing an

slightly more efficient than doing an

slightly more efficient than doing an
ask us all the time

ask us all the time

ask us all the time
and have to check for the actual

and have to check for the actual

and have to check for the actual
instance it's basically if you do

instance it's basically if you do

instance it's basically if you do
f-sharp

f-sharp

f-sharp
you probably think less of me right now

you probably think less of me right now

you probably think less of me right now
because it's much easier an f-sharp

because it's much easier an f-sharp

because it's much easier an f-sharp
because they have Union types and

because they have Union types and

because they have Union types and
c-sharp you have to do this by hand all

c-sharp you have to do this by hand all

c-sharp you have to do this by hand all
right so we have left right so that

right so we have left right so that

right so we have left right so that
seems like we have our data structures

seems like we have our data structures

seems like we have our data structures
at least somewhat in order for now and

at least somewhat in order for now and

at least somewhat in order for now and
all the part everybody has waited for

all the part everybody has waited for

all the part everybody has waited for
and how do you parse this stuff so let's

and how do you parse this stuff so let's

and how do you parse this stuff so let's
start with a public method public and

start with a public method public and

start with a public method public and
say we call this expression but it's

say we call this expression but it's

say we call this expression but it's
called this parse so how do we do this

called this parse so how do we do this

called this parse so how do we do this
so logically let's first think about how

so logically let's first think about how

so logically let's first think about how
the tree structures work right so at the

the tree structures work right so at the

the tree structures work right so at the
very bottom we have numbers so the first

very bottom we have numbers so the first

very bottom we have numbers so the first
thing you want to parse logically is

thing you want to parse logically is

thing you want to parse logically is
the leaves and then you build the other

the leaves and then you build the other

the leaves and then you build the other
structures on top of that and then you

structures on top of that and then you

structures on top of that and then you
know think of the method structure

know think of the method structure

know think of the method structure
basically as mirroring the source

basically as mirroring the source

basically as mirroring the source
structure at the tree structure so what

structure at the tree structure so what

structure at the tree structure so what
do I mean by this okay let's say that

do I mean by this okay let's say that

do I mean by this okay let's say that
started with the with the with the idea

started with the with the with the idea

started with the with the with the idea
that first you parse a primary

that first you parse a primary

that first you parse a primary
expression

expression

expression
maybe T's ever just write it out the

maybe T's ever just write it out the

maybe T's ever just write it out the
primary expression then we can say while

primary expression then we can say while

primary expression then we can say while
the current is syntax kind let's call

the current is syntax kind let's call

the current is syntax kind let's call
this plus token

oh yeah there's one method that we

oh yeah there's one method that we
really want a half which is private

really want a half which is private

really want a half which is private
syntax token next token which basically

syntax token next token which basically

syntax token next token which basically
says if our current is current and then

says if our current is current and then

says if our current is current and then
you say position plus plus and then you

you say position plus plus and then you

you say position plus plus and then you
return current so then we can save our

return current so then we can save our

return current so then we can save our
operator token equals next token and

operator token equals next token and

operator token equals next token and
then we can save our let's call this

then we can save our let's call this

then we can save our let's call this
right parse time ring let's call this

right parse time ring let's call this

right parse time ring let's call this
parse for now actually is there any way

parse for now actually is there any way

parse for now actually is there any way
to do the snow cross for me nevermind

to do the snow cross for me nevermind

to do the snow cross for me nevermind
that's primary expression

and then we can say primary is no new

and then we can say primary is no new
binary operator expression on binary

binary operator expression on binary

binary operator expression on binary
expression I guess we've let's call this

expression I guess we've let's call this

expression I guess we've let's call this
left left

left left

left left
operator token right and then we say

operator token right and then we say

operator token right and then we say
return left

yes and this needs to be kind and then

yes and this needs to be kind and then
primary expression in our kids right now

primary expression in our kids right now

primary expression in our kids right now
is literally just we expected in number

is literally just we expected in number

is literally just we expected in number
so let's do this for now and let's add

so let's do this for now and let's add

so let's do this for now and let's add
another method called match subjects

another method called match subjects

another method called match subjects
some kind kind so the idea is now if

some kind kind so the idea is now if

some kind kind so the idea is now if
current kind is kind then return next

current kind is kind then return next

current kind is kind then return next
token

token

token
[Music]

[Music]

[Music]
otherwise let's fabricate one so I will

otherwise let's fabricate one so I will

otherwise let's fabricate one so I will
explain later whether this is super

explain later whether this is super

explain later whether this is super
useful in the parser I mean you

useful in the parser I mean you

useful in the parser I mean you
basically create tokens but let's now

basically create tokens but let's now

basically create tokens but let's now
say we manufacture syntax Koken of the

say we manufacture syntax Koken of the

say we manufacture syntax Koken of the
kind that was asked at current position

kind that was asked at current position

kind that was asked at current position
it has no text because it's manufactured

it has no text because it's manufactured

it has no text because it's manufactured
and it has no value

all right what's going on here why does

all right what's going on here why does
that not work oh because type expression

that not work oh because type expression

that not work oh because type expression
syntax here we go so we say var number

syntax here we go so we say var number

syntax here we go so we say var number
token equals match syntax kind number

token equals match syntax kind number

token equals match syntax kind number
token and let me say return new number

token and let me say return new number

token and let me say return new number
expression for the number tokens all

expression for the number tokens all

expression for the number tokens all
right this should be happening here come

right this should be happening here come

right this should be happening here come
over from syntax token to syntax note

over from syntax token to syntax note

over from syntax token to syntax note
interesting did I mess it up

interesting did I mess it up

interesting did I mess it up
yep and didn't mess it up that is it

yep and didn't mess it up that is it

yep and didn't mess it up that is it
token not not a note all right so so far

token not not a note all right so so far

token not not a note all right so so far
so good

so good

so good
now the very first thing you will

now the very first thing you will

now the very first thing you will
probably find when you are parsing is

probably find when you are parsing is

probably find when you are parsing is
you really want to see the parse tree

you really want to see the parse tree

you really want to see the parse tree
because if you messed that one up that

because if you messed that one up that

because if you messed that one up that
is usually very annoying so I suggest we

is usually very annoying so I suggest we

is usually very annoying so I suggest we
go to the subjects node and we add the

go to the subjects node and we add the

go to the subjects node and we add the
notion of children because once we have

notion of children because once we have

notion of children because once we have
that we can actually walk the tree in a

that we can actually walk the tree in a

that we can actually walk the tree in a
generic way so let's say we have an

generic way so let's say we have an

generic way so let's say we have an
ienumerable of syntax node and we call

ienumerable of syntax node and we call

ienumerable of syntax node and we call
this get children

and let's make this guy abstract what

and let's make this guy abstract what
helps right now again this is probably

helps right now again this is probably

helps right now again this is probably
not what the production compiler would

not what the production compiler would

not what the production compiler would
look like but for now let's just say

look like but for now let's just say

look like but for now let's just say
syntax tokens I just notes because if we

syntax tokens I just notes because if we

syntax tokens I just notes because if we
do that then we can basically pretend

do that then we can basically pretend

do that then we can basically pretend
that some text tokens are actually the

that some text tokens are actually the

that some text tokens are actually the
leaves in our in our tree so this means

leaves in our in our tree so this means

leaves in our in our tree so this means
this guy does nothing so we say return

this guy does nothing so we say return

this guy does nothing so we say return
in your mobile thought empty or syntax

in your mobile thought empty or syntax

in your mobile thought empty or syntax
note

yes I need that all right no we can say

yes I need that all right no we can say
our number expression syntax just

our number expression syntax just

our number expression syntax just
returns our number token Jesus I'm

returns our number token Jesus I'm

returns our number token Jesus I'm
really bad at typing today usually not

really bad at typing today usually not

really bad at typing today usually not
that bad

then a binary expression will first

then a binary expression will first
yield return our left

yield return our left

yield return our left
then I'll operate a token and then we

then I'll operate a token and then we

then I'll operate a token and then we
say we want to return our right so you

say we want to return our right so you

say we want to return our right so you
have never used yield it's a very

have never used yield it's a very

have never used yield it's a very
convenient way to write stateful

convenient way to write stateful

convenient way to write stateful
iterators where effectively this

iterators where effectively this

iterators where effectively this
produces an enumerable where the first

produces an enumerable where the first

produces an enumerable where the first
item is left I could also just literally

item is left I could also just literally

item is left I could also just literally
create an array here that would probably

create an array here that would probably

create an array here that would probably
work as well but I don't know I find

work as well but I don't know I find

work as well but I don't know I find
these a little bit easier because they

these a little bit easier because they

these a little bit easier because they
can shuffle them around and again

can shuffle them around and again

can shuffle them around and again
efficiency right now it's not all

efficiency right now it's not all

efficiency right now it's not all
primary goal all right now we can

primary goal all right now we can

primary goal all right now we can
traverse the tree so now let's actually

change our main method here let's add a

change our main method here let's add a
new method static void pretty print and

new method static void pretty print and

new method static void pretty print and
it takes let's say a syntax note note we

it takes let's say a syntax note note we

it takes let's say a syntax note note we
probably want the indent what we have

probably want the indent what we have

probably want the indent what we have
written so far actually if we want this

written so far actually if we want this

written so far actually if we want this
why everyone wants a indent and then

why everyone wants a indent and then

why everyone wants a indent and then
starts with an empty string and then we

starts with an empty string and then we

starts with an empty string and then we
can literally just say console dot right

can literally just say console dot right

can literally just say console dot right
let's say no dot kind

and let's say this if note is syntax

and let's say this if note is syntax
token T let's say console right

token T let's say console right

token T let's say console right
[Music]

now actually let's just do this and T

now actually let's just do this and T
values not know in which case we add the

values not know in which case we add the

values not know in which case we add the
token value here and then we just say

token value here and then we just say

token value here and then we just say
indent plus equals what do we want for

indent plus equals what do we want for

indent plus equals what do we want for
spaces 1 2 3 4 I guess that works and

spaces 1 2 3 4 I guess that works and

spaces 1 2 3 4 I guess that works and
then we can say for h-bar child in know

then we can say for h-bar child in know

then we can say for h-bar child in know
to get children we can say pretty print

to get children we can say pretty print

to get children we can say pretty print
the child with the end and I should do

the child with the end and I should do

the child with the end and I should do
it for now all right now let's go back

it for now all right now let's go back

it for now all right now let's go back
here so instead of doing this we save

here so instead of doing this we save

here so instead of doing this we save
our parse our new parser for the line

let me say expression equals parser dot

let me say expression equals parser dot
parse and then let me just say our color

parse and then let me just say our color

parse and then let me just say our color
equals console foreground let's say and

equals console foreground let's say and

equals console foreground let's say and
let me say console dot foreground

let me say console dot foreground

let me say console dot foreground
console what is the console color dark

console what is the console color dark

console what is the console color dark
grey I don't know I know why I did this

grey I don't know I know why I did this

grey I don't know I know why I did this
but it seems cool and then we can just

but it seems cool and then we can just

but it seems cool and then we can just
restore the color here I guess

little swap damn I didn't type

little swap damn I didn't type
everything here and there is just a

everything here and there is just a

everything here and there is just a
pretty print for our what is that

pretty print for our what is that

pretty print for our what is that
expression let me just let me just

expression let me just let me just

expression let me just let me just
create it

create it

create it
alright so we have that part

alright I'm inclined to run it now and

alright I'm inclined to run it now and
see how bad I did all right let's do one

see how bad I did all right let's do one

see how bad I did all right let's do one
plus two plus three for now oh yeah we

plus two plus three for now oh yeah we

plus two plus three for now oh yeah we
did really well I guess you forgot or

did really well I guess you forgot or

did really well I guess you forgot or
yes you should have done this console

yes you should have done this console

yes you should have done this console
dot write line I guess it makes it

dot write line I guess it makes it

dot write line I guess it makes it
slightly more

that is interesting oh yeah yeah console

that is interesting oh yeah yeah console
dot right indent it's cool when you

dot right indent it's cool when you

dot right indent it's cool when you
construct in and but you also need to

construct in and but you also need to

construct in and but you also need to
write it to the console otherwise it

write it to the console otherwise it

write it to the console otherwise it
doesn't do much one plus two plus three

doesn't do much one plus two plus three

doesn't do much one plus two plus three
there you go so the binary expression

there you go so the binary expression

there you go so the binary expression
that is a binary expression that has a

that is a binary expression that has a

that is a binary expression that has a
number expression with the number token

number expression with the number token

number expression with the number token
and a plus two Oakland and number

and a plus two Oakland and number

and a plus two Oakland and number
expression so that's effectively the

expression so that's effectively the

expression so that's effectively the
tree that I drew earlier I the only

tree that I drew earlier I the only

tree that I drew earlier I the only
thing that annoys me slightly is what

thing that annoys me slightly is what

thing that annoys me slightly is what
does that called tree it would be nicer

does that called tree it would be nicer

does that called tree it would be nicer
if you would get and I'll put that looks

if you would get and I'll put that looks

if you would get and I'll put that looks
more like this

more like this

more like this
so let's actually get these

because he'll be looking at those guys a

because he'll be looking at those guys a
lot so he might as well make it actually

lot so he might as well make it actually

lot so he might as well make it actually
pretty um so many desk guy and there's

pretty um so many desk guy and there's

pretty um so many desk guy and there's
one more right there's the the center

one more right there's the the center

one more right there's the the center
guy that we need yeah something like

guy that we need yeah something like

guy that we need yeah something like
that

that

that
no we have to think about how we

no we have to think about how we

no we have to think about how we
construct these guys how did that work

construct these guys how did that work

construct these guys how did that work
again I think I need something like is

again I think I need something like is

again I think I need something like is
last I think the default is false

last I think the default is false

last I think the default is false
[Music]

[Music]

[Music]
so

so how do we indent you basically say if

so how do we indent you basically say if
is lost then we say indent is Plus this

to do this right it is this and it's

to do this right it is this and it's
that otherwise if it is not the last one

and then how do we know something is to

and then how do we know something is to
laugh you save lost is no get children

laugh you save lost is no get children

laugh you save lost is no get children
thought lost that's just cheat here and

thought lost that's just cheat here and

thought lost that's just cheat here and
then we just say you are it's called

then we just say you are it's called

then we just say you are it's called
this last child lost child something

this last child lost child something

this last child lost child something
like that and then I think I only need

like that and then I think I only need

like that and then I think I only need
to

to

to
[Music]

and as this guy come from

and as this guy come from
that

mmm let me quickly ones I'm not entirely

mmm let me quickly ones I'm not entirely
sure I might have missed up the what

sure I might have missed up the what

sure I might have missed up the what
happened why did this disappear so fast

one plus two plus three and that seems

one plus two plus three and that seems
reasonable

reasonable

reasonable
oh we crashed that is true last are the

oh we crashed that is true last are the

oh we crashed that is true last are the
falls to the rescue alright so this

falls to the rescue alright so this

falls to the rescue alright so this
looks pretty ugly so I think

so what is happening here is I believe

so what is happening here is I believe
that it

I think we create the England too

I think we create the England too
quickly right so

I think it's like this right so let's

I think it's like this right so let's
call this bar marker so we need to write

call this bar marker so we need to write

call this bar marker so we need to write
the indent and then we say write our

the indent and then we say write our

the indent and then we say write our
marker something like that right and

marker something like that right and

marker something like that right and
then we say by the way this is indent

[Music]

[Music]
yep and it actually helps if you're--if

yep and it actually helps if you're--if

yep and it actually helps if you're--if
check is not screwed up of course he has

check is not screwed up of course he has

check is not screwed up of course he has
to change this guy no I think we have

to change this guy no I think we have

to change this guy no I think we have
something that is actually borderline

something that is actually borderline

something that is actually borderline
readable except it's not the the the why

readable except it's not the the the why

readable except it's not the the the why
is that again

I guess it's like this right it's it's

I guess it's like this right it's it's
lost then it is 1 2 3 4

man this is like trial and error

man this is like trial and error
programming right here close-ish except

programming right here close-ish except

programming right here close-ish except
for the first one yeah which I think the

for the first one yeah which I think the

for the first one yeah which I think the
default is messed up the default should

default is messed up the default should

default is messed up the default should
be true and then I think I have it man

be true and then I think I have it man

be true and then I think I have it man
pretty printing trees the hardest

pretty printing trees the hardest

pretty printing trees the hardest
problem of compiler construction

problem of compiler construction

problem of compiler construction
apparently alright so now we can

apparently alright so now we can

apparently alright so now we can
actually read this thing

actually read this thing

actually read this thing
not too shabby I'd say alright so now in

not too shabby I'd say alright so now in

not too shabby I'd say alright so now in
order for us to actually make something

order for us to actually make something

order for us to actually make something
useful out of this yeah it's a bit of a

useful out of this yeah it's a bit of a

useful out of this yeah it's a bit of a
comment on my horrible string

comment on my horrible string

comment on my horrible string
concatenation but that's just the way it

concatenation but that's just the way it

concatenation but that's just the way it
is for now so now we have these guys

is for now so now we have these guys

is for now so now we have these guys
here now I think we're the first thing I

here now I think we're the first thing I

here now I think we're the first thing I
would like to do is deal with arrows

would like to do is deal with arrows

would like to do is deal with arrows
because right now so far we have ignored

because right now so far we have ignored

because right now so far we have ignored
any arrows we don't print anything we

any arrows we don't print anything we

any arrows we don't print anything we
just silently ignore them and again if

just silently ignore them and again if

just silently ignore them and again if
you want to build a compiler that's

you want to build a compiler that's

you want to build a compiler that's
probably the first thing you want to pay

probably the first thing you want to pay

probably the first thing you want to pay
attention to because otherwise it will

attention to because otherwise it will

attention to because otherwise it will
be lost forever in why stuff doesn't

be lost forever in why stuff doesn't

be lost forever in why stuff doesn't
work the way you wanted to when it turns

work the way you wanted to when it turns

work the way you wanted to when it turns
out that your parts are just did it a

out that your parts are just did it a

out that your parts are just did it a
little heart attack in the middle and

little heart attack in the middle and

little heart attack in the middle and
you never knew about it so the first

you never knew about it so the first

you never knew about it so the first
thing I want to do is I want to

thing I want to do is I want to

thing I want to do is I want to
introduce the notion of arrows and I'm

introduce the notion of arrows and I'm

introduce the notion of arrows and I'm
lazy right now so I will just call them

lazy right now so I will just call them

lazy right now so I will just call them
literally just a bunch of strings so

literally just a bunch of strings so

literally just a bunch of strings so
let's do this and let's say we have a

let's do this and let's say we have a

let's do this and let's say we have a
list of string which we call Diagnostics

list of string which we call Diagnostics

list of string which we call Diagnostics
new list of string and we will expose

new list of string and we will expose

new list of string and we will expose
this to the public by saying public I

this to the public by saying public I

this to the public by saying public I
know mobile string Diagnostics

know mobile string Diagnostics

know mobile string Diagnostics
they just returned our Diagnostics right

they just returned our Diagnostics right

they just returned our Diagnostics right
so now whatever we find something that

so now whatever we find something that

so now whatever we find something that
is bad like for example this we can say

is bad like for example this we can say

is bad like for example this we can say
Diagnostics ad and we can say error bad

Diagnostics ad and we can say error bad

Diagnostics ad and we can say error bad
token a bad character in input which in

token a bad character in input which in

token a bad character in input which in
our case we can probably say it's too

our case we can probably say it's too

our case we can probably say it's too
current here good enough so this way we

current here good enough so this way we

current here good enough so this way we
at least know what's going on of course

at least know what's going on of course

at least know what's going on of course
not everyone would record the position

not everyone would record the position

not everyone would record the position
but let's leave this for a later state

but let's leave this for a later state

but let's leave this for a later state
now let's do the same thing at the

now let's do the same thing at the

now let's do the same thing at the
parser so the parser where is it should

parser so the parser where is it should

parser so the parser where is it should
have that as well so private list string

have that as well so private list string

have that as well so private list string
Diagnostics new pistol string

so of course at the beginning we should

so of course at the beginning we should
say Diagnostics range lecture

say Diagnostics range lecture

say Diagnostics range lecture
Diagnostics so we don't forget what the

Diagnostics so we don't forget what the

Diagnostics so we don't forget what the
legs are reported and then everything

legs are reported and then everything

legs are reported and then everything
the time you see something bad here like

the time you see something bad here like

the time you see something bad here like
for example here we can say Diagnostics

for example here we can say Diagnostics

for example here we can say Diagnostics
add arrow unexpected so can let's do

add arrow unexpected so can let's do

add arrow unexpected so can let's do
this and let's call this what is that

this and let's call this what is that

this and let's call this what is that
current current expected

all right that's pretty decent no that's

all right that's pretty decent no that's
actually if we find any arrows let's

actually if we find any arrows let's

actually if we find any arrows let's
report them so we can say if parser I

report them so we can say if parser I

report them so we can say if parser I
think we have an exposed to in the

think we have an exposed to in the

think we have an exposed to in the
process okay did it uh no we have not

process okay did it uh no we have not

process okay did it uh no we have not
so let's say there's a public what is

so let's say there's a public what is

so let's say there's a public what is
happening with my tab here

what is happening I never had that

what is happening I never had that
public public ienumerable off string

public public ienumerable off string

public public ienumerable off string
Diagnostics let me say this is you guys

Diagnostics let me say this is you guys

Diagnostics let me say this is you guys
all right Tipton will focus no what's

all right Tipton will focus no what's

all right Tipton will focus no what's
that I would ever do that alright so if

that I would ever do that alright so if

that I would ever do that alright so if
the person has any Diagnostics parser

the person has any Diagnostics parser

the person has any Diagnostics parser
Diagnostics any then we say you know

Diagnostics any then we say you know

Diagnostics any then we say you know
let's change this color to something

let's change this color to something

let's change this color to something
dark red maybe I might regret dark red

dark red maybe I might regret dark red

dark red maybe I might regret dark red
it's probably unreadable well we'll find

it's probably unreadable well we'll find

it's probably unreadable well we'll find
out for each of our diagnostic in

out for each of our diagnostic in

out for each of our diagnostic in
presser Diagnostics console.writeline

presser Diagnostics console.writeline

presser Diagnostics console.writeline
diagnostic

all right let's check that out

all right let's check that out
so if we say let's do a bunch of garbage

so if we say let's do a bunch of garbage

so if we say let's do a bunch of garbage
so we get better parse tree which I

so we get better parse tree which I

so we get better parse tree which I
would like to highlight so we get a

would like to highlight so we get a

would like to highlight so we get a
valid parse tree back it's just because

valid parse tree back it's just because

valid parse tree back it's just because
we expected a number expression right so

we expected a number expression right so

we expected a number expression right so
we got that one and we have a bunch of

we got that one and we have a bunch of

we got that one and we have a bunch of
arrows and then we get parse errors as

arrows and then we get parse errors as

arrows and then we get parse errors as
well so now if we say 1 plus we get an

well so now if we say 1 plus we get an

well so now if we say 1 plus we get an
arrow that says unexpected token and a

arrow that says unexpected token and a

arrow that says unexpected token and a
file and expected a number token all

file and expected a number token all

file and expected a number token all
right because it was after the plus

unfortunately we also have this

unfortunately we also have this
situation where right now we are not

situation where right now we are not

situation where right now we are not
reporting an error because what happened

reporting an error because what happened

reporting an error because what happened
is we parsed an expression and then we

is we parsed an expression and then we

is we parsed an expression and then we
didn't assert that when parsing was done

didn't assert that when parsing was done

didn't assert that when parsing was done
we're actually having end-of-file which

we're actually having end-of-file which

we're actually having end-of-file which
is a problem because now you can have

is a problem because now you can have

is a problem because now you can have
basically trading garbage can you

basically trading garbage can you

basically trading garbage can you
consider that legal which is not what

consider that legal which is not what

consider that legal which is not what
you want so in order to address that the

you want so in order to address that the

you want so in order to address that the
cleanest way I think is for us to use a

cleanest way I think is for us to use a

cleanest way I think is for us to use a
new type which represents the entire

new type which represents the entire

new type which represents the entire
input and we call this guy the syntax

input and we call this guy the syntax

input and we call this guy the syntax
tree and so the syntax tree will

tree and so the syntax tree will

tree and so the syntax tree will
basically hold on to our expression

basically hold on to our expression

basically hold on to our expression
syntax we call this root and let's say

syntax we call this root and let's say

syntax we call this root and let's say
syntax token and a file token why would

syntax token and a file token why would

syntax token and a file token why would
I want to do that make this a property

I want to do that make this a property

I want to do that make this a property
make this guy a property and then we can

make this guy a property and then we can

make this guy a property and then we can
say also what we expect here

say also what we expect here

say also what we expect here
is and I enumerable of string and we

is and I enumerable of string and we

is and I enumerable of string and we
call this Diagnostics that's also the

call this Diagnostics that's also the

call this Diagnostics that's also the
thing let me return and yeah for the

thing let me return and yeah for the

thing let me return and yeah for the
time being let's just do that even

time being let's just do that even

time being let's just do that even
though that is also bad but good enough

though that is also bad but good enough

though that is also bad but good enough
you just store the annual as is you know

you just store the annual as is you know

you just store the annual as is you know
what not worth it

what not worth it

what not worth it
let's do the right way let's say we

let's do the right way let's say we

let's do the right way let's say we
store this as and I read only list for

store this as and I read only list for

store this as and I read only list for
now and so we just say to array so we

now and so we just say to array so we

now and so we just say to array so we
don't have to worry about any craziness

don't have to worry about any craziness

don't have to worry about any craziness
here then we will do we let our parser

here then we will do we let our parser

here then we will do we let our parser
instead of returning an expression for

instead of returning an expression for

instead of returning an expression for
the root they return a syntax tree let's

the root they return a syntax tree let's

the root they return a syntax tree let's
move this whole thing into another

move this whole thing into another

move this whole thing into another
method let's call this method Paris

method let's call this method Paris

method let's call this method Paris
expression yeah obviously I should

expression yeah obviously I should

expression yeah obviously I should
return an expression subject still then

return an expression subject still then

return an expression subject still then
we can save our expression equals parse

we can save our expression equals parse

we can save our expression equals parse
expression then we can say match syntax

expression then we can say match syntax

expression then we can say match syntax
kind and afar token because that's what

kind and afar token because that's what

kind and afar token because that's what
we really expect the law and of it's

we really expect the law and of it's

we really expect the law and of it's
okay

okay

okay
and then I can say return new syntax

and then I can say return new syntax

and then I can say return new syntax
tree basically our Diagnostics the

tree basically our Diagnostics the

tree basically our Diagnostics the
expression and our end of our token

now this is slightly cleaner so instead

now this is slightly cleaner so instead
of saying expression we say syntax tree

of saying expression we say syntax tree

of saying expression we say syntax tree
then we can say syntax tree root and

then we can say syntax tree root and

then we can say syntax tree root and
then we can say it's syntax tree

then we can say it's syntax tree

then we can say it's syntax tree
Diagnostics you walk over these guys

sweet all right

sweet all right
so far so good no let's run this guy now

so far so good no let's run this guy now

so far so good no let's run this guy now
we say 1 1 we get unexpected token

we say 1 1 we get unexpected token

we say 1 1 we get unexpected token
number token expected end of our token

number token expected end of our token

number token expected end of our token
so those things seem to work quite

so those things seem to work quite

so those things seem to work quite
nicely actually

nice all right now let's think about

nice all right now let's think about
priorities for a second so if you do

priorities for a second so if you do

priorities for a second so if you do
this that is ok actually know before we

this that is ok actually know before we

this that is ok actually know before we
do that let's actually evaluate let's do

do that let's actually evaluate let's do

do that let's actually evaluate let's do
that first so how will be how about we

that first so how will be how about we

that first so how will be how about we
use this output now to actually compute

use this output now to actually compute

use this output now to actually compute
a number right that's probably the maybe

a number right that's probably the maybe

a number right that's probably the maybe
not doing this just for the for the

not doing this just for the for the

not doing this just for the for the
giggles here you actually want to do

giggles here you actually want to do

giggles here you actually want to do
something with the end result so let's

something with the end result so let's

something with the end result so let's
call this an evaluate or let's say and

call this an evaluate or let's say and

call this an evaluate or let's say and
let's say we give this guy

Jesus Christ we give this let's say the

Jesus Christ we give this let's say the
root object root and then we have public

root object root and then we have public

root object root and then we have public
and evaluate and then we just say this

and evaluate and then we just say this

and evaluate and then we just say this
is return evaluate expression with this

is return evaluate expression with this

is return evaluate expression with this
root

all right how does this work well we

all right how does this work well we
have basically what kind of expressions

have basically what kind of expressions

have basically what kind of expressions
do we have we have a binary expression

do we have we have a binary expression

do we have we have a binary expression
right now and we have a number

right now and we have a number

right now and we have a number
expression right now it's the only two

expression right now it's the only two

expression right now it's the only two
things we have so let's do this

things we have so let's do this

things we have so let's do this
let's say if root is number expression

let's say if root is number expression

let's say if root is number expression
and then the result is the number token

and then the result is the number token

and then the result is the number token
and the value so now that is the problem

and the value so now that is the problem

and the value so now that is the problem
because we said earlier and the parser

because we said earlier and the parser

because we said earlier and the parser
that we may not actually have a value

that we may not actually have a value

that we may not actually have a value
right because we didn't actually

right because we didn't actually

right because we didn't actually
validate that so let me actually go back

validate that so let me actually go back

validate that so let me actually go back
to the lexer really quick remember when

to the lexer really quick remember when

to the lexer really quick remember when
we parse this guy here and we said where

we parse this guy here and we said where

we parse this guy here and we said where
is it here we said oh we don't know

is it here we said oh we don't know

is it here we said oh we don't know
what's going on well this is the moment

what's going on well this is the moment

what's going on well this is the moment
where you want to make sure that you

where you want to make sure that you

where you want to make sure that you
report an error so you would say if not

report an error so you would say if not

report an error so you would say if not
then we would report an error here that

then we would report an error here that

then we would report an error here that
says Diagnostics and the number

cannot be represented by and in 32 all

cannot be represented by and in 32 all
right because we know it's only numbers

right because we know it's only numbers

right because we know it's only numbers
for now right I choose this day isn't

for now right I choose this day isn't

for now right I choose this day isn't
valid in 32 good enough because now we

valid in 32 good enough because now we

valid in 32 good enough because now we
can say you can only call evaluate if

can say you can only call evaluate if

can say you can only call evaluate if
you don't have any arrows otherwise it's

you don't have any arrows otherwise it's

you don't have any arrows otherwise it's
illegal to call this method which

illegal to call this method which

illegal to call this method which
simplifies your error handling quite a

simplifies your error handling quite a

simplifies your error handling quite a
bit all right now we can say if root is

bit all right now we can say if root is

bit all right now we can say if root is
binary expression syntax B well we can

binary expression syntax B well we can

binary expression syntax B well we can
say var left equals evaluate expression

say var left equals evaluate expression

say var left equals evaluate expression
for B dot left do the same thing for

for B dot left do the same thing for

for B dot left do the same thing for
right right

and then we say well if P dot operator

and then we say well if P dot operator
token kind equals syntax kind plus token

token kind equals syntax kind plus token

token kind equals syntax kind plus token
then we say return left + right

bum-bum-bum gonna say this is the elsif

bum-bum-bum gonna say this is the elsif
out of out serve else throw new

out of out serve else throw new

out of out serve else throw new
exception unexpected binary operator

that will be B operator token kind right

that will be B operator token kind right
because that shouldn't happen right so

because that shouldn't happen right so

because that shouldn't happen right so
we have + right - right star would be

multiplication and then this would be

multiplication and then this would be
division and say whether it's slash

division and say whether it's slash

division and say whether it's slash
talking yeah and then same thing here we

talking yeah and then same thing here we

talking yeah and then same thing here we
would say it warned you

would say it warned you

would say it warned you
unexpected note

let's call this you know all right so

let's call this you know all right so
this one should give us something to

this one should give us something to

this one should give us something to
work with inter Denton if you have any

work with inter Denton if you have any

work with inter Denton if you have any
Diagnostics and we report them otherwise

Diagnostics and we report them otherwise

Diagnostics and we report them otherwise
we will for our syntax tree expression

we will for our syntax tree expression

we will for our syntax tree expression
no root I think it's gone yeah and then

no root I think it's gone yeah and then

no root I think it's gone yeah and then
we save our result equals evaluate and

we save our result equals evaluate and

we save our result equals evaluate and
then we say console dot write line is

then we say console dot write line is

then we say console dot write line is
that can invert if super nice because

that can invert if super nice because

that can invert if super nice because
that makes a little bit easier to read

let's try what happens

let's try what happens
one plus two is three two times three

one plus two is three two times three

one plus two is three two times three
well actually we don't parse that yet

well actually we don't parse that yet

well actually we don't parse that yet
okay two plus three minus one it's four

okay two plus three minus one it's four

okay two plus three minus one it's four
seems right and if we say really really

seems right and if we say really really

seems right and if we say really really
really really large number then we get

really really large number then we get

really really large number then we get
it's not a valid int alright so this way

it's not a valid int alright so this way

it's not a valid int alright so this way
we actually have some decent error

we actually have some decent error

we actually have some decent error
handling and we actually evaluate stuff

handling and we actually evaluate stuff

handling and we actually evaluate stuff
now let's actually go down to our parser

now let's actually go down to our parser

now let's actually go down to our parser
and try to handle multiplication because

and try to handle multiplication because

and try to handle multiplication because
how hard can it be right

how hard can it be right

how hard can it be right
we already handle plus and minus so all

we already handle plus and minus so all

we already handle plus and minus so all
we have to do here

are these guys right I would say what

are these guys right I would say what
does that start token and then / token

does that start token and then / token

does that start token and then / token
right now let's say 2 times 3 6 all

right now let's say 2 times 3 6 all

right now let's say 2 times 3 6 all
right it seems good 6 divided by 2 is 3

right it seems good 6 divided by 2 is 3

right it seems good 6 divided by 2 is 3
well 1 plus 2 times 3 it's not 9 so the

well 1 plus 2 times 3 it's not 9 so the

well 1 plus 2 times 3 it's not 9 so the
reason this is saying 9 is because the

reason this is saying 9 is because the

reason this is saying 9 is because the
parse tree it does not actually honor

parse tree it does not actually honor

parse tree it does not actually honor
our normal priority rules right normally

our normal priority rules right normally

our normal priority rules right normally
you would say 2 plus 3 binds stronger

you would say 2 plus 3 binds stronger

you would say 2 plus 3 binds stronger
then this one here but right now because

then this one here but right now because

then this one here but right now because
the way it's being parsed is we first

the way it's being parsed is we first

the way it's being parsed is we first
parse 1 plus 2 and then we just say plus

parse 1 plus 2 and then we just say plus

parse 1 plus 2 and then we just say plus
2 times 3 so we first evaluate 1 plus 2

2 times 3 so we first evaluate 1 plus 2

2 times 3 so we first evaluate 1 plus 2
which is 3 and then we say times 3 which

which is 3 and then we say times 3 which

which is 3 and then we say times 3 which
is 9 but that's not the correct way to

is 9 but that's not the correct way to

is 9 but that's not the correct way to
do the math so we have to parse this

do the math so we have to parse this

do the math so we have to parse this
differently so the way we handle that is

differently so the way we handle that is

differently so the way we handle that is
by just changing the way the parser is

by just changing the way the parser is

by just changing the way the parser is
organized so if you think about the

organized so if you think about the

organized so if you think about the
parser for a second right so this is a

parser for a second right so this is a

parser for a second right so this is a
what's called a recursive descent parser

what's called a recursive descent parser

what's called a recursive descent parser
because basically what you do is you

because basically what you do is you

because basically what you do is you
call these methods recursively right and

call these methods recursively right and

call these methods recursively right and
so this is how you get the tree

so this is how you get the tree

so this is how you get the tree
structure going

structure going

structure going
I know marques I'm not having really

I know marques I'm not having really

I know marques I'm not having really
recursion right now because I just have

recursion right now because I just have

recursion right now because I just have
a primitive while loop so let's actually

a primitive while loop so let's actually

a primitive while loop so let's actually
do a recursive part here so the trick is

do a recursive part here so the trick is

do a recursive part here so the trick is
you just split these guys into two and

you just split these guys into two and

you just split these guys into two and
then this is what people call parse more

then this is what people call parse more

then this is what people call parse more
to multiplicative expression let's say I

to multiplicative expression let's say I

to multiplicative expression let's say I
think the correct term for that is parts

think the correct term for that is parts

think the correct term for that is parts
factor which is basic to say you know

factor which is basic to say you know

factor which is basic to say you know
the things that are stronger together

the things that are stronger together

the things that are stronger together
let me say parse factor as the primary

let me say parse factor as the primary

let me say parse factor as the primary
expression times was divided by another

expression times was divided by another

expression times was divided by another
primary expression and let me say this

primary expression and let me say this

primary expression and let me say this
is a this is a we call this parse Terim

is a this is a we call this parse Terim

is a this is a we call this parse Terim
I believe it was the usual term and

I believe it was the usual term and

I believe it was the usual term and
internet that they use where we say this

internet that they use where we say this

internet that they use where we say this
is a bunch of factors that are strung

is a bunch of factors that are strung

is a bunch of factors that are strung
together and then this guy only handles

together and then this guy only handles

together and then this guy only handles
these guys so let's see whether this

these guys so let's see whether this

these guys so let's see whether this
actually solves our opponent well first

actually solves our opponent well first

actually solves our opponent well first
it would help if it compiles so we now

it would help if it compiles so we now

it would help if it compiles so we now
say 1 plus 2 times 3 now I get 7 and now

say 1 plus 2 times 3 now I get 7 and now

say 1 plus 2 times 3 now I get 7 and now
I get a different press 3 right so now

I get a different press 3 right so now

I get a different press 3 right so now
what ends up happening is we say 1 plus

what ends up happening is we say 1 plus

what ends up happening is we say 1 plus
and then the operand 4 plus is another

and then the operand 4 plus is another

and then the operand 4 plus is another
expression which is now our our factor

expression which is now our our factor

expression which is now our our factor
effectively that represents the result

effectively that represents the result

effectively that represents the result
of the computation so now we actually

of the computation so now we actually

of the computation so now we actually
have the correct priorities in our in

have the correct priorities in our in

have the correct priorities in our in
our evaluator so let's do one more thing

our evaluator so let's do one more thing

our evaluator so let's do one more thing
because right now what annoys me a bit

yeah I guess doesn't matter um so we

yeah I guess doesn't matter um so we
have that now the other thing that we

have that now the other thing that we

have that now the other thing that we
want to do probably is support

want to do probably is support

want to do probably is support
parenthesized expressions so let me

parenthesized expressions so let me

parenthesized expressions so let me
actually add another note for that so

actually add another note for that so

actually add another note for that so
what would that look like so we have a

what would that look like so we have a

what would that look like so we have a
sealed clasp parenthesized expression

sealed clasp parenthesized expression

sealed clasp parenthesized expression
syntax which is an expression syntax

there's no way I typed it correctly

there's no way I typed it correctly
prevent this I get look looks good

prevent this I get look looks good

prevent this I get look looks good
I'm syntax token so what do we have

I'm syntax token so what do we have

I'm syntax token so what do we have
syntax token we say open parenthesis

syntax token we say open parenthesis

syntax token we say open parenthesis
token then we say we have the expression

token then we say we have the expression

token then we say we have the expression
syntax which is the expression and then

syntax which is the expression and then

syntax which is the expression and then
we have another syntax token which is

we have another syntax token which is

we have another syntax token which is
the closed parenthesis token and then I

the closed parenthesis token and then I

the closed parenthesis token and then I
just store them in properties we have to

just store them in properties we have to

just store them in properties we have to
override a certain thing so we say this

override a certain thing so we say this

override a certain thing so we say this
is some kind X what do we say

is some kind X what do we say

is some kind X what do we say
parenthesized you know what I copy that

this guy here generate the you November

this guy here generate the you November
and then we say what do we do we say

and then we say what do we do we say

and then we say what do we do we say
yield return open parentheses token

yield return open parentheses token

yield return open parentheses token
closed parentheses token and there is

closed parentheses token and there is

closed parentheses token and there is
any yield return an expression in the

any yield return an expression in the

any yield return an expression in the
middle alright so this is our thing you

middle alright so this is our thing you

middle alright so this is our thing you
know we only have to parse it so the way

know we only have to parse it so the way

know we only have to parse it so the way
we would parse this is at the very very

we would parse this is at the very very

we would parse this is at the very very
bottom part why driven right now say

bottom part why driven right now say

bottom part why driven right now say
primary expression we now have two kinds

primary expression we now have two kinds

primary expression we now have two kinds
that we can expect we can say if current

that we can expect we can say if current

that we can expect we can say if current
kind equals send kind left sorry open

kind equals send kind left sorry open

kind equals send kind left sorry open
parentheses token then I would say var

parentheses token then I would say var

parentheses token then I would say var
left equals next token then I save our

left equals next token then I save our

left equals next token then I save our
expression equals parse this is one of

expression equals parse this is one of

expression equals parse this is one of
those things where you want to have

those things where you want to have

those things where you want to have
helper method so you don't have to

helper method so you don't have to

helper method so you don't have to
understand the structure of your stuff

understand the structure of your stuff

understand the structure of your stuff
so what we would do is it would just

so what we would do is it would just

so what we would do is it would just
have a private message private

have a private message private

have a private message private
expression subjects parse expression and

expression subjects parse expression and

expression subjects parse expression and
that just says return parse turn so you

that just says return parse turn so you

that just says return parse turn so you
have sensible names you don't have to

have sensible names you don't have to

have sensible names you don't have to
remember this thread the structure and

remember this thread the structure and

remember this thread the structure and
we can say this is part expression and

we can say this is part expression and

we can say this is part expression and
then I can say bar write is match for

then I can say bar write is match for

then I can say bar write is match for
syntax kind close parenthesis children

syntax kind close parenthesis children

syntax kind close parenthesis children
let me say we return a new parenthesis

let me say we return a new parenthesis

let me say we return a new parenthesis
this sized expression which is left

this sized expression which is left

this sized expression which is left
expression and write does that own it

expression and write does that own it

expression and write does that own it
let's find out so now let's say we do 1

let's find out so now let's say we do 1

let's find out so now let's say we do 1
plus 2 times 3 right and I think I

plus 2 times 3 right and I think I

plus 2 times 3 right and I think I
crashed

so let's attach a debugger 1 plus 2

so let's attach a debugger 1 plus 2
times 3 oh I know what the problem is

times 3 oh I know what the problem is

times 3 oh I know what the problem is
look it's disk right here so we haven't

look it's disk right here so we haven't

look it's disk right here so we haven't
handled our note in the evaluator so if

handled our note in the evaluator so if

handled our note in the evaluator so if
note is parenthesized expression syntax

note is parenthesized expression syntax

note is parenthesized expression syntax
p in that case it is just return

p in that case it is just return

p in that case it is just return
evaluate expression for p dot expression

evaluate expression for p dot expression

evaluate expression for p dot expression
right because parenthesized expressions

right because parenthesized expressions

right because parenthesized expressions
are just you just evaluate the child of

are just you just evaluate the child of

are just you just evaluate the child of
it so now let's do this again 1 plus 2

it so now let's do this again 1 plus 2

it so now let's do this again 1 plus 2
times 3 and it's 9 because yes we first

times 3 and it's 9 because yes we first

times 3 and it's 9 because yes we first
do this which is 3 and then times 3 and

do this which is 3 and then times 3 and

do this which is 3 and then times 3 and
so we have the proper note structure

so we have the proper note structure

so we have the proper note structure
here so what I also want to show here

here so what I also want to show here

here so what I also want to show here
right now is if I say 1 plus 2 and I

right now is if I say 1 plus 2 and I

right now is if I say 1 plus 2 and I
don't provide a closing parenthesis we

don't provide a closing parenthesis we

don't provide a closing parenthesis we
manufactured one here right so that's a

manufactured one here right so that's a

manufactured one here right so that's a
closed parenthesis token here that we

closed parenthesis token here that we

closed parenthesis token here that we
edited the tree so what's nice is that

edited the tree so what's nice is that

edited the tree so what's nice is that
when you when you process your trees you

when you when you process your trees you

when you when you process your trees you
don't have to deal with my reference

don't have to deal with my reference

don't have to deal with my reference
exceptions for for parts of the tree

exceptions for for parts of the tree

exceptions for for parts of the tree
that you that you just don't have right

that you that you just don't have right

that you that you just don't have right
so the the idea there is that you just

so the the idea there is that you just

so the the idea there is that you just
have synthesized tokens for that and you

have synthesized tokens for that and you

have synthesized tokens for that and you
just rely on the fact that you have

just rely on the fact that you have

just rely on the fact that you have
reported errors for those and then this

reported errors for those and then this

reported errors for those and then this
way things tend to work much better now

way things tend to work much better now

way things tend to work much better now
the downside of inserting tokens is that

the downside of inserting tokens is that

the downside of inserting tokens is that
you have to be careful how you structure

you have to be careful how you structure

you have to be careful how you structure
the parser because when you insert

the parser because when you insert

the parser because when you insert
tokens you might end up in loop

tokens you might end up in loop

tokens you might end up in loop
situations where you keep inserting

situations where you keep inserting

situations where you keep inserting
tokens and keep inserting tokens and you

tokens and keep inserting tokens and you

tokens and keep inserting tokens and you
never

never

never
you need to be very careful that you

you need to be very careful that you

you need to be very careful that you
ride your purse on such a way you always

ride your purse on such a way you always

ride your purse on such a way you always
consume tokens so that eventually you

consume tokens so that eventually you

consume tokens so that eventually you
will hit the end of file to open and

will hit the end of file to open and

will hit the end of file to open and
your parser terminates otherwise you

your parser terminates otherwise you

your parser terminates otherwise you
will create a lot of memory and nothing

will create a lot of memory and nothing

will create a lot of memory and nothing
happens all right so this one I think so

happens all right so this one I think so

happens all right so this one I think so
far so good

far so good

far so good
the one thing I would like to add in our

the one thing I would like to add in our

the one thing I would like to add in our
repple just forget shits and giggles is

yeah make the make the API is a little

yeah make the make the API is a little
bit nicer so for example we don't really

bit nicer so for example we don't really

bit nicer so for example we don't really
want to deal with the lexer and the

want to deal with the lexer and the

want to deal with the lexer and the
parser anyway realistically because what

parser anyway realistically because what

parser anyway realistically because what
we operate on is the syntax tree right

we operate on is the syntax tree right

we operate on is the syntax tree right
so what we can do is we can just have a

so what we can do is we can just have a

so what we can do is we can just have a
message here public static syntax tree

message here public static syntax tree

message here public static syntax tree
parse and we can just say give a text

parse and we can just say give a text

parse and we can just say give a text
and then we can just do our parser

and then we can just do our parser

and then we can just do our parser
equals new parser for the text and then

equals new parser for the text and then

equals new parser for the text and then
we can say return parser thought parse

we can say return parser thought parse

we can say return parser thought parse
and it makes the api's I don't know not

and it makes the api's I don't know not

and it makes the api's I don't know not
a whole lot cooler but I know I like

a whole lot cooler but I know I like

a whole lot cooler but I know I like
this one a lot more than having to deal

this one a lot more than having to deal

this one a lot more than having to deal
with the parser it also beats slightly

with the parser it also beats slightly

with the parser it also beats slightly
more logical subjects tree dot parse you

more logical subjects tree dot parse you

more logical subjects tree dot parse you
get back a subjects tree right seems

get back a subjects tree right seems

get back a subjects tree right seems
reasonable yeah so the done thing I

reasonable yeah so the done thing I

reasonable yeah so the done thing I
would like to add here is some pseudo

would like to add here is some pseudo

would like to add here is some pseudo
commands so we could say if line equals

so tree first of all we say continue

so tree first of all we say continue
more importantly let's have aesthetic

more importantly let's have aesthetic

more importantly let's have aesthetic
here actually doesn't have to be static

here actually doesn't have to be static

here actually doesn't have to be static
volume bull show tree falls I'd say and

volume bull show tree falls I'd say and

volume bull show tree falls I'd say and
then we can say show tree equals not

then we can say show tree equals not

then we can say show tree equals not
show tree and then we can say console

show tree and then we can say console

show tree and then we can say console
dot write line show tree showing parse

dot write line show tree showing parse

dot write line show tree showing parse
trees

otherwise not showing past phrase

otherwise not showing past phrase
so this way everyone our thing it looks

so this way everyone our thing it looks

so this way everyone our thing it looks
a little bit cleaner oh yeah it helps if

a little bit cleaner oh yeah it helps if

a little bit cleaner oh yeah it helps if
we actually handle that thing - where's

we actually handle that thing - where's

we actually handle that thing - where's
the pretty print here if show tree do

the pretty print here if show tree do

the pretty print here if show tree do
that otherwise don't do that I guess you

that otherwise don't do that I guess you

that otherwise don't do that I guess you
need to do that here now as well

you can sell one close to you get a

you can sell one close to you get a
result I can say show T samples - I get

result I can say show T samples - I get

result I can say show T samples - I get
the treat so this way we have some

the treat so this way we have some

the treat so this way we have some
diagnostic information without without

diagnostic information without without

diagnostic information without without
anything and then I think the other one

anything and then I think the other one

anything and then I think the other one
that I probably want out of line equals

that I probably want out of line equals

that I probably want out of line equals
CLS they say console dot clear

have a little bit nicer as far as the

have a little bit nicer as far as the
console is concerned

console is concerned

console is concerned
alright so I think we now have at least

alright so I think we now have at least

alright so I think we now have at least
a ripple that kind of sort of works for

a ripple that kind of sort of works for

a ripple that kind of sort of works for
us now let's quickly look at the project

us now let's quickly look at the project

us now let's quickly look at the project
structure that you have so far because

structure that you have so far because

structure that you have so far because
right now everything is in one giant

right now everything is in one giant

right now everything is in one giant
file which I know some people prefer

file which I know some people prefer

file which I know some people prefer
everything in one giant file I am NOT

everything in one giant file I am NOT

everything in one giant file I am NOT
one of those people because it makes

one of those people because it makes

one of those people because it makes
version control pretty ugly first thing

version control pretty ugly first thing

version control pretty ugly first thing
is the texture we name our namespace

is the texture we name our namespace

is the texture we name our namespace
here into Minsk let me create a folder

here into Minsk let me create a folder

here into Minsk let me create a folder
here which I will call code analysis and

here which I will call code analysis and

here which I will call code analysis and
yes if you have ever used was nine there

yes if you have ever used was nine there

yes if you have ever used was nine there
wasn't a P is the ones that are just

wasn't a P is the ones that are just

wasn't a P is the ones that are just
produced will look very familiar

produced will look very familiar

produced will look very familiar
let's just say so let me just add a new

let's just say so let me just add a new

let's just say so let me just add a new
file here stuff dot CS and let me take

file here stuff dot CS and let me take

file here stuff dot CS and let me take
everything we just built and put it into

everything we just built and put it into

everything we just built and put it into
an in space min starts code analysis and

an in space min starts code analysis and

an in space min starts code analysis and
put the stuff in here now of course we

put the stuff in here now of course we

put the stuff in here now of course we
need a ton of usings

and now I can just move these guys to

and now I can just move these guys to
separate files so let's just go this one

separate files so let's just go this one

separate files so let's just go this one
to this file to type move type type type

actually let me do a save all for now

actually let me do a save all for now
because I cannot deal with that many

because I cannot deal with that many

because I cannot deal with that many
open windows all right let's keep doing

open windows all right let's keep doing

open windows all right let's keep doing
overtime type move type I know this is

overtime type move type I know this is

overtime type move type I know this is
last one so let's just rename the file

all right then I guess here we can just

all right then I guess here we can just
take the delete hmm

take the delete hmm

take the delete hmm
what we select everything again that

what we select everything again that

what we select everything again that
also works don't wanna try to using for

also works don't wanna try to using for

also works don't wanna try to using for
code analysis and booyah now we have

code analysis and booyah now we have

code analysis and booyah now we have
just our pretty print and the repple in

just our pretty print and the repple in

just our pretty print and the repple in
here and everything else is neatly

here and everything else is neatly

here and everything else is neatly
distributed in a bunch of smaller files

I'd say I'm at this point so far quite

I'd say I'm at this point so far quite
happy with the result now let me

happy with the result now let me

happy with the result now let me
actually because I haven't done this in

actually because I haven't done this in

actually because I haven't done this in
a while look over the questions that

a while look over the questions that

a while look over the questions that
I've gone what do we have

so both of the questions were related to

so both of the questions were related to
what language are we using it very

what language are we using it very

what language are we using it very
answered yeah so some person asked why

answered yeah so some person asked why

answered yeah so some person asked why
do we duplicate the note information in

do we duplicate the note information in

do we duplicate the note information in
an enum and the class hierarchy so right

an enum and the class hierarchy so right

an enum and the class hierarchy so right
now what I what I have done here is I

now what I what I have done here is I

now what I what I have done here is I
have cheated a lot right I've done a lot

have cheated a lot right I've done a lot

have cheated a lot right I've done a lot
of instance checking so if you look at

of instance checking so if you look at

of instance checking so if you look at
the evaluator for example we just

the evaluator for example we just

the evaluator for example we just
quickly see where that guy is now here

quickly see where that guy is now here

quickly see where that guy is now here
we just do this Rd basically just say

we just do this Rd basically just say

we just do this Rd basically just say
you know if this if this instance is

you know if this if this instance is

you know if this if this instance is
this instance here and now with the new

this instance here and now with the new

this instance here and now with the new
c-sharp pattern matching is actually

c-sharp pattern matching is actually

c-sharp pattern matching is actually
pretty concise you can just do that but

pretty concise you can just do that but

pretty concise you can just do that but
for the most part you really want is you

for the most part you really want is you

for the most part you really want is you
want a switch statement because that is

want a switch statement because that is

want a switch statement because that is
just much more efficient especially when

just much more efficient especially when

just much more efficient especially when
you walk larger trees these things are

you walk larger trees these things are

you walk larger trees these things are
much much cheaper because what you do is

much much cheaper because what you do is

much much cheaper because what you do is
you basically ask the instance give me

you basically ask the instance give me

you basically ask the instance give me
an int which is you know the enum value

an int which is you know the enum value

an int which is you know the enum value
and then the switch statement is just a

and then the switch statement is just a

and then the switch statement is just a
jump table that directly dispatches to

jump table that directly dispatches to

jump table that directly dispatches to
the to the block and then you have of

the to the block and then you have of

the to the block and then you have of
course the cost still occurring in that

course the cost still occurring in that

course the cost still occurring in that
in their block but you only have one

in their block but you only have one

in their block but you only have one
cost as opposed to you try this one no

cost as opposed to you try this one no

cost as opposed to you try this one no
you try this one nope you try this one

you try this one nope you try this one

you try this one nope you try this one
nopes we do a plenty of costs before you

nopes we do a plenty of costs before you

nopes we do a plenty of costs before you
actually find the object so instead of

actually find the object so instead of

actually find the object so instead of
doing this you just directly jump to the

doing this you just directly jump to the

doing this you just directly jump to the
corresponding code block for three or

corresponding code block for three or

corresponding code block for three or
four instances like we have here no

four instances like we have here no

four instances like we have here no
point but I wanted to set the pattern

point but I wanted to set the pattern

point but I wanted to set the pattern
already so that we don't have to

already so that we don't have to

already so that we don't have to
duplicate so much information later yep

duplicate so much information later yep

duplicate so much information later yep
somebody says you could do different no

somebody says you could do different no

somebody says you could do different no
colors for the output that's actually

colors for the output that's actually

colors for the output that's actually
good idea we should probably do that

any plan writing a new CLR that will be

any plan writing a new CLR that will be
a lot of work right he new CLR a new

a lot of work right he new CLR a new

a lot of work right he new CLR a new
language for the CLR might actually be

language for the CLR might actually be

language for the CLR might actually be
something in fact that's what we do here

something in fact that's what we do here

something in fact that's what we do here
might be compiled onto il and that's

might be compiled onto il and that's

might be compiled onto il and that's
basically new language yeah somebody

basically new language yeah somebody

basically new language yeah somebody
mentioned lob em I have tried LLVM

mentioned lob em I have tried LLVM

mentioned lob em I have tried LLVM
before I've not succeeded yet in getting

before I've not succeeded yet in getting

before I've not succeeded yet in getting
my back-end up and running on a VM but

my back-end up and running on a VM but

my back-end up and running on a VM but
it is something I would like to look

it is something I would like to look

it is something I would like to look
into because my language is you saw

into because my language is you saw

into because my language is you saw
doesn't really deal with object

doesn't really deal with object

doesn't really deal with object
allocations so it should be fairly

allocations so it should be fairly

allocations so it should be fairly
straightforward to to take the language

straightforward to to take the language

straightforward to to take the language
subset that I have and omit actually

subset that I have and omit actually

subset that I have and omit actually
native code for that might make the

native code for that might make the

native code for that might make the
debugging a lot harder though yeah so

debugging a lot harder though yeah so

debugging a lot harder though yeah so
somebody suggests maybe we should have

somebody suggests maybe we should have

somebody suggests maybe we should have
done commits for the individual items

done commits for the individual items

done commits for the individual items
that's a good idea I generally do that

that's a good idea I generally do that

that's a good idea I generally do that
but when I get carried away I'm not

but when I get carried away I'm not

but when I get carried away I'm not
doing this but generally just how I work

doing this but generally just how I work

doing this but generally just how I work
I would I would commit logical chunks

I would I would commit logical chunks

I would I would commit logical chunks
and we can do this right now actually if

and we can do this right now actually if

and we can do this right now actually if
we wanted to let me think about that for

we wanted to let me think about that for

we wanted to let me think about that for
a second is that easy probably not right

a second is that easy probably not right

a second is that easy probably not right
now because you already have

now because you already have

now because you already have
interdependencies everywhere but I would

interdependencies everywhere but I would

interdependencies everywhere but I would
say for our first episode um you know

say for our first episode um you know

say for our first episode um you know
it's not do that and that's do it the

it's not do that and that's do it the

it's not do that and that's do it the
right way to check out it's called as

right way to check out it's called as

right way to check out it's called as
episode 1

yeah I guess episode 1 lexer and parser

yeah I guess episode 1 lexer and parser
right just for good measure and then we

right just for good measure and then we

right just for good measure and then we
just say add these guys why don't we go

just say add these guys why don't we go

just say add these guys why don't we go
to what we were to commit I'm not sure I

to what we were to commit I'm not sure I

to what we were to commit I'm not sure I
want to commit deviance code once but

want to commit deviance code once but

want to commit deviance code once but
yeah it is what it is all right let's do

the tune so here's all the stuff we're

the tune so here's all the stuff we're
about to commit

yeah good enough alright add lexer and

yeah good enough alright add lexer and
parser this adds the basics maybe we

parser this adds the basics maybe we

parser this adds the basics maybe we
should say that expression evaluate or

should say that expression evaluate or

should say that expression evaluate or
evaluate or that's the basics we need

evaluate or that's the basics we need

evaluate or that's the basics we need
specifically lexer parser and

specifically lexer parser and

specifically lexer parser and
diagnostics mistakes diagnostics that

diagnostics mistakes diagnostics that

diagnostics mistakes diagnostics that
will lay the foundation for our compiler

I'd say good enough so I think for our

I'd say good enough so I think for our
first episode that is a pretty decent

first episode that is a pretty decent

first episode that is a pretty decent
start alright so yeah my my lights are

start alright so yeah my my lights are

start alright so yeah my my lights are
all fading so I look very interesting

all fading so I look very interesting

all fading so I look very interesting
probably very dark it's a very critical

probably very dark it's a very critical

probably very dark it's a very critical
thing here so I think the next episodes

thing here so I think the next episodes

thing here so I think the next episodes
will focus a little bit more on getting

will focus a little bit more on getting

will focus a little bit more on getting
more stuff from the language going maybe

more stuff from the language going maybe

more stuff from the language going maybe
some statements and then also we have to

some statements and then also we have to

some statements and then also we have to
think about how we and we want to run

think about how we and we want to run

think about how we and we want to run
this guy probably start first with an e

this guy probably start first with an e

this guy probably start first with an e
value of an interpreter because it's

value of an interpreter because it's

value of an interpreter because it's
much easier to do an interpreter than it

much easier to do an interpreter than it

much easier to do an interpreter than it
is to omit il and then we will walk our

is to omit il and then we will walk our

is to omit il and then we will walk our
way slowly up alright so this we are

way slowly up alright so this we are

way slowly up alright so this we are
pretty much in time I was hoping for 90

pretty much in time I was hoping for 90

pretty much in time I was hoping for 90
minutes we're now at 100 minutes but