-module(contracts_with_subtypes).

-compile(export_all).

%===============================================================================

-spec extract() -> 'ok'.

extract() ->
   case dz_extract() of
       {ok, Val} -> Val;
       error -> exit(boom)
   end.

-spec dz_extract() -> RetValue when
     FileList :: something,
     RetValue :: {ok, FileList} | error.

dz_extract() -> get(foo).

%-------------------------------------------------------------------------------

-spec extract2() -> 'ok'.

extract2() ->
   case dz_extract2() of
       {ok, Val} -> Val;
       error -> exit(boom)
   end.

-spec dz_extract2() -> RetValue when
     RetValue :: {ok, FileList} | error,
     FileList :: something.

dz_extract2() -> get(foo).

%===============================================================================

-spec foo1(Arg1) -> Res when
      Arg1 :: atom(),
      Res  :: atom().

foo1(X) -> X.

-spec foo2(Arg1) -> Res when
      Arg1 :: Arg2,
      Arg2 :: atom(),
      Res  :: atom().

foo2(X) -> X.

-spec foo3(Arg1) -> Res when
      Arg2 :: atom(),
      Arg1 :: Arg2,
      Res  :: atom().

foo3(X) -> X.

-spec foo4(Type) -> Type when is_subtype(Type, atom()).

foo4(X) -> X.

-spec foo5(Type :: atom()) -> Type :: atom().

foo5(X) -> X.

-spec foo6(Type) -> Type when Type :: atom().

foo6(X) -> X.

-spec foo7(Type) -> Type.

foo7(X) -> X.

%-------------------------------------------------------------------------------

bar(1) -> foo1(5);
bar(2) -> foo2(5);
bar(3) -> foo3(5);
bar(4) -> foo4(5);
bar(5) -> foo5(5);
bar(6) -> foo6(5);
bar(7) -> foo7(5).

wrong_foo6() ->
    b = foo6(a).

%===============================================================================

-spec rec_arg(Arg) -> ok when
      Arg :: {a, A} | {b, B},
      A   :: a | {b, B},
      B   :: b | {a, A}.

rec_arg(X) -> get(X).

c(aa) -> rec_arg({a, a});
c(bb) -> rec_arg({b, b});
c(abb) -> rec_arg({a, {b, b}});
c(baa) -> rec_arg({b, {a, a}});
c(abaa) -> rec_arg({a, {b, {a, a}}});
c(babb) -> rec_arg({b, {a, {b, b}}});
c(ababb) -> rec_arg({a, {b, {a, {b, b}}}});
c(babaa) -> rec_arg({b, {a, {b, {a, a}}}}).

w(ab) -> rec_arg({a, b}); % breaks the contract
w(ba) -> rec_arg({b, a}); % breaks the contract
w(aba) -> rec_arg({a, {b, a}}); % no longer breaks the contract
w(bab) -> rec_arg({b, {a, b}}); % breaks the contract
w(abab) -> rec_arg({a, {b, {a, b}}}); % no longer breaks the contract
w(baba) -> rec_arg({b, {a, {b, a}}}); % no longer breaks the contract
w(ababa) -> rec_arg({a, {b, {a, {b, a}}}});
w(babab) -> rec_arg({b, {a, {b, {a, b}}}}).

%% For comparison: the same thing with types

-type ab() :: {a, a()} | {b, b()}.
-type a() :: a | {b, b()}.
-type b() :: b | {a, a()}.

-spec rec2(Arg) -> ok when
      Arg :: ab().

rec2(X) -> get(X).

d(aa) -> rec2({a, a});
d(bb) -> rec2({b, b});
d(abb) -> rec2({a, {b, b}});
d(baa) -> rec2({b, {a, a}});
d(abaa) -> rec2({a, {b, {a, a}}});
d(babb) -> rec2({b, {a, {b, b}}});
d(ababb) -> rec2({a, {b, {a, {b, b}}}});
d(babaa) -> rec2({b, {a, {b, {a, a}}}}).

