// Example of Rust's ownership system
fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 is moved here
    
    // println!("{}, world!", s1);  // This would not compile
    println!("{}, world!", s2);  // This works
}

#lang racket

(require openscad)

(define (create-box width height depth)
  (cube width height depth))

(define (create-lid width depth)
  (translate [0 0 (/ depth 2)]
    (cube width 1 depth)))

(define (main)
  (union
   (create-box 10 5 3)
   (create-lid 10 3)))

(save-scad "box-with-lid.scad" (main))

#lang racket

(require adqc)

(define (normalize expr)
  (match expr
    [`(λ ,x ,body) `(λ ,x ,(normalize body))]
    [`(,f ,arg) (let ([f' (normalize f)]
                      [arg' (normalize arg)])
                  (if (and (lambda? f') (value? arg'))
                      (substitute (lambda-body f') (lambda-param f') arg')
                      `(,f' ,arg')))]
    [x x]))

(define expr '((λ x (x x)) (λ y y)))
(displayln (normalize expr))

(use-package racket-mode
  :ensure t
  :mode "\\.rkt\\'"
  :config
  (add-hook 'racket-mode-hook
            (lambda ()
              (define-key racket-mode-map (kbd "C-c r") 'racket-run)
              (define-key racket-mode-map (kbd "C-c t") 'racket-test))))

#lang racket
(require algebraic)

(define-algebra maybe
  [just : a -> (maybe a)]
  [nothing : (maybe a)])

(define (maybe-map f m)
  (match m
    [(just x) (just (f x))]
    [nothing nothing]))

(define m (just 5))
(displayln (maybe-map add1 m))  ; (just 6)
(displayln (maybe-map add1 nothing))  ; nothing

#lang wishful-thinking

(define (factorial n)
  (if (zero? n)
      1
      (* n (factorial (sub1 n)))))

(test-case "factorial works"
  (check-equal? (factorial 5) 120)
  (check-equal? (factorial 0) 1))

;; The language will automatically generate the implementation
;; based on the test cases and function signature

#lang racket
(require fructure)

(define-fructure-editor my-editor
  #:keymap
  '(("C-n" . fructure-next-sibling)
    ("C-p" . fructure-previous-sibling)
    ("C-f" . fructure-forward-char)
    ("C-b" . fructure-backward-char)
    ("C-e" . fructure-end-of-line)
    ("C-a" . fructure-beginning-of-line)))

(my-editor)

;; Example of simply-typed lambda calculus in Racket
(define-type Type
  [TInt]
  [TFun Type Type])

(define-type Expr
  [Var Symbol]
  [Lam Symbol Type Expr]
  [App Expr Expr])

(define (type-check expr env)
  (match expr
    [(Var x) (hash-ref env x)]
    [(Lam x t body)
     (TFun t (type-check body (hash-set env x t)))]
    [(App f arg)
     (match (type-check f env)
       [(TFun arg-t ret-t)
        #:when (equal? arg-t (type-check arg env))
        ret-t]
       [_ (error "Type mismatch in application")])]))

(run 99 (q) (evalo q '(I love you)))

;; Example of one of the seven problems: The Zebra Puzzle
(define (zebra)
  (run* (h)
    (fresh (e j s u n)
      (== h (list e j s u n))
      (!= e j) (!= e s) (!= e u) (!= e n)
      (!= j s) (!= j u) (!= j n)
      (!= s u) (!= s n)
      (!= u n)
      (membero '(norwegian . yellow) h)
      (membero '(ukrainian . blue) h)
      (righto '(norwegian . _) '(blue . _) h)
      (first '(norwegian . _) h)
      (nexto '(chesterfields . _) '(fox . _) h)
      (nexto '(kools . _) '(horse . _) h)
      (membero '(lucky-strike . orange-juice) h)
      (membero '(japanese . parliaments) h)
      (nexto '(norwegian . _) '(dunhill . _) h)
      (membero '(_ . milk) s)
      (membero '(_ . water) j)
      (membero '(_ . zebra) u))))