Skip to content
BranchesTags

Repository files navigation

Yet Another Really Rusty Lox

This software is not meant to be useful. It's merely for practice and learning.

But what is this?

This is a WIP implemetation of the Lox language described in the delightful light novel Crafting Interpreters. The lecture is highly recommended - it's a delectable romantic thriller, full of ups and down, relatable characters, and touching on universal human suffering with refreshing lightness.

Yes, the "really" wasn't really needed in the name. Ye better not complain lest ye be thrown ta th' sharks.

Progress

  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started

Running yarrlox

First of all, get Rust if you need to.

Run the REPL:

cargo run

Run a Lox program:

cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:

cargo install --path .

Differences from the Book

  • Binary operation precedence/associativity is handled with a precedence climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory management and garbage collection so that the reader doesn't have to think about those... yet. For my tree-walk interpreter, I decided to pass small values by value and put bigger ones (functions, strings) in ref-counted pointers. This probably has implications about cycles and all that jazz. It's probably not ideal without deeper thought, but it lets me get on with the book without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type uniquely identifiable. That's why the parser assigns a unique ID to every variable reference. Since those IDs are contiguous, our locals data collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this in integration tests since it's stupidly convenient.

Less-than-ideal stuff

I don't want to spend time fixing these in a toy language, but I want to note these.

  • If there are multiple resolution errors in source code, only the first one gets reported.
  • It feels like some code could be more functional and rely less on outside state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not in the global one. Feels like a confusing inconsistency.

License

Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.

About

Yet Another Really Rusty Lox

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - uint/yarrlox: Yet Another Really Rusty Lox · GitHub
Skip to content
BranchesTags
Repository files navigation
Yet Another Really Rusty Lox
This software is not meant to be useful. It's merely for practice and learning.
But what is this?
This is a WIP implemetation of the Lox language described in the delightful
light novel Crafting Interpreters. The
lecture is highly recommended - it's a delectable romantic thriller, full of ups
and down, relatable characters, and touching on universal human suffering with
refreshing lightness.
Yes, the "really" wasn't really needed in the name. Ye better not complain
lest ye be thrown ta th' sharks.
Progress
  • tree-walk interpreter: 11/13 chapters
  • bytecode VM: not started
Running yarrlox
First of all, get Rust if you need to.
Run the REPL:
cargo run

Run a Lox program:
cargo run -- scripts/fib.lox

Install it into your PATH if you like it a lot:
cargo install --path .

Differences from the Book
  • Binary operation precedence/associativity is handled with a precedence
climbing algorithm.
  • The original jlox implementation seems to cleverly exploit Java's memory
management and garbage collection so that the reader doesn't have to think
about those... yet. For my tree-walk interpreter, I decided to pass small
values by value and put bigger ones (functions, strings) in ref-counted
pointers. This probably has implications about cycles and all that jazz. It's
probably not ideal without deeper thought, but it lets me get on with the book
without spending too much time here.
  • In Rust, there's no built-in mechanism for making every instance of a type
uniquely identifiable. That's why the parser assigns a unique ID to every
variable reference. Since those IDs are contiguous, our locals data
collected by the resolver doesn't need to be a hashmap. It's a Vec instead.
  • No visitor pattern in the tree-walk interpreter. I couldn't find enough
justification for doing that and opted for enums and pattern-matching instead.
  • Returning from the top level is not treated as an error. I started using this
in integration tests since it's stupidly convenient.
Less-than-ideal stuff
I don't want to spend time fixing these in a toy language, but I want to note
these.
  • If there are multiple resolution errors in source code, only the first one
gets reported.
  • It feels like some code could be more functional and rely less on outside
state (struct methods mostly).
  • Declaring the same name multiple times is an error in a local scope, but not
in the global one. Feels like a confusing inconsistency.
License
Dual licensed under MIT and Apache 2.0 at your option, like most Rust project.
About
Yet Another Really Rusty Lox
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages