DouKaku?

-module(netmask).
-export([numbits_of/1,from_numbits/1,test/0]).

numbits_of(StrMask) -> 
    try
        {ok,Mask} = inet_parse:address(StrMask) ,
        {Class,MaskByte} = case Mask of
                        {255,255,255,X} -> {24,X};
                        {255,255,  X,0} -> {16,X};
                        {255,  X,  0,0} -> { 8,X};
                        _ -> throw("bad mask")
                        end,
        {ok,
        case MaskByte of
            (256-  1)-> 8;
            (256-  2)-> 7;
            (256-  4)-> 6;
            (256-  8)-> 5;
            (256- 16)-> 4;
            (256- 32)-> 3;
            (256- 64)-> 2;
            (256-128)-> 1;
            0        -> 0
        end + Class }% <--- result
    catch
        throw:E -> {thrown,E};
        exit :E -> {exited,E};
        error:E -> {error ,E}
    end.

from_numbits(Numbits)->
    try
        {Class,Maskbits} = 
                        case Numbits of
                            N when N>=24 -> {24,N-24} ;
                            N when N>=16 -> {16,N-16} ;
                            N when N>= 8 -> { 8,N- 8} 
                        end ,
        Maskbyte = 
                case Maskbits of 
                    8 -> (256-  1) ;
                    7 -> (256-  2) ;
                    6 -> (256-  4) ;
                    5 -> (256-  8) ;
                    4 -> (256- 16) ;
                    3 -> (256- 32) ;
                    2 -> (256- 64) ;
                    1 -> (256-128) ;
                    0 -> 0
                end ,
        %
        {ok , 
        case Class of
            24 -> inet_parse:ntoa( {255,255,255,Maskbyte} ) ;
            16 -> inet_parse:ntoa( {255,255,Maskbyte  ,0} ) ;
            8  -> inet_parse:ntoa( {255,Maskbyte    ,0,0} ) 
        end }% <--- result
    catch
        throw:E -> {thrown,E};
        exit :E -> {exited,E};
        error:E -> {error ,E}
    end.

test()->
    lists:foreach(fun(I)->
                    {ok , M} = from_numbits(I),
                    {ok , N} = numbits_of(M),
                    io:format("Numbits=~p , Mask=~p , Result=~p~n",[I,M,(I==N)])
                  end , lists:seq(8,31) ).