src/hope_result.erl

   1 -module(hope_result).
   2
   3 -behavior(hope_gen_monad).
   4
   5 -export_type(
   6     [ t/2
   7     , exn_class/0
   8     , exn_value/1
   9     ]).
  10
  11 -export(
  12     [ return/1
  13     , map/2
  14     , map_error/2
  15     , tag_error/2
  16     , pipe/2
  17     , lift_exn/1
  18     , lift_exn/2
  19     , lift_map_exn/3
  20     ]).
  21
  22 -type exn_class() ::
  23       error
  24     | exit
  25     | throw
  26     .
  27
  28 -type exn_value(A) ::
  29     {exn_class(), A}.
  30
  31 -type t(A, B) ::
  32       {ok, A}
  33     | {error, B}
  34     .
  35
  36
  37 -spec return(A) ->
  38     {ok, A}.
  39 return(X) ->
  40     {ok, X}.
  41
  42 -spec map(t(A, Error), fun((A) -> (B))) ->
  43     t(B, Error).
  44 map({ok, X}, F) ->
  45     {ok, F(X)};
  46 map({error, _}=Error, _) ->
  47     Error.
  48
  49 -spec map_error(t(A, B), fun((B) -> (C))) ->
  50     t(A, C).
  51 map_error({ok, _}=Ok, _) ->
  52     Ok;
  53 map_error({error, Reason}, F) ->
  54     {error, F(Reason)}.
  55
  56 -spec tag_error(t(A, Reason), Tag) ->
  57     t(A, {Tag, Reason}).
  58 tag_error({ok, _}=Ok, _) ->
  59     Ok;
  60 tag_error({error, Reason}, Tag) ->
  61     {error, {Tag, Reason}}.
  62
  63 -spec pipe([F], X) ->
  64     t(Ok, Error)
  65     when X     :: any()
  66        , Ok    :: any()
  67        , Error :: any()
  68        , F     :: fun((X) -> t(Ok, Error))
  69        .
  70 pipe([], X) ->
  71     {ok, X};
  72 pipe([F|Fs], X) ->
  73     case F(X)
  74     of  {error, _}=E -> E
  75     ;   {ok, Y}      -> pipe(Fs, Y)
  76     end.
  77
  78 -spec lift_exn(F) -> G
  79     when F     :: fun((A) -> B)
  80        , G     :: fun((A) -> t(B, exn_value(any())))
  81        .
  82 lift_exn(F) when is_function(F, 1) ->
  83     ID = fun hope_fun:id/1,
  84     lift_map_exn(F, ID, ID).
  85
  86 -spec lift_exn(F, ErrorTag) -> G
  87     when F :: fun((A) -> B)
  88        , G :: fun((A) -> t(B, {ErrorTag, exn_value(any())}))
  89        .
  90 lift_exn(F, ErrorTag) when is_function(F, 1) ->
  91     ID = fun hope_fun:id/1,
  92     Tag = fun (Reason) -> {ErrorTag, Reason} end,
  93     lift_map_exn(F, ID, Tag).
  94
  95 -spec lift_map_exn(F, MapOk, MapError) -> G
  96     when F        :: fun((A) -> B)
  97        , MapOk    :: fun((B) -> C)
  98        , MapError :: fun((exn_value(any())) -> Error)
  99        , G        :: fun((A) -> t(C, Error))
 100        .
 101 lift_map_exn(F, MapOk, MapError) when is_function(F, 1) ->
 102     fun(X) ->
 103         Result =
 104             try
 105                 {ok, F(X)}
 106             catch Class:Reason ->
 107                 {error, {Class, Reason}}
 108             end,
 109         % Applying maps separately as to not unintentionally catch an exception
 110         % raised in a map.
 111         case Result
 112         of  {ok   , _}=Ok    -> map      (Ok   , MapOk)
 113         ;   {error, _}=Error -> map_error(Error, MapError)
 114         end
 115     end.