q(ab) -> rec2({a, b}); % breaks the contract
q(ba) -> rec2({b, a}); % breaks the contract
q(aba) -> rec2({a, {b, a}}); % breaks the contract
q(bab) -> rec2({b, {a, b}}); % breaks the contract
q(abab) -> rec2({a, {b, {a, b}}});
q(baba) -> rec2({b, {a, {b, a}}});
q(ababa) -> rec2({a, {b, {a, {b, a}}}});
q(babab) -> rec2({b, {a, {b, {a, b}}}}).

%===============================================================================

-type dublo(X) :: {X, X}.

-type weird(X,Y) :: {X, Y, X, X}.

-spec forfun(dublo(Var)) -> ok when Var :: atom().

forfun(_) -> ok.

-spec forfun2(weird(Var, Var)) -> ok when Var :: atom().

forfun2(_) -> ok.

%===============================================================================

-spec shallow(X) -> {ok, X} | {ok, X, file:filename()} | err1 | err2.

shallow(X) -> get(X).

st(X) when is_atom(X) ->
    case shallow(X) of
	err1 -> ok;
	err2 -> ok;
	{ok, X} -> ok;
	{ok, X, Res} ->
	    case Res of
		1      -> bad;
		_Other -> ok
	    end;
	alpha -> bad;
	{ok, 42} -> ok;
	42 -> bad
    end.

%-------------------------------------------------------------------------------

-spec deep(X) -> Ret when
      Ret :: {ok, X} | Err,
      Err :: err1 | err2.

deep(X) -> get(X).

dt(X) when is_atom(X) ->
    case deep(X) of
	err1 -> ok;
	err2 -> ok;
	{ok, X} -> ok;
	alpha -> bad;
	{ok, 42} -> ok;
	42 -> bad
    end.

%-------------------------------------------------------------------------------

-type local_errors() :: err1 | err2.

-spec deep2(X) -> Ret when
      Ret :: {ok, X} | Err,
      Err :: local_errors().

deep2(X) -> get(X).

dt2(X) when is_atom(X) ->
    case deep2(X) of
	err1 -> ok;
	err2 -> ok;
	{ok, X} -> ok;
	alpha -> bad;
	{ok, 42} -> ok;
	42 -> bad
    end.

%-------------------------------------------------------------------------------

-spec deep3(X) -> Ret when
      Ret :: {ok, X, file:filename()} | Err,
      Err :: local_errors().

deep3(X) -> get(X).

dt3(X) when is_atom(X) ->
    case deep3(X) of
	err1 -> ok;
	err2 -> ok;
	{ok, X, Res} ->
	    case Res of
		1      -> bad;
		_Other -> ok
	    end;
	{ok, X} -> bad;
	alpha -> bad;
	{ok, 42} -> bad;
	42 -> bad
    end.

%===============================================================================

-spec flat_ets_new(Name, Options) -> atom() when
      Name :: atom(),
      Options :: [Option],
      Option :: set
              | ordered_set
              | bag
              | duplicate_bag
              | public
              | protected
              | private
              | named_table
              | {keypos, integer()}
              | {heir, pid(), term()}
              | {heir, none}
              | {write_concurrency, boolean()}
              | {read_concurrency, boolean()}
              | compressed.

flat_ets_new(Name, Options) ->
    get({Name, Options}).

flat_ets_new_t() ->
    flat_ets_new(12,[]),
    flat_ets_new({a,b},[]),
    flat_ets_new(name,[foo]),
    flat_ets_new(name,{bag}),
    flat_ets_new(name,bag),
    ok.

-type access()     :: public | protected | private.
-type type()       :: set | ordered_set | bag | duplicate_bag.

-spec factored_ets_new(Name, Options) -> atom() when
      Name :: atom(),
      Options :: [Option],
      Option :: Type | Access | named_table | {keypos,Pos}
              | {heir, Pid :: pid(), HeirData} | {heir, none} | Tweaks,
      Type :: type(),
      Access :: access(),
      Tweaks :: {write_concurrency, boolean()}
              | {read_concurrency, boolean()}
              | compressed,
      Pos :: pos_integer(),
      HeirData :: term().

factored_ets_new(Name, Options) ->
    get({Name, Options}).

factored_ets_new_t() ->
    factored_ets_new(12,[]),
    factored_ets_new({a,b},[]),
    factored_ets_new(name,[foo]),
    factored_ets_new(name,{bag}),
    factored_ets_new(name,bag),
    ok.