読者です 読者をやめる 読者になる 読者になる

RSpec で pending しても before :context が呼ばれてしまう

結果だけ先に書いてしまいますが『pending しているスコープで before :context を定義すると before のブロックが呼ばれます』。
どういうことかというと次のように before :context 内で例外が発生した場合、テストが失敗してしまいます。

describe X do
    # 以下のブロックを pending にする
    xcontext 'hoge' do
        # pending しているのにもかかわらず it 時に before のブロックが呼ばれてしまう
        before :context do
            raise "error"
        end
        it { expect(0).to eq 0 }
    end
end

これは pending してるのにもかかわらず before:context を指定した場合、it 時にブロック内の処理が呼ばれてしまうためです。
また、この問題(というべきかはわかりませんが)は :context を渡した時のみ発生し、引数を渡さなかったり :example を渡した場合には再現しません。
ちなみに :all:contextエイリアスなので :all を渡しても同様の問題が発生します。

どういう時に困るのか

例えば、次のように before 内で実装する予定のメソッドを呼び出していると例外が発生するのでテストが失敗してしまいます。

describe X do
    # X.hoge を後で実装する
    xcontext '.hoge' do
        before :context do
            # この段階では .hoge は未実装
            @result = X.hoge
        end
        it { expect(@result).to eq "hoge" }
        it { expect(@result).to be_kind_of String }
    end
end

こういう場合は before :context を使わなかったり、before 以外(subject など)を使用して回避する必要があります。

[関連]

https://github.com/rspec/rspec-core/issues/107

[追記]

書き忘れてましたが RSpec のバージョンは 3.6.0 です。

Ruby の Method#=== が定義されていないのでつらい問題

Method#=== が定義されていなくてつらい問題です。

Proc#===

Proc オブジェクトでは #call で評価することが出来ますが、そのエイリアスとして #=== が存在します。

upcase = proc { |a| a.upcase }
upcase.call "homu"
# => "HOMU"
upcase === "mami"
# => "MAMI"

これは次のように when で使用出来るようにするためです。

def sign n
    case n
    when proc { |n| 0 < n }
        1
    when proc { |n| 0 > n }
        -1
    else
        0
    end
end

sign -4  # => -1
sign 0   # => 0
sign 7   # => 1

ここで、Ruby に精通してる人なら気づくと思いますが、#method を使って proc { |n| 0 < n }0.method(:<) と書き直したくなります。

def sign n
    case n
    # #method はレシーバのメソッドをブロックオブジェクトとして返す
    when 0.method(:<)
        1
    when 0.method(:>)
        -1
    else
        0
    end
end

しかし、これは上手く動作しません。
なぜなら #method が返す Method クラスでは #=== が定義されていないからです。

Method#=== を定義する gem をつくった

と、いうことで Method#=== を使うことが出来る gem をつくりました。

$ gem install procedureable_method

で、インストールすることが出来ます。

使い方

使い方は

require "procedureable_method"
using ProcedureableMethod

という風に refinements として使用するか

require "procedureable_method/core_ext"

として直接モンキーパッチを適用されるかします。
これで Method#=== を使用する事が出来ます。

require "procedureable_method"

using ProcedureableMethod

def sign n
    case n
    when 0.method(:<)
        1
    when 0.method(:>)
        -1
    else
        0
    end
end

sign -4  # => -1
sign 0   # => 0
sign 7   # => 1

これで無事に whenMethod を渡して評価する事が出来ました。
関係ないですが when の場合はちゃんと refinements で定義したメソッドが呼ばれるんですね。
本体にも Method#=== が追加されてほしい。

Ruby で mixin したモジュールを削除する gem をつくった

Rubyメタプログラミングをやっているとどうしても『mixin したモジュールを削除したい』という欲求にかられるのでつくりました。

インストール

$ gem install unmixer

使い方

require "unmixer"

# Unmixer は refinements を使用してるので using して使用します
using Unmixer

module M1; end
module M2; end
module M3; end

class X
    include M1
    prepend M2
end

p X.ancestors
# => [M2, X, M1, Object, Kernel, BasicObject]

