yestercafe/emehcs

A Scheme-like language interpreter

Ivan Chien/Yestercafe - He/Him

Hi there, I am Ivan Chien. I like Rust and C++ and have used them to write some projects, you can find them below or on the repositories page.

I use NeoVim, VSCode, and Emacs. You can find out my configs:

• NeoVim
• Emacs
• dotfiles in which you can find more about, such as zsh or bash

I'd like to learn more about functional programming languages like Haskell and independent-type programming languages like Coq or Agda.

Recent Goals

• to finish Coffee OJ
• porting some major C++ projects to Rust

Interested in

• Rust & Go
• functional programming
• programming languages
• theorem proving

My Handworks

• Yestercafe/CoffeeOJ-judge(WIP): An online judge backend service written in Rust
• Yestercafe/CoffeeOJ(WIP): An online judge platform written in Golang
• Yestercafe/leetcode-solutions: My LeetCode solutions, C++/Python/Go/Rust/and so on, all in this repo!
• Yestercafe/Euphoria: A UE C++ documentation generator written in Rust
• Yestercafe/Emehcs(Archived): A Lisp-like language interpreter written in C++

emehcs's Issues

Environment closure variable hiding bug

Codes, Newton's method calc sqrt:

(define (abs n)
  (if (< n 0)
      (-0 n)
      n))

(define tolerance (/ 1 100000))
(define (fixed-point f first-guess)
  (define (close-enough? v1 v2)
    (< (abs (- v1 v2)) tolerance))
  (define (try guess)
    (let ((next (f guess)))
      (print f)
      (debug-get-function-env f)
      (print next)
      (if (close-enough? guess next)
          next
          (try next))))
  (try first-guess))

(define dx (/ 1 100000000))
(define (deriv g)
  (lambda (x)
    (/ (- (g (+ x dx)) (g x))
       dx)))

(define (newton-transform g)
  (lambda (x)
    (- x (/ (g x) ((deriv g) x2)))))

(define (newtons-method g guess)
  (fixed-point (newton-transform g) guess))

(define (sqrt x)
  (newtons-method (lambda (y) (- (* y y) x))
                  1))

(sqrt 2)

The result is:

>>> (define (abs n)
	  (if (< n 0)
	      (-0 n)
	      n))
=> (function (abs n) (if (< n 0) (-0 n) n))
>>> (define tolerance (/ 1 100000))
=> 1e-05
>>> (define (fixed-point f first-guess)
	  (define (close-enough? v1 v2)
	    (< (abs (- v1 v2)) tolerance))
	  (define (try guess)
	    (let ((next (f guess)))
	      (print f)
	      (debug-get-function-env f)
	      (print next)
	      (if (close-enough? guess next)
	          next
	          (try next))))
	  (try first-guess))
=> (function (fixed-point f first-guess) (define (close-enough? v1 v2) (< (abs (- v1 v2)) tolerance)) (define (try guess) (let ((next (f guess))) (print f) (debug-get-function-env f) (print next) (if (close-enough? guess next) next (try next)))) (try first-guess))
>>> (define dx (/ 1 100000000))
=> 1e-08
>>> (define (deriv g)
	  (lambda (x)
	    (/ (- (g (+ x dx)) (g x))
	       dx)))
=> (function (deriv g) (lambda (x) (/ (- (g (+ x dx)) (g x)) dx)))
>>> (define (newton-transform g)
	  (lambda (x)
	    (- x (/ (g x) ((deriv g) x)))))
=> (function (newton-transform g) (lambda (x) (- x (/ (g x) ((deriv g) x)))))
>>> (define (newtons-method g guess)
	  (fixed-point (newton-transform g) guess))
=> (function (newtons-method g guess) (fixed-point (newton-transform g) guess))
>>> (define (sqrt x)
	  (newtons-method (lambda (y) (- (* y y) x))
	                  1))
=> (function (sqrt x) (newtons-method (lambda (y) (- (* y y) x)) 1))
>>> (define kk (lambda (y) (- (* y y) 2)))
=> (function (lambda y) (- (* y y) 2))
>>> (sqrt 2)
(function (lambda x) (- x (/ (g x) ((function (lambda x) (/ (- (g (+ x dx)) (g x)) dx)) x))))
(g . (function (lambda y) (- (* y y) x)))
(guess . 1)
(g . (function (lambda y) (- (* y y) x)))
(x . 2)
(newton-transform . (function (newton-transform g) (lambda (x) (- x (/ (g x) ((function (lambda x) (/ (- (g (+ x dx)) (g x)) dx)) x))))))
(newtons-method . (function (newtons-method g guess) (fixed-point (newton-transform g) guess)))
(deriv . (function (deriv g) (lambda (x) (/ (- (g (+ x dx)) (g x)) dx))))
(dx . 1e-08)
(fixed-point . (function (fixed-point f first-guess) (define (close-enough? v1 v2) (< (abs (- v1 v2)) tolerance)) (define (try guess) (let ((next (f guess))) (print f) (debug-get-function-env f) (print next) (if (close-enough? guess next) next (try next)))) (try first-guess)))
(tolerance . 1e-05)
(sqrt . (function (sqrt x) (newtons-method (lambda (y) (- (* y y) x)) 1)))
(abs . (function (abs n) (if (< n 0) (-0 n) n)))
1
=> 1

But in f's closure env, the x should be 1, not 2. Fix it.

Y-combinator codes can't eval successfully

(define Y
  (lambda (fn)
    ((lambda (f)
       (f f)) (lambda (f)
                (fn (lambda (s) ((f f) s)))))))

((Y (lambda (g)
      (lambda (s)
        (cond
          ((eq? s '()) '())
          (#t
            (cons (string-upcase (car s)) (g (cdr s)))))))) '("a" "b" "c" "d" "e"))

eval and env codes may/would be rewritten.