me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Unify Program definition in iced_program subcrate

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2025-03-12 02:10:42 +01:00
parent ebfcb65841
commit fd1101bd5f
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
66 changed files with 1862 additions and 1935 deletions
Download patch file Download diff file Expand all files Collapse all files

80
src/application.rs
View file

@ -6,7 +6,7 @@
//! use iced::Theme;
//!
//! pub fn main() -> iced::Result {
//! iced::application("A counter", update, view)
//! iced::application(u64::default, update, view)
//! .theme(|_| Theme::Dark)
//! .centered()
//! .run()
@ -31,6 +31,7 @@
//! }
//! ```
use crate::program::{self, Program};
use crate::shell;
use crate::theme;
use crate::window;
use crate::{
@ -39,14 +40,14 @@ use crate::{
use std::borrow::Cow;
/// Creates an iced [`Application`] given its title, update, and view logic.
/// Creates an iced [`Application`] given its update and view logic.
///
/// # Example
/// ```no_run
/// use iced::widget::{button, column, text, Column};
///
/// pub fn main() -> iced::Result {
/// iced::application("A counter", update, view).run()
/// iced::application(u64::default, update, view).run()
/// }
///
/// #[derive(Debug, Clone)]
@ -68,7 +69,7 @@ use std::borrow::Cow;
/// }
/// ```
pub fn application<State, Message, Theme, Renderer>(
title: impl Title<State>,
new: impl New<State, Message>,
update: impl Update<State, Message>,
view: impl for<'a> self::View<'a, State, Message, Theme, Renderer>,
) -> Application<impl Program<State = State, Message = Message, Theme = Theme>>
@ -80,7 +81,8 @@ where
{
use std::marker::PhantomData;
struct Instance<State, Message, Theme, Renderer, Update, View> {
struct Instance<State, Message, Theme, Renderer, New, Update, View> {
new: New,
update: Update,
view: View,
_state: PhantomData<State>,
@ -89,12 +91,13 @@ where
_renderer: PhantomData<Renderer>,
}
impl<State, Message, Theme, Renderer, Update, View> Program
for Instance<State, Message, Theme, Renderer, Update, View>
impl<State, Message, Theme, Renderer, New, Update, View> Program
for Instance<State, Message, Theme, Renderer, New, Update, View>
where
Message: Send + std::fmt::Debug + 'static,
Theme: Default + theme::Base,
Renderer: program::Renderer,
New: self::New<State, Message>,
Update: self::Update<State, Message>,
View: for<'a> self::View<'a, State, Message, Theme, Renderer>,
{
@ -104,6 +107,16 @@ where
type Renderer = Renderer;
type Executor = iced_futures::backend::default::Executor;
fn name() -> &'static str {
let name = std::any::type_name::<State>();
name.split("::").next().unwrap_or("a_cool_application")
}
fn boot(&self) -> (State, Task<Message>) {
self.new.new()
}
fn update(
&self,
state: &mut Self::State,
@ -123,6 +136,7 @@ where
Application {
raw: Instance {
new,
update,
view,
_state: PhantomData,
@ -133,7 +147,6 @@ where
settings: Settings::default(),
window: window::Settings::default(),
}
.title(title)
}
/// The underlying definition and configuration of an iced application.
@ -161,19 +174,8 @@ impl<P: Program> Application<P> {
pub fn run(self) -> Result
where
Self: 'static,
P::State: Default,
{
self.raw.run(self.settings, Some(self.window))
}
/// Runs the [`Application`] with a closure that creates the initial state.
pub fn run_with<I>(self, initialize: I) -> Result
where
Self: 'static,
I: FnOnce() -> (P::State, Task<P::Message>) + 'static,
{
self.raw
.run_with(self.settings, Some(self.window), initialize)
Ok(shell::run(self.raw, self.settings, Some(self.window))?)
}
/// Sets the [`Settings`] that will be used to run the [`Application`].
@ -305,7 +307,7 @@ impl<P: Program> Application<P> {
}
/// Sets the [`Title`] of the [`Application`].
pub(crate) fn title(
pub fn title(
self,
title: impl Title<P::State>,
) -> Application<
@ -395,6 +397,42 @@ impl<P: Program> Application<P> {
}
}
/// The logic to initialize the `State` of some [`Application`].
pub trait New<State, Message> {
/// Initializes the [`Application`] state.
#[allow(clippy::new_ret_no_self)]
#[allow(clippy::wrong_self_convention)]
fn new(&self) -> (State, Task<Message>);
}
impl<T, C, State, Message> New<State, Message> for T
where
T: Fn() -> C,
C: IntoState<State, Message>,
{
fn new(&self) -> (State, Task<Message>) {
self().into_state()
}
}
/// TODO
pub trait IntoState<State, Message> {
/// TODO
fn into_state(self) -> (State, Task<Message>);
}
impl<State, Message> IntoState<State, Message> for State {
fn into_state(self) -> (State, Task<Message>) {
(self, Task::none())
}
}
impl<State, Message> IntoState<State, Message> for (State, Task<Message>) {
fn into_state(self) -> (State, Task<Message>) {
self
}
}
/// The title logic of some [`Application`].
///
/// This trait is implemented both for `&static str` and

37
src/daemon.rs
View file

@ -1,6 +1,7 @@
//! Create and run daemons that run in the background.
use crate::application;
use crate::program::{self, Program};
use crate::shell;
use crate::theme;
use crate::window;
use crate::{Element, Executor, Font, Result, Settings, Subscription, Task};
@ -18,7 +19,7 @@ use std::borrow::Cow;
///
/// [`exit`]: crate::exit
pub fn daemon<State, Message, Theme, Renderer>(
title: impl Title<State>,
boot: impl application::New<State, Message>,
update: impl application::Update<State, Message>,
view: impl for<'a> self::View<'a, State, Message, Theme, Renderer>,
) -> Daemon<impl Program<State = State, Message = Message, Theme = Theme>>
@ -30,7 +31,8 @@ where
{
use std::marker::PhantomData;
struct Instance<State, Message, Theme, Renderer, Update, View> {
struct Instance<State, Message, Theme, Renderer, Boot, Update, View> {
boot: Boot,
update: Update,
view: View,
_state: PhantomData<State>,
@ -39,12 +41,13 @@ where
_renderer: PhantomData<Renderer>,
}
impl<State, Message, Theme, Renderer, Update, View> Program
for Instance<State, Message, Theme, Renderer, Update, View>
impl<State, Message, Theme, Renderer, Boot, Update, View> Program
for Instance<State, Message, Theme, Renderer, Boot, Update, View>
where
Message: Send + std::fmt::Debug + 'static,
Theme: Default + theme::Base,
Renderer: program::Renderer,
Boot: application::New<State, Message>,
Update: application::Update<State, Message>,
View: for<'a> self::View<'a, State, Message, Theme, Renderer>,
{
@ -54,6 +57,16 @@ where
type Renderer = Renderer;
type Executor = iced_futures::backend::default::Executor;
fn name() -> &'static str {
let name = std::any::type_name::<State>();
name.split("::").next().unwrap_or("a_cool_daemon")
}
fn boot(&self) -> (Self::State, Task<Self::Message>) {
self.boot.new()
}
fn update(
&self,
state: &mut Self::State,
@ -73,6 +86,7 @@ where
Daemon {
raw: Instance {
boot,
update,
view,
_state: PhantomData,
@ -82,7 +96,6 @@ where
},
settings: Settings::default(),
}
.title(title)
}
/// The underlying definition and configuration of an iced daemon.
@ -109,18 +122,8 @@ impl<P: Program> Daemon<P> {
pub fn run(self) -> Result
where
Self: 'static,
P::State: Default,
{
self.raw.run(self.settings, None)
}
/// Runs the [`Daemon`] with a closure that creates the initial state.
pub fn run_with<I>(self, initialize: I) -> Result
where
Self: 'static,
I: FnOnce() -> (P::State, Task<P::Message>) + 'static,
{
self.raw.run_with(self.settings, None, initialize)
Ok(shell::run(self.raw, self.settings, None)?)
}
/// Sets the [`Settings`] that will be used to run the [`Daemon`].
@ -157,7 +160,7 @@ impl<P: Program> Daemon<P> {
}
/// Sets the [`Title`] of the [`Daemon`].
pub(crate) fn title(
pub fn title(
self,
title: impl Title<P::State>,
) -> Daemon<

21
src/lib.rs
View file

@ -31,7 +31,7 @@
//!
//! ```rust,no_run
//! pub fn main() -> iced::Result {
//! iced::run("A cool counter", update, view)
//! iced::run(update, view)
//! }
//! # fn update(state: &mut (), message: ()) {}
//! # fn view(state: &()) -> iced::Element<()> { iced::widget::text("").into() }
@ -198,16 +198,20 @@
//! calling [`run`]:
//!
//! ```rust,no_run
//! # #[derive(Default)]
//! # struct State;
//! use iced::Theme;
//!
//! pub fn main() -> iced::Result {
//! iced::application("A cool application", update, view)
//! iced::application(new, update, view)
//! .theme(theme)
//! .run()
//! }
//!
//! fn new() -> State {
//! // ...
//! # State
//! }
//!
//! fn theme(state: &State) -> Theme {
//! Theme::TokyoNight
//! }
@ -335,7 +339,6 @@
//! You will need to define a `subscription` function and use the [`Application`] builder:
//!
//! ```rust,no_run
//! # #[derive(Default)]
//! # struct State;
//! use iced::window;
//! use iced::{Size, Subscription};
@ -346,7 +349,7 @@
//! }
//!
//! pub fn main() -> iced::Result {
//! iced::application("A cool application", update, view)
//! iced::application(new, update, view)
//! .subscription(subscription)
//! .run()
//! }
@ -354,6 +357,7 @@
//! fn subscription(state: &State) -> Subscription<Message> {
//! window::resize_events().map(|(_id, size)| Message::WindowResized(size))
//! }
//! # fn new() -> State { State }
//! # fn update(state: &mut State, message: Message) {}
//! # fn view(state: &State) -> iced::Element<Message> { iced::widget::text("").into() }
//! ```
@ -475,6 +479,7 @@ use iced_widget::graphics;
use iced_widget::renderer;
use iced_winit as shell;
use iced_winit::core;
use iced_winit::program;
use iced_winit::runtime;
pub use iced_futures::futures;
@ -487,7 +492,6 @@ pub use iced_highlighter as highlighter;
pub use iced_renderer::wgpu::wgpu;
mod error;
mod program;
pub mod application;
pub mod daemon;
@ -658,7 +662,7 @@ pub type Result = std::result::Result<(), Error>;
/// use iced::widget::{button, column, text, Column};
///
/// pub fn main() -> iced::Result {
/// iced::run("A counter", update, view)
/// iced::run(update, view)
/// }
///
/// #[derive(Debug, Clone)]
@ -680,7 +684,6 @@ pub type Result = std::result::Result<(), Error>;
/// }
/// ```
pub fn run<State, Message, Theme, Renderer>(
title: impl application::Title<State> + 'static,
update: impl application::Update<State, Message> + 'static,
view: impl for<'a> application::View<'a, State, Message, Theme, Renderer>
+ 'static,
@ -691,5 +694,5 @@ where
Theme: Default + theme::Base + 'static,
Renderer: program::Renderer + 'static,
{
application(title, update, view).run()
application(State::default, update, view).run()
}

633
src/program.rs
View file

@ -1,633 +0,0 @@
use crate::core::text;
use crate::graphics::compositor;
use crate::shell;
use crate::theme;
use crate::window;
use crate::{Element, Executor, Result, Settings, Subscription, Task};
/// The internal definition of a [`Program`].
///
/// You should not need to implement this trait directly. Instead, use the
/// methods available in the [`Program`] struct.
#[allow(missing_docs)]
pub trait Program: Sized {
/// The state of the program.
type State;
/// The message of the program.
type Message: Send + std::fmt::Debug + 'static;
/// The theme of the program.
type Theme: Default + theme::Base;
/// The renderer of the program.
type Renderer: Renderer;
/// The executor of the program.
type Executor: Executor;
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message>;
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer>;
fn title(&self, _state: &Self::State, _window: window::Id) -> String {
String::from("A cool iced application!")
}
fn subscription(
&self,
_state: &Self::State,
) -> Subscription<Self::Message> {
Subscription::none()
}
fn theme(&self, _state: &Self::State, _window: window::Id) -> Self::Theme {
<Self::Theme as Default>::default()
}
fn style(&self, _state: &Self::State, theme: &Self::Theme) -> theme::Style {
theme::Base::base(theme)
}
fn scale_factor(&self, _state: &Self::State, _window: window::Id) -> f64 {
1.0
}
/// Runs the [`Program`].
///
/// The state of the [`Program`] must implement [`Default`].
/// If your state does not implement [`Default`], use [`run_with`]
/// instead.
///
/// [`run_with`]: Self::run_with
fn run(
self,
settings: Settings,
window_settings: Option<window::Settings>,
) -> Result
where
Self: 'static,
Self::State: Default,
{
self.run_with(settings, window_settings, || {
(Self::State::default(), Task::none())
})
}
/// Runs the [`Program`] with the given [`Settings`] and a closure that creates the initial state.
fn run_with<I>(
self,
settings: Settings,
window_settings: Option<window::Settings>,
initialize: I,
) -> Result
where
Self: 'static,
I: FnOnce() -> (Self::State, Task<Self::Message>) + 'static,
{
use std::marker::PhantomData;
struct Instance<P: Program, I> {
program: P,
state: P::State,
_initialize: PhantomData<I>,
}
impl<P: Program, I: FnOnce() -> (P::State, Task<P::Message>)>
shell::Program for Instance<P, I>
{
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Flags = (P, I);
type Executor = P::Executor;
fn name() -> &'static str {
std::any::type_name::<P::State>()
}
fn new(
(program, initialize): Self::Flags,
) -> (Self, Task<Self::Message>) {
let (state, task) = initialize();
(
Self {
program,
state,
_initialize: PhantomData,
},
task,
)
}
fn title(&self, window: window::Id) -> String {
self.program.title(&self.state, window)
}
fn update(
&mut self,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(&mut self.state, message)
}
fn view(
&self,
window: window::Id,
) -> crate::Element<'_, Self::Message, Self::Theme, Self::Renderer>
{
self.program.view(&self.state, window)
}
fn subscription(&self) -> Subscription<Self::Message> {
self.program.subscription(&self.state)
}
fn theme(&self, window: window::Id) -> Self::Theme {
self.program.theme(&self.state, window)
}
fn style(&self, theme: &Self::Theme) -> theme::Style {
self.program.style(&self.state, theme)
}
fn scale_factor(&self, window: window::Id) -> f64 {
self.program.scale_factor(&self.state, window)
}
}
#[allow(clippy::needless_update)]
let renderer_settings = crate::graphics::Settings {
default_font: settings.default_font,
default_text_size: settings.default_text_size,
antialiasing: if settings.antialiasing {
Some(crate::graphics::Antialiasing::MSAAx4)
} else {
None
},
..crate::graphics::Settings::default()
};
Ok(shell::program::run::<
Instance<Self, I>,
<Self::Renderer as compositor::Default>::Compositor,
>(
Settings {
id: settings.id,
fonts: settings.fonts,
default_font: settings.default_font,
default_text_size: settings.default_text_size,
antialiasing: settings.antialiasing,
}
.into(),
renderer_settings,
window_settings,
(self, initialize),
)?)
}
}
pub fn with_title<P: Program>(
program: P,
title: impl Fn(&P::State, window::Id) -> String,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
struct WithTitle<P, Title> {
program: P,
title: Title,
}
impl<P, Title> Program for WithTitle<P, Title>
where
P: Program,
Title: Fn(&P::State, window::Id) -> String,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = P::Executor;
fn title(&self, state: &Self::State, window: window::Id) -> String {
(self.title)(state, window)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
self.program.theme(state, window)
}
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
self.program.subscription(state)
}
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
self.program.style(state, theme)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
self.program.scale_factor(state, window)
}
}
WithTitle { program, title }
}
pub fn with_subscription<P: Program>(
program: P,
f: impl Fn(&P::State) -> Subscription<P::Message>,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
struct WithSubscription<P, F> {
program: P,
subscription: F,
}
impl<P: Program, F> Program for WithSubscription<P, F>
where
F: Fn(&P::State) -> Subscription<P::Message>,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = P::Executor;
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
(self.subscription)(state)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn title(&self, state: &Self::State, window: window::Id) -> String {
self.program.title(state, window)
}
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
self.program.theme(state, window)
}
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
self.program.style(state, theme)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
self.program.scale_factor(state, window)
}
}
WithSubscription {
program,
subscription: f,
}
}
pub fn with_theme<P: Program>(
program: P,
f: impl Fn(&P::State, window::Id) -> P::Theme,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
struct WithTheme<P, F> {
program: P,
theme: F,
}
impl<P: Program, F> Program for WithTheme<P, F>
where
F: Fn(&P::State, window::Id) -> P::Theme,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = P::Executor;
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
(self.theme)(state, window)
}
fn title(&self, state: &Self::State, window: window::Id) -> String {
self.program.title(state, window)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
self.program.subscription(state)
}
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
self.program.style(state, theme)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
self.program.scale_factor(state, window)
}
}
WithTheme { program, theme: f }
}
pub fn with_style<P: Program>(
program: P,
f: impl Fn(&P::State, &P::Theme) -> theme::Style,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
struct WithStyle<P, F> {
program: P,
style: F,
}
impl<P: Program, F> Program for WithStyle<P, F>
where
F: Fn(&P::State, &P::Theme) -> theme::Style,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = P::Executor;
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
(self.style)(state, theme)
}
fn title(&self, state: &Self::State, window: window::Id) -> String {
self.program.title(state, window)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
self.program.subscription(state)
}
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
self.program.theme(state, window)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
self.program.scale_factor(state, window)
}
}
WithStyle { program, style: f }
}
pub fn with_scale_factor<P: Program>(
program: P,
f: impl Fn(&P::State, window::Id) -> f64,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
struct WithScaleFactor<P, F> {
program: P,
scale_factor: F,
}
impl<P: Program, F> Program for WithScaleFactor<P, F>
where
F: Fn(&P::State, window::Id) -> f64,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = P::Executor;
fn title(&self, state: &Self::State, window: window::Id) -> String {
self.program.title(state, window)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
self.program.subscription(state)
}
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
self.program.theme(state, window)
}
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
self.program.style(state, theme)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
(self.scale_factor)(state, window)
}
}
WithScaleFactor {
program,
scale_factor: f,
}
}
pub fn with_executor<P: Program, E: Executor>(
program: P,
) -> impl Program<State = P::State, Message = P::Message, Theme = P::Theme> {
use std::marker::PhantomData;
struct WithExecutor<P, E> {
program: P,
executor: PhantomData<E>,
}
impl<P: Program, E> Program for WithExecutor<P, E>
where
E: Executor,
{
type State = P::State;
type Message = P::Message;
type Theme = P::Theme;
type Renderer = P::Renderer;
type Executor = E;
fn title(&self, state: &Self::State, window: window::Id) -> String {
self.program.title(state, window)
}
fn update(
&self,
state: &mut Self::State,
message: Self::Message,
) -> Task<Self::Message> {
self.program.update(state, message)
}
fn view<'a>(
&self,
state: &'a Self::State,
window: window::Id,
) -> Element<'a, Self::Message, Self::Theme, Self::Renderer> {
self.program.view(state, window)
}
fn subscription(
&self,
state: &Self::State,
) -> Subscription<Self::Message> {
self.program.subscription(state)
}
fn theme(
&self,
state: &Self::State,
window: window::Id,
) -> Self::Theme {
self.program.theme(state, window)
}
fn style(
&self,
state: &Self::State,
theme: &Self::Theme,
) -> theme::Style {
self.program.style(state, theme)
}
fn scale_factor(&self, state: &Self::State, window: window::Id) -> f64 {
self.program.scale_factor(state, window)
}
}
WithExecutor {
program,
executor: PhantomData::<E>,
}
}
/// The renderer of some [`Program`].
pub trait Renderer: text::Renderer + compositor::Default {}
impl<T> Renderer for T where T: text::Renderer + compositor::Default {}