remove _t sufix from types (#509)

Author: mat-hek

CHANGELOG.md

@@ -3,7 +3,7 @@
 ## 1.0.0
  * Introduce `:remove_link` action in pipelines and bins.
  * Add children groups - a mechanism that allows refering to multiple children with a single identifier. 
- * Rename `remove_child_t` action into `remove_children_t` and allow for removing a children group with a single action.
+ * Rename `remove_child` action into `remove_children` and allow for removing a children group with a single action.
  * Add an ability to spawn anonymous children.
  * Replace `Membrane.Time.round_to_<unit_name>` with `Membrane.Time.as_<unit_name>/2` with second argument equal `:round`. Rename `Membrane.Time.round_to_timebase` to `Membrane.Time.divide_by_timebase/2`. [#494](https://github.com/membraneframework/membrane_core/pull/494)
  * Remove `:playback` action. Introduce `:setup` action. [#496](https://github.com/membraneframework/membrane_core/pull/496)
@@ -13,6 +13,7 @@
  * Output pads working in `:pull` mode should have their `demand_unit` specified. If case it's not available, it's assumed that the pad handles demands in both `:bytes` and `:buffers` units.
  * Rename callbacks `handle_process/4` and `handle_write/4` to `handle_buffer/4` in [#506](https://github.com/membraneframework/membrane_core/pull/506)
  * The flow control of the pad is now set with a single `:flow_control` option instead of `:mode` and `:demand_mode` options.
+ * Remove _t suffix from types [#509](https://github.com/membraneframework/membrane_core/pull/509)
 
 ## 0.11.0
  * Separate element_name and pad arguments in handle_element_{start, end}_of_stream signature [#219](https://github.com/membraneframework/membrane_core/issues/219)

guides/upgrading/v0.11.md

@@ -292,7 +292,7 @@ Rename `Membrane.Time.to_<unit name>/1` into `Membrane.Time.round_to_<unit name>
 ```
 
 ## Update the children definitions
-Children defintions syntax (previously known as `ParentSpec`, after the name of a structure used to define children), that was used in `Membrane.Pipeline.Action.spec_t` and `Membrane.Bin.Action.spec_t` actions, has changed. 
+Children definitions syntax (previously known as `ParentSpec`, after the name of a structure used to define children), that was used in `Membrane.Pipeline.Action.spec_t` and `Membrane.Bin.Action.spec_t` actions, has changed. 
 Since there are quite a few changes concerning children definition, we have decided to present them in the subsections below.
 
 ### Update children names

lib/membrane/bin.ex

@@ -20,20 +20,20 @@ defmodule Membrane.Bin do
   require Membrane.Core.Message
   require Membrane.Logger
 
-  @type state_t :: any()
+  @type state :: any()
 
-  @type callback_return_t :: {[Action.t()], state_t()}
+  @type callback_return :: {[Action.t()], state()}
 
   @typedoc """
   Defines options that can be passed to `start_link/3` and received
   in `c:handle_init/2` callback.
   """
-  @type options_t :: struct | nil
+  @type options :: struct | nil
 
   @typedoc """
   Type that defines a bin name by which it is identified.
   """
-  @type name_t :: tuple() | atom()
+  @type name :: tuple() | atom()
 
   @doc """
   Callback invoked on initialization of bin.
@@ -44,8 +44,8 @@ defmodule Membrane.Bin do
   while `handle_init` should be used for things like parsing options, initializing state or
   spawning children.
   """
-  @callback handle_init(context :: CallbackContext.t(), options :: options_t) ::
-              callback_return_t()
+  @callback handle_init(context :: CallbackContext.t(), options :: options) ::
+              callback_return()
 
   @doc """
   Callback that is called when new pad has been added to bin. Executed
@@ -54,10 +54,10 @@ defmodule Membrane.Bin do
   Context passed to this callback contains additional field `:pad_options`.
   """
   @callback handle_pad_added(
-              pad :: Pad.ref_t(),
+              pad :: Pad.ref(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback that is called when some pad of the bin has been removed. Executed
@@ -66,10 +66,10 @@ defmodule Membrane.Bin do
   Context passed to this callback contains additional field `:pad_options`.
   """
   @callback handle_pad_removed(
-              pad :: Pad.ref_t(),
+              pad :: Pad.ref(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked on bin startup, right after `c:handle_init/2`.
@@ -78,36 +78,36 @@ defmodule Membrane.Bin do
   """
   @callback handle_setup(
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when bin switches the playback to `:playing`.
   """
   @callback handle_playing(
               context :: CallbackContext.t(),
-              state :: state_t
+              state :: state
             ) ::
-              callback_return_t
+              callback_return
 
   @doc """
   Callback invoked when a notification comes in from an element.
   """
   @callback handle_child_notification(
               notification :: Membrane.ChildNotification.t(),
-              element :: Child.name_t(),
+              element :: Child.name(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when a notification comes in from an parent.
   """
   @callback handle_parent_notification(
               notification :: Membrane.ParentNotification.t(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when bin receives a message that is not recognized
@@ -118,58 +118,58 @@ defmodule Membrane.Bin do
   @callback handle_info(
               message :: any,
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when a child element starts processing stream via given pad.
   """
   @callback handle_element_start_of_stream(
-              child :: Child.name_t(),
-              pad :: Pad.ref_t(),
+              child :: Child.name(),
+              pad :: Pad.ref(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when a child element finishes processing stream via given pad.
   """
   @callback handle_element_end_of_stream(
-              child :: Child.name_t(),
-              pad :: Pad.ref_t(),
+              child :: Child.name(),
+              pad :: Pad.ref(),
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   Callback invoked when children of `Membrane.ChildrenSpec` are started.
   """
   @callback handle_spec_started(
-              children :: [Child.name_t()],
+              children :: [Child.name()],
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
-  Callback invoked upon each timer tick. A timer can be started with `t:Membrane.Bin.Action.start_timer_t/0`
+  Callback invoked upon each timer tick. A timer can be started with `t:Membrane.Bin.Action.start_timer/0`
   action.
   """
   @callback handle_tick(
               timer_id :: any,
               context :: CallbackContext.t(),
-              state :: state_t
-            ) :: callback_return_t
+              state :: state
+            ) :: callback_return
 
   @doc """
   A callback invoked when the bin is being removed by its parent.
 
-  By default it returns `t:Membrane.Bin.Action.terminate_t/0` with reason `:normal`.
+  By default it returns `t:Membrane.Bin.Action.terminate/0` with reason `:normal`.
   """
   @callback handle_terminate_request(
               context :: CallbackContext.t(),
-              state_t
+              state
             ) ::
-              callback_return_t()
+              callback_return()
 
   @optional_callbacks handle_init: 2,
                       handle_pad_added: 3,

lib/membrane/bin/action.ex

@@ -19,92 +19,92 @@ defmodule Membrane.Bin.Action do
 
   Untils the setup lasts, the component won't enter `:playing` playback.
   """
-  @type setup_t :: {:setup, :incomplete | :complete}
+  @type setup :: {:setup, :incomplete | :complete}
 
   @typedoc """
   Action that sends a message to a child identified by name.
   """
-  @type notify_child_t ::
-          {:notify_child, {Child.name_t(), Membrane.ParentNotification.t()}}
+  @type notify_child ::
+          {:notify_child, {Child.name(), Membrane.ParentNotification.t()}}
 
   @typedoc """
   Sends a message to the parent.
   """
-  @type notify_parent_t :: {:notify_parent, Membrane.ChildNotification.t()}
+  @type notify_parent :: {:notify_parent, Membrane.ChildNotification.t()}
 
   @typedoc """
   Action that instantiates children and links them according to `Membrane.ChildrenSpec`.
 
   Children's playback is changed to the current bin playback.
   `c:Membrane.Parent.handle_spec_started/3` callback is executed once the children are spawned.
   """
-  @type spec_t :: {:spec, ChildrenSpec.t()}
+  @type spec :: {:spec, ChildrenSpec.t()}
 
   @typedoc """
   Action that stops, unlinks and removes specified child/children from the bin.
 
   A child ref, list of children refs, children group id or a list of children group ids can be specified
   as an argument. In case you need to refer to a single child from a children group, use `Membrane.Child.ref/2`.
   """
-  @type remove_children_t ::
+  @type remove_children ::
           {:remove_children,
-           Child.ref_t()
-           | [Child.ref_t()]
-           | Membrane.Child.group_t()
-           | [Membrane.Child.group_t()]}
+           Child.ref()
+           | [Child.ref()]
+           | Membrane.Child.group()
+           | [Membrane.Child.group()]}
 
   @typedoc """
   Action that removes link, which relates to specified child and pad.
 
   Removed link has to have dynamic pads on both ends.
   """
-  @type remove_link_t :: {:remove_link, {Child.name_t(), Pad.ref_t()}}
+  @type remove_link :: {:remove_link, {Child.name(), Pad.ref()}}
 
   @typedoc """
   Starts a timer that will invoke `c:Membrane.Bin.handle_tick/3` callback
   every `interval` according to the given `clock`.
 
   The timer's `id` is passed to the `c:Membrane.Bin.handle_tick/3`
-  callback and can be used for changing its interval via `t:timer_interval_t/0`
-  or stopping it via `t:stop_timer_t/0`.
+  callback and can be used for changing its interval via `t:timer_interval/0`
+  or stopping it via `t:stop_timer/0`.
 
   If `interval` is set to `:no_interval`, the timer won't issue any ticks until
-  the interval is set with `t:timer_interval_t/0` action.
+  the interval is set with `t:timer_interval/0` action.
 
   If no `clock` is passed, parent clock is chosen.
 
   Timers use `Process.send_after/3` under the hood.
   """
-  @type start_timer_t ::
+  @type start_timer ::
           {:start_timer,
-           {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg_t() | :no_interval}
-           | {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg_t() | :no_interval,
+           {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg() | :no_interval}
+           | {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg() | :no_interval,
               clock :: Membrane.Clock.t()}}
 
   @typedoc """
-  Changes interval of a timer started with `t:start_timer_t/0`.
+  Changes interval of a timer started with `t:start_timer/0`.
 
   Permitted only from `c:Membrane.Bin.handle_tick/3`, unless the interval
   was previously set to `:no_interval`.
 
   If the `interval` is `:no_interval`, the timer won't issue any ticks until
-  another `t:timer_interval_t/0` action. Otherwise, the timer will issue ticks every
+  another `t:timer_interval/0` action. Otherwise, the timer will issue ticks every
   new `interval`. The next tick after interval change is scheduled at
   `new_interval + previous_time`, where previous_time is the time of the latest
-  tick or the time of returning `t:start_timer_t/0` action if no tick has been
+  tick or the time of returning `t:start_timer/0` action if no tick has been
   sent yet. Note that if `current_time - previous_time > new_interval`, a burst
   of `div(current_time - previous_time, new_interval)` ticks is issued immediately.
   """
-  @type timer_interval_t ::
+  @type timer_interval ::
           {:timer_interval,
-           {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg_t() | :no_interval}}
+           {timer_id :: any, interval :: Ratio.t() | Membrane.Time.non_neg() | :no_interval}}
 
   @typedoc """
-  Stops a timer started with `t:start_timer_t/0` action.
+  Stops a timer started with `t:start_timer/0` action.
 
   This action is atomic: stopping timer guarantees that no ticks will arrive from it.
   """
-  @type stop_timer_t :: {:stop_timer, timer_id :: any}
+  @type stop_timer :: {:stop_timer, timer_id :: any}
 
   @typedoc """
   Terminates bin with given reason.
@@ -120,7 +120,7 @@ defmodule Membrane.Bin.Action do
   terminates all the children with the reason `:shutdown`
   - If the reason is neither `:normal`, `:shutdown` nor `{:shutdown, term}`, an error is logged
   """
-  @type terminate_t :: {:terminate, reason :: :normal | :shutdown | {:shutdown, term} | term}
+  @type terminate :: {:terminate, reason :: :normal | :shutdown | {:shutdown, term} | term}
 
   @typedoc """
   Type describing actions that can be returned from bin callbacks.
@@ -129,14 +129,14 @@ defmodule Membrane.Bin.Action do
   other parts of framework.
   """
   @type t ::
-          setup_t
-          | notify_child_t
-          | notify_parent_t
-          | spec_t
-          | remove_children_t
-          | remove_link_t
-          | start_timer_t
-          | timer_interval_t
-          | stop_timer_t
-          | terminate_t
+          setup
+          | notify_child
+          | notify_parent
+          | spec
+          | remove_children
+          | remove_link
+          | start_timer
+          | timer_interval
+          | stop_timer
+          | terminate
 end

lib/membrane/bin/callback_context.ex

@@ -12,9 +12,9 @@ defmodule Membrane.Bin.CallbackContext do
   @type t :: %{
           :clock => Membrane.Clock.t(),
           :parent_clock => Membrane.Clock.t(),
-          :pads => %{Membrane.Pad.ref_t() => Membrane.Bin.PadData.t()},
-          :name => Membrane.Bin.name_t(),
-          :children => %{Membrane.Child.name_t() => Membrane.ChildEntry.t()},
+          :pads => %{Membrane.Pad.ref() => Membrane.Bin.PadData.t()},
+          :name => Membrane.Bin.name(),
+          :children => %{Membrane.Child.name() => Membrane.ChildEntry.t()},
           :playback => Membrane.Playback.t(),
           :resource_guard => Membrane.ResourceGuard.t(),
           :utility_supervisor => Membrane.UtilitySupervisor.t(),