# include したモジュールを削除
X.instance_eval { uninclude M1 }
p X.ancestors
# => [M2, X, Object, Kernel, BasicObject]

# include したモジュール以外は削除できない
X.instance_eval { uninclude M2 }
p X.ancestors
# => [M2, X, Object, Kernel, BasicObject]


# prepend したモジュールを削除
X.instance_eval { unprepend M2 }
p X.ancestors
# => [X, Object, Kernel, BasicObject]


X.extend M3
p X.singleton_class.ancestors
# => [#<Class:X>, M3, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

# extend したモジュールを削除
X.unextend M3
p X.singleton_class.ancestors
# => [#<Class:X>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]


# #extend にブロックを渡した場合、ブロック内でのみ mixin される
X.extend M1 do
    # mixin only in block.
    p X.singleton_class.ancestors
    # => [#<Class:X>, M1, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
    p X.singleton_class.ancestors.include? M1
    # => true
end
p X.singleton_class.ancestors
# => [#<Class:X>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
p X.singleton_class.ancestors.include? M1
# => false

元々は uninclude という gem があったのですが、こちらは比較的新しい Ruby では動作しなかったのでそれを焼き直した形になります。

現状は、Ruby 2.1 〜2.4 であれば動作すると思います。
ただ、実装が結構無理なりなので今後のサポートや意図しない動作が発生する可能性はあります。
今回初めて Ruby で C拡張のコードを書いたんですが、やはり C言語つらいですね…。
最初は C 側で全部を実装していたんですが、途中でつらくなったので C 側は最小限の処理のみ実装して結局 Ruby 側でガシガシ実装しました。
多少不安なところはあるんですが、やはり mixin を削除できる機能はかなり便利です。
言語仕様側で導入されないかなあ…。

【初心者C++er Advent Calendar 2016 21日目】C++ でプリプロセスマクロを使う場面

初心者C++er Advent Calendar 2016 21日目の記事です。
さて、巷ではマクロを使用したコードを公開すると『static const を使え』や『typedef しろ』、『関数テンプレートでおk』などと斧が飛んでくる突っ込まれることが多いです。
これは C++ では『基本的にはマクロを使うべきではなく』さらに『マクロを使わないでよいコード』に直せることが多いからです。
では逆に『マクロを使うべきコード』というのはどういうものなのでしょうか。
この記事では『マクロを使うべきコード』の実例をいくつか紹介してみたいと思います。

[インクルードガード]

ヘッダーファイルを記述する際に『重複インクルードを防止するため』にインクルードガードという技法が使用されれます。
これは #ifndef を利用して『一度だけヘッダーファイルが読み込まれる』ような仕組みです。

// hoge.h
#ifndef HOGE_H
#define HOGE_H

// ここに実装を記述する

#endif    // HOGE_H

これにより複数回 #include "hoge.h" しても一度だけ定義が読み込まれます。
ただ、最近は同等の機能である #pragma once を実装してるコンパイラもあるので、そちらを使用している人もいます。

[キーワードなどを置き換える]

さて、次のように constexpr を使ったコードがあるとします。

constexpr auto
plus(int a, int b){
    return a + b;
}

constexpr auto
minus(int a, int b){
    return a - b;
}

static_assert(plus(1, 2) == 3, "");
static_assert(minus(4, 5) == -1, "");

これは C++11 に対応してるコンパイラであれば問題なく動作します。
しかし、環境によってはどうしても C++03 に対応しなければならないこともあります。
こういう場合、constexpr というキーワードをマクロに置き換えることで、複数の環境に柔軟に対応する事が出来ます。

// C++11 以上ならば
#if __cplusplus >= 201103L
    // constexpr をマクロに置き換える
   #define CONSTEXPR constexpr
#else
    // C++11 以上に対応してないなら空のマクロを定義
   #define CONSTEXPR
#endif

// constexpr をマクロに置き換える
CONSTEXPR int
plus(int a, int b){
    return a + b;
}

CONSTEXPR int
minus(int a, int b){
    return a - b;
}

