#![allow(dead_code)]
#![allow(unused_assignments)]
#![allow(unused_variables)]

use std::rc::Rc;
use std::cell::RefCell;

type Q = Node;
type Flonum = f64;

#[derive(Clone)]
struct Cons {
    car :Node,
    cdr :Node }

#[derive(Clone)]
enum Node {
    Flonum (f64),
    Cons (Rc<RefCell<Cons>>) }

fn maknum (x :Flonum) -> Q {
    Node::Flonum(x) }

fn getnum (x :Q) -> Flonum {
    match x {
        Node::Flonum(x) => x,
        _ => panic! ("Not a number"), } }

fn cons (x :Q, y :Q) -> Q {
    Node::Cons (Rc::new(RefCell::new(Cons { car: x, cdr: y }))) }

fn car (x :Q) -> Q {
    match x {
        Node::Cons(x) => {
            let a = Rc::clone(&x);
            let b = a.borrow();
            b.car.clone() }
        _ => panic! ("Not a cons"), } }

fn cdr (x :Q) -> Q {
    match x {
        Node::Cons(x) => {
            let a = Rc::clone(&x);
            let b = a.borrow();
            b.cdr.clone() }
        _ => panic! ("Not a cons"), } }

fn rplaca (x :Q, y :Q) -> Q {
    match x.clone() {
        Node::Cons(x) => {
            let a = Rc::clone(&x);
            let mut b = a.borrow_mut();
            b.car = y }
        _ => panic! ("Not a cons"), };
    x }

fn rplacd (x :Q, y :Q) -> Q {
    match x.clone() {
        Node::Cons(x) => {
            let a = Rc::clone(&x);
            let mut b = a.borrow_mut();
            b.cdr = y }
        _ => panic! ("Not a cons"), };
    x }

fn main () {
    let f = maknum (42 as Flonum);
    let g = maknum (69 as Flonum);
    let a = cons (f.clone(), g.clone());
    let b = cons (a.clone(), f);
    let c = a.clone();
    println! ("a = ({} . {})", getnum(car(a.clone())), getnum(cdr(a.clone())));
    rplaca (a.clone(), g.clone());
    println! ("a = ({} . {})", getnum(car(a.clone())), getnum(cdr(a.clone())));
    println! ("c = ({} . {})", getnum(car(c.clone())), getnum(cdr(c.clone())));
}