function getCountry(student) {
    const school = student.getSchool();
    if (school !== null) {
        const addr = school.getAddress();
        if (addr !== null) {
            let country = addr.getCountry();
            return country;
        }
        return null;
    }
    throw new Error('Error extracting coutry info');
}

class Wrapper {
    constructor(value) {
        this._value = value;
    },
    // map :: (a -> b) -> Wrapper a -> b
    map(f) {
        return f(this._value);
    },
    // fmap :: (a -> b) -> Wrapper a -> Wrapper b
    fmap(f) {
        return new Wrapper(f(this._value));
    },
    toString() {
        return 'Wrapper (' + this._value + ')';
    }
}

const wrap = val => new Wrapper(val);

Functor f => fmap :: (a -> b) -> f a -> f b

map :: (a -> b) -> Array a -> Array b

[1, 2, 3].map(x => x ** 2);

// findStudent :: DB -> String -> Wrapper Student
const findStudent = R.curry(function(db, ssn) {
    return wrap(find(db, ssn));
});


// getAddress :: Wrapper Student -> Wrapper Wrapper String
const getAddress = 
    student => wrap(student.fmap(R.prop('address')));
    // student.fmap(R.prop('address')) の時点で Wrapper Stringに評価される
    // それをさらにwrapしているので Wrapper Wrapper String
    

// studentAddress -> Wrapper Wrapper String
const studentAddress = R.compose(
    getAddress,
    findStudent(db('student'))
);

$('#student-info').fadeIn(3000).text(student.fullname());

// 空のコンテナ
// 「値がない」場合を安全に取り扱う
class Empty {
    // map :: (a -> b) -> Wrapper a -> b
    map(f) {
        // 書籍ではこうなっている。これはおかしいでしょう(型が合わない)
        // return this;

        // Identityを作用させてnullが返るのが正しい？
        return null;
        
        // まあこの後消える関数なのであまり深く考えなくてもいい
    },
    // fmap :: (a -> b) -> Wrapper a -> Wrapper b
    fmap (_) {
        return new Empty();    // 関数を作用させても何もしない
    },
    toString () {
        return 'Empty()';
    },
}

const empty = () => new Empty();

// isEven :: Number -> Boolean
const isEven = n => n % 2 == 0;

// half :: Number -> (Wrap Number) | Empty
const half = val => isEven(val) ? wrap(val / 2) : empty();


half(4); // -> Wrapper(2)
half(3); // -> Empty()
         //    不正な入力値(3)について、エラー値としてEmptyコンテナを返す

half(4).fmap(increment); // -> Wrapper(3)
half(3).fmap(increment); // -> Empty()
                         //    不正な入力値(3)についても関数をマッピングする方法を知っている
                         //    (単になにもしない)

class Wrapper {
    constructor(value) {
        this._value = value;
    },

    // of :: a -> Wrapper a
    static of(a) {
        return new Wrapper(a);
    },
    
    // map :: (a -> b) -> Wrapper a -> Wrapper b
    // fmapと呼んでいたやつ
    // 以後、単にmapとする
    map(f) {
        return Wrapper.of(f(this._value));
    },
    
    // join :: Wrapper Wrapper ... a -> Wrapper a
    // ↑正式にはどう書くんだろ
    // 1層は残す
    join() {
        if(!(this._value instanceof Wrapper)) {
            return this;
        }
        
        // recursion
        return this._value.join();
    }
    
    // get :: Wrapper a -> a
    get() {
        return this._value;
        // Emptyならnullを返すのかな
    }
    
    toString() {
        return 'Wrapper (' + this._value.toString() + ')';
    }
}

function decode(uri) {
    try {
        const result = decodeURIComponent(url);  // throws URIError
        return Eigher.of(result);
    }
    catch(uriError) {
        return Either.left(uriError);    // 例外オブジェクトをLeftで包む
    }
}

<div id="student-name">alonzo church</div>

const changeToStartCase =
    IO.from(readDom('#student-name'))
    .map(_.startCase)
    .map(writeDom('#student-name'));

<div id="student-name">alonzo church</div>

changeToStartCase.run();

// readDom('#student-name')以降の処理が順に実行される

<div id="student-name">Alonzo Church</div>

const showStudent = (ssn) =>
    Maybe.fromNullable(ssn)
        .map(cleanInput)
        .chain(checkLengthSsn)
        .map(R.tap(trace('Input was valid')))
        .chain(findStudent)
        .map(R.tap(trace('Record fetched successfully!')))
        .map(R.props(['ssn', 'firstname', 'lastname']))
        .map(csv)
        .map(R.tap(trace('Student info converted to CSV')))
        .map(append('#student-info'))
        .map(R.tap(trace('Student added to HTML page')));

// Functor f => (a -> b) -> F a -> F b
const map = R.curry((f, container) => container.map(f));
// Monad m => (a -> M b) -> M a -> M b
const chain = R.curry((f, container) => container.chain(f));

const showStudent = R.compose(
    R.tap(trace('Student added to HTML page')),
    map(append('#student-info')),
    R.tap(trace('Student info converted to CSV')),
    map(csv),
    map(R.props(['ssn', 'firstname', 'lastname'])),
    R.tap(trace('Record fetched successfully!')),
    chain(findStudent),
    R.tap(trace('Input was valid')),
    chain(checkLengthSsn),
    lift(cleanInput)
);

const showStudent = R.compose(
    map(append('#student-info')),
    map(csv),
    map(R.props(['ssn', 'firstname', 'lastname'])),
    chain(findStudent),
    chain(checkLengthSsn),
    lift(cleanInput)
);

// append('#student-info')が実行され、
// DOMへの書き出しという副作用が起こる。
// 不純な関数
showStudent('4444-44-4444');

// IOのメソッドを関数に
// (staticメソッドだからしなくてもいい気がするけど)
const liftIO = function (val) {
    return IO.of(val);
}


// string -> IO string
const showStudent = R.compose(
    // IOモナドは処理の実行を遅延する
    map(append('#student-info')),

    // ここでMaybeモナドから値を取り出し、IOモナドで包み直す
    liftIO,
    getOrElse('unable to find Student'),
    
    map(csv),
    map(R.props(['ssn', 'firstname', 'lastname'])),
    chain(findStudent),
    chain(checkLengthSsn),
    lift(cleanInput)
);

// showStudentを実行すると、学生のレコードの取得～csvへの成形まで行う
// 副作用のあるDOM出力は待機するので、showStudent自体は純粋
// (findStudentが純粋なのかはさておき)
const io = showStudent('4444-44-4444');

// io.runして初めてappend('#student-info')が実行される
// 副作用を伴い、不純
io.run();