#if __cplusplus >= 201103L
static_assert(plus(1, 2) == 3, "");
static_assert(minus(4, 5) == -1, "");
#endif

このように『マクロ以外』で置き換えることが出来ないようなワークアラウンドに対応する場合に利用できます。

[コンパイルするときに挙動を変更したい場合]

例えば、次のように『デバッグコードを仕込んだコード』があるとします。

int
plus(int a, int b){
// DEBUG が定義されている時のみログを出力したい
#ifndef DEBUG
    std::cout << a << std::endl;
    std::cout << b << std::endl;
#endif
    return a + b;
}

このように『マクロを使用すること』でコンパイル時に『挙動を変更する』事が出来ます

# DEBUG マクロを定義してコンパイルする
$ g++ main.cpp -DDEBUG
$ ./a
1
2
3

gcc だとこんな感じでコンパイル時にマクロを定義する事が出来ます。

[まとめ]

と、言う感じでパッと思いついたものを上げてみました。
他にも使うべき場面はありますが、初心者向けならこのあたりでしょうか。
C++ では『マクロを使うべきではないコード』もたくさんありますが『マクロでしか実装出来ないコード』もまた存在します。
マクロは用法・用量を守って正しくお使いください。

Ruby 2.4 で refinements の制限が緩和された

さて、先日 Ruby 2.4 がリリースされました。

Ruby 2.4.0 リリース

[refinements の制限を緩和]

Ruby 2.4 では refinements の制限が緩和され、#send からも refine されているメソッドが呼び出せるようになりました。

class X; end

module Ex
    refine X do
        def homu
            p "homu"
        end
    end
end

using Ex

x = X.new

x.send :homu
# => "homu"

日頃から refinements クソだ!と言ってる勢としては『やっと対応されたか…』という感じ。
今後も使い勝手がよくなるようにここら辺の制限の調整がすすむといいですねえ…。
あとリリース前に Symbol#to_proc 内からも呼び出させるようになると聞いたんですが、こっちはまだエラーでした。

# Error: undefined method `homu' for #<X:0x005564eebeba60> (NoMethodError)
:homu.to_proc.call x

【初心者C++er Advent Calendar 2016 20日目】関数テンプレートの呼び出しに優先順位をつける

初心者C++er Advent Calendar 2016 20日目の記事です。
クリスマスが終わって『もはや Advent Calendar とは…』となってるんですが、まあ埋まってないより埋まってるほうがいいかなーと。
今回は初心者向けかどうか怪しい内容ですが、ちょっとしたハックでも。
なお、この記事は SFINAE を知ってる事が前提の記事になります。

[コード]

さて、次のように SFINAE を利用して『a + aができる型(値)のみ』受け付けたい関数テンプレートを定義したいことがあると思います。

template<typename T>
auto
twice(T a)
// decltype() 内で式を記述することで a + a を要求する
->decltype(a + a){
    return a + a;
}

// 42 + 42 は有効なので OK
twice(42);         // 84

// 3.14f + 3.14f も有効なので OK
twice(3.14f);      // 6.28

// "homu" + "homu" は無効なので NG
twice("homu");

まあここまではよくあるコードだと思います。

[問題]

このような関数テンプレートを定義した場合に『それ以外にマッチする関数』も定義したいことがあると思います。

// a + a が有効でない引数の場合に呼び出す関数を定義
template<typename T>
auto
twice(T t){
    return t;
}

twice("homu");        // "homu"

これでよかったよかった…とはならずに、次のように『a + aができる型(値)』を渡した場合にエラーになります。

// Error: call of overloaded 'twice(int)' is ambiguous
twice(42);

http://melpon.org/wandbox/permlink/GqFem4RxFct7gvqF

これは twice(int) 時に『両方の関数に該当するため』呼び出しが解決できないためです。

[解決]

解決策はいくつかあるんですが、次のようにして『オーバーロードを解決するため引数』を追加することで比較的簡単に回避することが出来ます。

// 引数に int を追加する
template<typename T>
auto
twice(int, T a)
->decltype(a + a){
    return a + a;
}

