anchor.diff:  default_block_size() ->
       ?BLOCK_SIZE.
   
  --spec parse(Bin :: binary()) -> [row()].
  +-spec parse(Bin) -> Rows when
  +      Bin :: binary(),
  +      Rows :: rows().
   parse(Bin) ->
       parse(Bin, []).
   
  --spec parse(Bin :: binary(), Opts :: options()) -> [row()].
  +-spec parse(Bin, Opts) -> Rows when
  +      Bin :: binary(),
  +      Opts :: options(),
  +      Rows :: rows().
   parse(Bin, Opts) ->
       {ok, Acc, S} = parse_raw(Bin, parser_init(Opts), []),
       {ok, Ls, _} = parse_raw(eof, S, Acc),
       lists:reverse(Ls).
   
  --spec parse_step(Input :: input(), State0 :: state()) -> {ok, [row()], State :: state()}.
  +-spec parse_step(Input, State0) -> Result when
  +      Input :: input(),
  +      State0 :: state(),
  +      Result :: {ok, Rows, State},
  +      Rows :: rows(),
  +      State :: state().
   parse_step(Bin, State) ->
       {ok, Ls, S2} = parse_raw(Bin, State, []),
       {ok, lists:reverse(Ls), S2}.
   
  --spec parse_stream(
  -        reader_fun(ReaderStateType), ReaderState0 :: ReaderStateType,
  -        callback_fun(CallBackStateType), CallbackState0 :: CallBackStateType) ->
  -    {ReaderState :: ReaderStateType, CallbackState :: CallBackStateType,
  -     State :: state()}.
  +-spec parse_stream(Reader, ReaderState0, CallBack, CallbackState0) ->
  +    Result when
  +      Reader :: reader_fun(ReaderStateType),
  +      ReaderState0 :: ReaderStateType,
  +      CallBack :: callback_fun(CallBackStateType),
  +      CallbackState0 :: CallBackStateType,
  +      Result :: {ReaderState, CallbackState, State},
  +      ReaderState :: ReaderStateType,
  +      CallbackState :: CallBackStateType,
  +      State :: state().
   parse_stream(Reader, ReaderState0, CallBack, CallbackState0) ->
       parse_stream(Reader, ReaderState0, CallBack, CallbackState0, []).
   
  --spec parse_stream(
  -        reader_fun(ReaderStateType), ReaderState0 :: ReaderStateType,
  -        callback_fun(CallBackStateType), CallbackState0 :: CallBackStateType,
  -        StateOrOpts :: state() | options()) ->
  -    {ReaderState :: ReaderStateType, CallBackState :: CallBackStateType,
  -     State :: state()}.
  +-spec parse_stream(Reader, ReaderState0, CallBack, CallbackState0, StateOrOpts) ->
  +    Result when
  +      Reader :: reader_fun(ReaderStateType),
  +      ReaderState0 :: ReaderStateType,
  +      CallBack :: callback_fun(CallBackStateType),
  +      CallbackState0 :: CallBackStateType,
  +      StateOrOpts :: state() | options(),
  +      Result :: {ReaderState, CallbackState, State},
  +      ReaderState :: ReaderStateType,
  +      CallbackState :: CallBackStateType,
  +      State :: state().
   parse_stream(Reader, ReaderState0, CallBack, CallbackState0, State) ->
       parse_stream_(Reader, ReaderState0, CallBack, CallbackState0,
                     if
  
positive.code:                       true           -> State
                    end).
  
  -spec parse_raw(Input :: input(), State0 :: state(), Acc :: [row()]) ->
      {ok, RevRows :: [row()], State :: state()}.
  parse_raw(eof, State, Acc) -> ecsv_nif:parse(eof, State, Acc);
  parse_raw(<<Bin:(?BLOCK_SIZE)/bytes, Rest/bytes>>, State, Acc) ->
      {ok, Acc2, S2} = ecsv_nif:parse(Bin, State, Acc),
  
negative.code:             end
      end.
  
  -spec block_chopper(BlockSize) -> Reader when
        BlockSize :: pos_integer(),
        Reader :: reader_fun(State),
        State :: binary().
  block_chopper(BlockSize) when is_integer(BlockSize), BlockSize > 0 ->
      fun(<<>>) ->
              {eof, <<>>};
  