Simple pipelines

pipe.erl

-spec pipe([Fun], Value) -> Result
    when Fun      :: fun((Value) -> Result),
         Value    :: term(),
         Result   :: {ok, NewValue}
                   | {error, Reason}
                   | {error, Reason, Info},
         NewValue :: term(),
         Reason   :: term(),
         Info     :: {Fun, Value}
                   | {Fun, Value, Info}.

pipe([F | Fs], Value) ->
    case F(Value) of
        {ok, Result}          -> pipe(Fs, Result);
        {error, Reason}       -> {error, Reason, {F, Value}};
        {error, Reason, Info} -> {error, Reason, {F, Value, Info}}
    end;
pipe([], Value) ->
    {ok, Value}.


-spec pipe([Fun], Value, State) -> Result
    when Fun      :: fun((Value, State) -> Result),
         Value    :: term(),
         Result   :: {ok, NewValue}
                   | {ok, NewValue, NewState}
                   | {error, Reason}
                   | {error, Reason, Info},
         NewValue :: term(),
         NewState :: term(),
         Reason   :: term(),
         Info     :: {Fun, Value}
                   | {Fun, Value, State}
                   | {Fun, Value, State, Info}.

pipe([F | Fs], Value, State) ->
    case F(Value, State) of
        {ok, Result}           -> pipe(Fs, Result, State);
        {ok, Result, NewState} -> pipe(Fs, Result, NewState);
        {error, Reason}        -> {error, Reason, {F, Value, State}};
        {error, Reason, Info}  -> {error, Reason, {F, Value, State, Info}}
    end;
pipe([], Value, State) ->
    {ok, Value, State}.


some_long_operation(Value) ->
    Transform =
        [fun a/1,
         fun b/1,
         fun c/1,
         fun d/1],
    pipe(Transform, Value).


some_long_operation(Value, State) ->
    Transform =
        [fun a/2,
         fun b/2,
         fun c/2,
         fun d/2],
    pipe(Transform, Value, State).