// 引数に bool を追加する
template<typename T>
auto
twice(bool, T t){
    return t;
}

// int 型の値を関数に渡すことで最初に定義した関数の方を優先して呼び出されるようになる
twice(0, 42);        // 84
twice(0, 3.14f);     // 6.28
twice(0, "homu");    // "homu"

http://melpon.org/wandbox/permlink/WeEUFMV8MGEZRkyb

これは twice(0, 42) の場合は twice(bool, T) よりも twice(int, T) にマッチし、twice(0, "homu") の場合は SFINAE によって twice(int, T)オーバーロード候補から外れ、0bool 型に暗黙の型変換されるので twice(bool, T) にマッチするためです。
まあ、要するに

void func(int);
void func(bool);

// func(int) を呼び出す
func(0);

ということを利用しているだけですね。

[ちょっと改良]

上記のままだと毎回 0 を渡す必要があるのでラッパ関数を用意すると使い勝手がよくなります。

template<typename T>
auto
twice_impl(int, T a)
->decltype(a + a){
    return a + a;
}

template<typename T>
auto
twice_impl(bool, T t){
    return t;
}

template<typename T>
auto
twice(T t){
    // ラッパ関数を用意して、その中で twice の実装を呼び出す
    return twice_impl(0, t);
}

twice(42);        // 84
twice(3.14f);     // 6.28
twice("homu");    // "homu"

http://melpon.org/wandbox/permlink/lwTkvXx39ptEP6TN

これでユーザコードからこのハックを隠蔽する事が出来ました。

[まとめ]

と、言う感じで簡単なハックを紹介してみました。
SFINAE を使った関数を定義しているとこういう『オーバーロードが解決できない関数』が結構出てくるんで地味に重宝します。
もうちょっと汎用的にしたコードが下記の記事に載ってるので気になる方は読んでみるとよいです。

[参照]

【初心者C++er Advent Calendar 2016 19日目】C++ 楽しいメタプログラミングしよう

初心者C++er Advent Calendar 2016 19日目の記事です。
クリスマスから少し過ぎてしまいましたが、最後に楽しくメタプログラミングしてみる記事でも。
初心者C++er Advent Calendar 2016 が全部うまるといいですね。

[メタプログラミングとは]

メタプログラミングの定義は言語によって異なりますが、C++ においては『テンプレート』を利用して『コンパイル時』に処理を行うことを指す事が一般的です。
今回はテンプレートを利用して『型に対して』コンパイル時に処理を行うコードを書いていきたいと思います。

[前提の知識]

[テンプレートの特殊化]

前提として『テンプレートの特殊化』を理解している必要があります。
『テンプレートの特殊化』というのはクラステンプレートなどに対して『特定の型』に対して処理を別に記述する記法です。

template<typename T>
struct X{
    
};

// 任意のテンプレート引数型に対して拡張する
// テンプレート引数が int の場合はこっちが使用される
template<>
struct X<int>{
    
};

メタプログラミングはこの特殊化を利用することが多いです。

[static_assert()]

static_assert() は『コンパイル時に意図的にエラーにするため』の機能です。

static_assert(定数式, 文字列リテラル);

のような形式で記述し、定数式false の場合に 文字列リテラル を出力してコンパイルエラーになります。

static_assert(3 > 1, "Error Message");    // OK コンパイルエラーにならない
static_assert(1 > 3, "Error Message");    // NG コンパイルエラーになる

メタプログラミングstatic_assert() を使用してテストする事が多いです。

参照:コンパイル時アサート - cpprefjp C++日本語リファレンス

[std::true_typestd::false_type]

今回つくるメタプログラミングstd::true_typestd::false_type を使用します。
この2つの型は単純に ::valuetruefalse を返すだけのクラスになります。

std::true_type::value;    // true
std::false_type::value;   // false

この2つは標準ライブラリの <type_traits> で 具体的な利用方法はこのあと書いていきます。

[メタ関数]

メタプログラミングはクラステンプレートに型を渡して処理を行ないます。

// hoge クラステンプレートに型を渡してその結果を ::type で取得する
hoge<int, float>::type

このように任意の型をクラステンプレートに渡して、その結果を ::type という型で受け取ります。
また、このように型に対して処理するクラステンプレートのことを『メタ関数』を呼びます。
ちなみにメタ関数には型以外にも『値』を返すこともあります。
その場合は

foo<int, float>::value

というふうに ::value で返すことが一般的です。
このようにメタ関数を使用、定義する場合はそのメタ関数が『型を返す』のか『値を返す』のかを意識する必要があります。

[型を比較する]

さて、まずは簡単に型を比較してみましょう。
動作イメージは以下のような感じです。

template<typename T, typename U>
struct is_same;

is_same<int, int>::value;         // true
is_same<int, float>::value;       // false
is_same<int, const int>::value;   // false

このようにある型とある型が同じ型かどうかを比較するクラステンプレートを書いてみます。

#include <type_traits>

// 元となるクラステンプレート
// デフォルトでは std::false_type を継承する
template<typename T, typename U>
struct is_same : std::false_type{};

template<typename T>
// 2つのテンプレート引数が同じ型の場合の特殊化
// 同じ型の場合は std::true_type を継承する
struct is_same<T, T> : std::true_type{};


// ::value は std::true_type と std::false_type で定義されてる
static_assert(is_same<int, int>::value       == true, "");
static_assert(is_same<int, float>::value     == false, "");
static_assert(is_same<int, const int>::value == false, "");

http://melpon.org/wandbox/permlink/VNE2apvsZ2Hq21Le

こんな感じでテンプレートの特殊化を利用して実装します。
今回は比較した結果を『値』で返すので ::value で結果を受け取ります。
ポイントとしては真になる場合は std::true_type を継承し、偽になる場合は std::false_type を継承してる点です。
これにより ::value を定義することなく継承するだけで『真』や『偽』となるクラスが定義できます。

[型に const などを付属させる]

任意の型に対して const やポインタなどを付属させるメタ関数を定義してみます。
まずはポインタを追加するメタ関数です。

template<typename T>
struct add_const{
    using type = T const;
};

static_assert(is_same<add_const<int>::type, int const>::value, "");
static_assert(is_same<add_const<int*>::type,  int* const>::value, "");
static_assert(is_same<add_const<int const>::type, int const>::value, "");


template<typename T>
struct add_pointer{
    using type = T*;
};

static_assert(is_same<add_pointer<int>::type,    int*>::value, "");
static_assert(is_same<add_pointer<void>::type,   void*>::value, "");
static_assert(is_same<add_pointer<float*>::type, float**>::value, "");

// 組み合わせて使用したり
static_assert(is_same<add_pointer<add_const<int>::type>::type, int const*>::value, "");

http://melpon.org/wandbox/permlink/GtOPyLNLgxyJK2jX

今回は結果が『値』ではなくて『型』なのでテンプレート型に対して const* を付属した type 型を定義しています。

[const やポインタを削除する]

では逆に const やポインタを削除するメタ関数を定義してみましょう。

template<typename T>
struct remove_pointer{
    using type = T;
};

template<typename T>
struct remove_pointer<T*>{
    using type = T;
};

static_assert(is_same<remove_pointer<int*>::type,  int>::value, "");
static_assert(is_same<remove_pointer<int**>::type, int*>::value, "");
static_assert(is_same<remove_pointer<int>::type,   int>::value, "");


template<typename T>
struct remove_const{
    using type = T;
};

template<typename T>
struct remove_const<T const>{
    using type = T;
};

static_assert(is_same<remove_const<int const>::type,  int>::value, "");
static_assert(is_same<remove_const<int* const>::type, int*>::value, "");
static_assert(is_same<remove_const<int>::type,        int>::value, "");

http://melpon.org/wandbox/permlink/dmYesP6x8QV9GZOK

先ほどのコードよりもちょっと複雑ですね。
const やポインタの判定に特殊化を利用しています。

template<typename T>
struct X<T*>{};

というように記述することで『ポインタ型の場合のみ』という特殊化を行うことが出来ます。

[コンパイルFizzBuzz]

さて、最後にコンパイル時に FizzBuzz を行うメタ関数を書いてみましょう

[結果の型]

今回、FizzBuzz の結果は型として返します。
ですので最初にそれぞれの結果を型として定義しておきます。

struct Fizz{};

struct Buzz{};

struct FizzBuzz{};

// Fizz, Buzz, FizzBuzz 以外の場合はこの型をラップして返す
template<int N>
struct int_{};

数値の場合は『値』ではなくて『型』を返す必要があるので、それ用に『数値を受け取るクラステンプレート』も用意しておきます。

[if_else]

分岐処理を行うために if 文を模倣するメタ関数も用意しておきます。

template<bool Cond, typename Then, typename Else>
struct if_{
    using type = Then;
};

template<typename Then, typename Else>
struct if_<false, Then, Else>{
    using type = Else;
};

static_assert(is_same<if_<true,  int, float>::type, int>::value, "");
static_assert(is_same<if_<false, int, float>::type, float>::value, "");

これも特殊化を利用してデフォルトは Then を返し、Condfalse の場合は Else を返すようにします。

[完成品]

先ほど書いたメタ関数を利用して FizzBuzz を実装すると以下のような感じになります。

struct Fizz{};

struct Buzz{};

struct FizzBuzz{};

template<int N>
struct int_{};


template<bool Cond, typename Then, typename Else>
struct if_{
    using type = Then;
};

template<typename Then, typename Else>
struct if_<false, Then, Else>{
    using type = Else;
};

static_assert(is_same<if_<true,  int, float>::type, int>::value, "");
static_assert(is_same<if_<false, int, float>::type, float>::value, "");


template<int N>
struct fizzbuzz{
    using type
        = typename if_<N % 15 == 0, FizzBuzz,
          typename if_<N %  3 == 0, Fizz,
          typename if_<N %  5 == 0, Buzz,
          int_<N> >::type >::type >::type;

//  どっちが見やすいかな…
//     using type = typename if_<
//         N % 15 == 0,
//         FizzBuzz,
//         typename if_<
//             N % 3 == 0,
//             Fizz,
//             typename if_<
//                 N % 5 == 0,
//                 Buzz,
//                 int_<N>
//             >::type
//         >::type
//     >::type;
};

static_assert(is_same<fizzbuzz<1>::type,  int_<1>>::value, "");
static_assert(is_same<fizzbuzz<2>::type,  int_<2>>::value, "");
static_assert(is_same<fizzbuzz<3>::type,  Fizz>::value, "");
static_assert(is_same<fizzbuzz<4>::type,  int_<4>>::value, "");
static_assert(is_same<fizzbuzz<5>::type,  Buzz>::value, "");
static_assert(is_same<fizzbuzz<6>::type,  Fizz>::value, "");
static_assert(is_same<fizzbuzz<10>::type, Buzz>::value, "");
static_assert(is_same<fizzbuzz<15>::type, FizzBuzz>::value, "");
static_assert(is_same<fizzbuzz<30>::type, FizzBuzz>::value, "");

http://melpon.org/wandbox/permlink/pEnLxRi5MXxKJ83C

メタプログラミングではネストした if 文を記述するのが難読化してしまうのでちょっと見づらいですが、やってること自体は一般的な FizzBuzz と同じなのでそんなに複雑ではないです。

[まとめ]

と、言う感じで簡単にメタプログラミングについて書いてみました。
C++メタプログラミングというと敷居が高いイメージがありますが、細かいところ見ていくとそんなに複雑なことをしていないことがわかると思います。
メタプログラミングC++ の醍醐味でもありますしね。
今回の記事でメタプログラミングに興味を持った方は標準ライブラリの <type_traits> を調べてみたり Boost.MPL なんかを見てみるとよいと思います。
ちなみに今回は C++03 を少し意識して書いたんですが、C++11/14 では少しメタプログラミングが記述しやすくなっているので、それについても調べてみても面白いです。
それではよい C++ を〜。