SYMBOL INDEX (330 symbols across 26 files)

FILE: examples/counter.rs
  type Counter (line 8) | struct Counter {
  method compose (line 13) | fn compose(cx: Scope<Self>) -> impl Compose {
  function setup (line 31) | fn setup(mut commands: Commands) {
  function main (line 45) | fn main() {

FILE: examples/http.rs
  type Breed (line 10) | struct Breed {
  method compose (line 16) | fn compose(cx: Scope<Self>) -> impl Compose {
  type Response (line 27) | struct Response {
  type BreedList (line 33) | struct BreedList;
  method compose (line 36) | fn compose(cx: Scope<Self>) -> impl Compose {
  type Example (line 65) | struct Example;
  method compose (line 68) | fn compose(cx: Scope<Self>) -> impl Compose {
  function main (line 76) | fn main() {
  function setup (line 84) | fn setup(mut commands: Commands) {

FILE: examples/radio_button.rs
  type Example (line 8) | struct Example;
  method compose (line 11) | fn compose(cx: Scope<Self>) -> impl Compose {
  function setup (line 20) | fn setup(mut commands: Commands) {
  function main (line 35) | fn main() {

FILE: examples/timer.rs
  type Timer (line 8) | struct Timer;
  method compose (line 11) | fn compose(cx: Scope<Self>) -> impl Compose {
  function main (line 24) | fn main() {
  function setup (line 31) | fn setup(mut commands: Commands) {

FILE: macros/src/lib.rs
  function derive_data (line 9) | pub fn derive_data(input: TokenStream) -> TokenStream {
  function data (line 86) | pub fn data(_attrs: TokenStream, input: TokenStream) -> TokenStream {

FILE: src/animation.rs
  type State (line 16) | struct State<T> {
  function use_animated (line 24) | pub fn use_animated<T>(cx: ScopeState<'_>, make_initial: impl FnOnce() -...
  type UseAnimated (line 88) | pub struct UseAnimated<'a, T> {
  function animate (line 95) | pub async fn animate(&self, to: T, duration: Duration) {
  function controller (line 100) | pub fn controller(&self) -> AnimationController<T> {
  method clone (line 106) | fn clone(&self) -> Self {
  type Target (line 114) | type Target = T;
  method deref (line 116) | fn deref(&self) -> &Self::Target {
  type AnimationController (line 124) | pub struct AnimationController<T> {
  function animate (line 130) | pub async fn animate(&self, to: T, duration: Duration) {
  method clone (line 138) | fn clone(&self) -> Self {

FILE: src/compose/catch.rs
  function catch (line 42) | pub fn catch<'a, C: Compose>(
  type Catch (line 57) | pub struct Catch<'a, C> {
  method compose (line 66) | fn compose(cx: Scope<Self>) -> impl Compose {

FILE: src/compose/dyn_compose.rs
  function dyn_compose (line 53) | pub fn dyn_compose<'a>(content: impl Compose + 'a) -> DynCompose<'a> {
  type DynCompose (line 61) | pub struct DynCompose<'a> {
  type DynComposeState (line 66) | struct DynComposeState {
  method compose (line 72) | fn compose(cx: Scope<Self>) -> impl Compose {

FILE: src/compose/from_fn.rs
  function from_fn (line 33) | pub fn from_fn<F, C>(f: F) -> FromFn<F, C>
  type FromFn (line 47) | pub struct FromFn<F, C> {
  method clone (line 53) | fn clone(&self) -> Self {
  method compose (line 73) | fn compose(cx: Scope<Self>) -> impl Compose {

FILE: src/compose/from_iter.rs
  function from_iter (line 36) | pub fn from_iter<'a, I, C>(
  type FromIter (line 55) | pub struct FromIter<'a, I, Item, C> {
  method clone (line 65) | fn clone(&self) -> Self {
  method compose (line 87) | fn compose(cx: Scope<Self>) -> impl Compose {
  type ItemState (line 152) | struct ItemState<T> {

FILE: src/compose/memo.rs
  function memo (line 11) | pub fn memo<D, C>(dependency: D, content: C) -> Memo<D, C>
  type Memo (line 28) | pub struct Memo<T, C> {
  method compose (line 38) | fn compose(cx: Scope<Self>) -> impl Compose {
  method name (line 61) | fn name() -> Option<Cow<'static, str>> {

FILE: src/compose/mod.rs
  type Compose (line 49) | pub trait Compose: Data {
    method compose (line 51) | fn compose(cx: Scope<Self>) -> impl Compose;
    method name (line 54) | fn name() -> Option<Cow<'static, str>> {
    method compose (line 69) | fn compose(cx: Scope<Self>) -> impl Compose {
    method compose (line 75) | fn compose(cx: Scope<Self>) -> impl Compose {
    method compose (line 180) | fn compose(cx: Scope<Self>) -> impl Compose {
    method compose (line 293) | fn compose(cx: Scope<Self>) -> impl Compose {
  function drop_node (line 134) | fn drop_node(nodes: &mut SlotMap<DefaultKey, Rc<Node>>, key: DefaultKey) {
  type Error (line 154) | pub struct Error {
    method new (line 160) | pub fn new(error: impl core::error::Error + Clone + 'static) -> Self {
    method fmt (line 168) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 174) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type CatchContext (line 248) | pub(crate) struct CatchContext {
    method new (line 253) | pub(crate) fn new(f: impl Fn(Box<dyn core::error::Error>) + 'static) -...
  function use_node (line 305) | fn use_node(
  type AnyCompose (line 350) | pub(crate) trait AnyCompose {
    method data_id (line 351) | fn data_id(&self) -> TypeId;
    method as_ptr_mut (line 353) | fn as_ptr_mut(&mut self) -> *mut ();
    method reborrow (line 355) | unsafe fn reborrow(&mut self, ptr: *mut ());
    method any_compose (line 358) | unsafe fn any_compose(&self, state: &ScopeData);
    method name (line 360) | fn name(&self) -> Option<Cow<'static, str>>;
    method data_id (line 367) | fn data_id(&self) -> TypeId {
    method as_ptr_mut (line 371) | fn as_ptr_mut(&mut self) -> *mut () {
    method reborrow (line 375) | unsafe fn reborrow(&mut self, ptr: *mut ()) {
    method any_compose (line 379) | unsafe fn any_compose(&self, state: &ScopeData) {
    method name (line 456) | fn name(&self) -> Option<Cow<'static, str>> {

FILE: src/composer.rs
  type RuntimeFuture (line 23) | type RuntimeFuture = Pin<Box<dyn Future<Output = ()>>>;
  type ComposePtr (line 25) | pub(crate) enum ComposePtr {
  method data_id (line 31) | fn data_id(&self) -> TypeId {
  method as_ptr_mut (line 38) | fn as_ptr_mut(&mut self) -> *mut () {
  method reborrow (line 45) | unsafe fn reborrow(&mut self, ptr: *mut ()) {
  method any_compose (line 52) | unsafe fn any_compose(&self, state: &ScopeData) {
  method name (line 59) | fn name(&self) -> Option<std::borrow::Cow<'static, str>> {
  type Node (line 68) | pub(crate) struct Node {
  type Runtime (line 78) | pub(crate) struct Runtime {
    method current (line 108) | pub fn current() -> Self {
    method enter (line 119) | pub fn enter(&self) {
    method update (line 126) | pub fn update(&self, f: impl FnOnce() + Send + 'static) {
    method pending (line 145) | pub fn pending(&self, key: DefaultKey) -> Pending {
    method queue (line 162) | pub fn queue(&self, key: DefaultKey) {
  type TaskWaker (line 172) | struct TaskWaker {
  method wake (line 179) | fn wake(self: Arc<Self>) {
  type TryComposeError (line 189) | pub enum TryComposeError {
  method eq (line 198) | fn eq(&self, other: &Self) -> bool {
  type Pending (line 204) | pub(crate) struct Pending {
  method partial_cmp (line 210) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 216) | fn cmp(&self, other: &Self) -> Ordering {
  type Composer (line 262) | pub struct Composer {
    method new (line 271) | pub fn new(content: impl Compose + 'static) -> Self {
    method try_compose (line 307) | pub fn try_compose(&mut self) -> Result<(), TryComposeError> {
    method poll_compose (line 324) | pub fn poll_compose(&mut self, cx: &mut Context) -> Poll<Result<(), Bo...
    method compose (line 335) | pub async fn compose(&mut self) -> Result<(), Box<dyn Error>> {
    method fmt (line 417) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method drop (line 341) | fn drop(&mut self) {
  function drop_recursive (line 347) | fn drop_recursive(rt: &Runtime, key: DefaultKey, node: Rc<Node>) {
  type Item (line 358) | type Item = Result<(), Box<dyn Error>>;
  method next (line 360) | fn next(&mut self) -> Option<Self::Item> {
  type Field (line 426) | struct Field<'a> {
  function fmt (line 433) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function dbg_composer (line 444) | fn dbg_composer(

FILE: src/data.rs
  type Data (line 72) | pub unsafe trait Data {}
  type FieldWrap (line 126) | pub struct FieldWrap<T>(pub T);
  type FnField (line 129) | pub unsafe trait FnField<Marker> {
    method check (line 130) | fn check(&self) {
  type DataField (line 154) | pub unsafe trait DataField {
    method check (line 155) | fn check(&self) {
  type StaticField (line 163) | pub unsafe trait StaticField {
    method check (line 164) | fn check(&self) {

FILE: src/ecs/mod.rs
  type ActuatePlugin (line 52) | pub struct ActuatePlugin;
  method build (line 55) | fn build(&self, app: &mut App) {
  type UpdateFn (line 65) | type UpdateFn = Box<dyn FnMut(&mut World)>;
  type WorldListenerFn (line 67) | type WorldListenerFn = Rc<dyn Fn(&mut World)>;
  type Inner (line 69) | struct Inner {
  type RuntimeContext (line 77) | struct RuntimeContext {
    method current (line 82) | fn current() -> Self {
    method world_mut (line 92) | unsafe fn world_mut(&self) -> &'static mut World {
  type RuntimeComposer (line 101) | struct RuntimeComposer {
  type Runtime (line 105) | struct Runtime {
  type Composition (line 110) | pub struct Composition<C> {
  function new (line 120) | pub fn new(content: C) -> Self {
  function target (line 130) | pub fn target(&self) -> Option<Entity> {
  function set_target (line 137) | pub fn set_target(&mut self, target: Option<Entity>) {
  function with_target (line 144) | pub fn with_target(mut self, target: Entity) -> Self {
  constant STORAGE_TYPE (line 154) | const STORAGE_TYPE: StorageType = StorageType::SparseSet;
  type Mutability (line 156) | type Mutability = Mutable;
  method on_insert (line 158) | fn on_insert() -> Option<bevy_ecs::lifecycle::ComponentHook> {
  type CompositionContent (line 181) | struct CompositionContent<C> {
  method compose (line 187) | fn compose(cx: Scope<Self>) -> impl Compose {
  type RuntimeWaker (line 197) | struct RuntimeWaker {
  method wake (line 202) | fn wake(self: Arc<Self>) {
  function compose (line 207) | fn compose(world: &mut World) {
  type SystemParamFunction (line 260) | pub trait SystemParamFunction<Marker> {
    method run (line 271) | fn run(&mut self, input: Self::In, param_value: SystemParamItem<Self::...
  type Wrap (line 275) | pub struct Wrap<T>(T);
  function use_world (line 385) | pub fn use_world<'a, Marker, F>(cx: ScopeState<'a>, mut with_world: F)
  type SystemParamFunctionOnce (line 427) | pub trait SystemParamFunctionOnce<Marker> {
    method run (line 435) | fn run(self, param: <Self::Param as SystemParam>::Item<'_, '_>) -> Sel...
  function use_world_once (line 459) | pub fn use_world_once<Marker, F>(cx: ScopeState<'_>, with_world: F) -> &...
  type UseCommands (line 475) | pub struct UseCommands {
    method push (line 481) | pub fn push<C>(&mut self, command: C)
  function use_commands (line 490) | pub fn use_commands(cx: ScopeState<'_>) -> &UseCommands {
  type SpawnContext (line 497) | struct SpawnContext {
  function use_bundle (line 505) | pub fn use_bundle<B: Bundle>(cx: ScopeState<'_>, make_bundle: impl FnOnc...
  function use_bundle_inner (line 516) | fn use_bundle_inner(
  type Modifier (line 544) | pub struct Modifier<'a> {
  function apply (line 550) | pub fn apply(&self, spawn: Spawn<'a>) -> Spawn<'a> {
  function append (line 557) | pub fn append(&mut self, modifier: Cow<'a, Modifier>) {
  function fmt (line 565) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Modify (line 611) | pub trait Modify<'a> {
    method modifier (line 613) | fn modifier(&mut self) -> &mut Modifier<'a>;
    method modify (line 616) | fn modify(mut self, f: impl Fn(Spawn<'a, ()>) -> Spawn<'a, ()> + 'a) -...
    method append (line 625) | fn append(mut self, modifier: Cow<'a, Modifier>) -> Self
    method on_insert (line 634) | fn on_insert<F>(self, f: F) -> Self
    method flex_gap (line 652) | fn flex_gap(self, gap: Val) -> Self
    method observe (line 709) | fn observe<F, E, B, Marker>(self, observer: F) -> Self

FILE: src/ecs/spawn.rs
  function spawn (line 38) | pub fn spawn<'a, B>(bundle: B) -> Spawn<'a>
  type SpawnFn (line 59) | type SpawnFn = Rc<dyn Fn(&mut World, &mut Option<Entity>)>;
  type ObserverFn (line 61) | type ObserverFn<'a> = Rc<dyn Fn(&mut EntityWorldMut) + 'a>;
  type OnInsertFn (line 63) | type OnInsertFn<'a> = Rc<dyn Fn(EntityWorldMut) + 'a>;
  type Spawn (line 70) | pub struct Spawn<'a, C = ()> {
  function target (line 84) | pub fn target(mut self, target: Entity) -> Self {
  function content (line 90) | pub fn content<C2>(self, content: C2) -> Spawn<'a, C2> {
  function on_spawn (line 103) | pub fn on_spawn(mut self, f: impl Fn(EntityWorldMut) + 'a) -> Self {
  function on_insert (line 109) | pub fn on_insert(mut self, f: impl Fn(EntityWorldMut) + 'a) -> Self {
  function observe (line 115) | pub fn observe<F, E, B, Marker>(mut self, observer: F) -> Self
  method compose (line 163) | fn compose(cx: Scope<Self>) -> impl Compose {

FILE: src/executor.rs
  type Executor (line 5) | pub trait Executor {
    method spawn (line 7) | fn spawn(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>);
    method spawn (line 13) | fn spawn(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
  type ExecutorContext (line 33) | pub struct ExecutorContext {
    method new (line 46) | pub fn new(executor: impl Executor + 'static) -> Self {
    method spawn (line 53) | pub fn spawn<F>(&self, future: F)
    method spawn_boxed (line 61) | pub fn spawn_boxed(&self, future: Pin<Box<dyn Future<Output = ()> + Se...
  method default (line 39) | fn default() -> Self {

FILE: src/lib.rs
  type Cow (line 202) | pub enum Cow<'a, T> {
  function to_owned (line 211) | pub fn to_owned(&self) -> T
  function into_owned (line 219) | pub fn into_owned(self) -> T
  method clone (line 234) | fn clone(&self) -> Self {
  type Target (line 243) | type Target = T;
  method deref (line 245) | fn deref(&self) -> &Self::Target {
  function from (line 254) | fn from(value: RefMap<'a, T>) -> Self {
  function from (line 260) | fn from(value: Signal<'a, T>) -> Self {
  function from (line 266) | fn from(value: Map<'a, T>) -> Self {
  function fmt (line 272) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type RefMap (line 284) | pub enum RefMap<'a, T> {
  method clone (line 294) | fn clone(&self) -> Self {
  type Target (line 302) | type Target = T;
  method deref (line 304) | fn deref(&self) -> &Self::Target {
  method hash (line 314) | fn hash<H: Hasher>(&self, state: &mut H) {
  function from (line 320) | fn from(value: Signal<'a, T>) -> Self {
  function from (line 326) | fn from(value: Map<'a, T>) -> Self {
  function fmt (line 332) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Map (line 342) | pub struct Map<'a, T> {
  type Target (line 350) | type Target = T;
  method deref (line 352) | fn deref(&self) -> &Self::Target {
  type MapUnchecked (line 360) | pub struct MapUnchecked<'a, T> {
  method compose (line 367) | fn compose(cx: Scope<Self>) -> impl Compose {
  method name (line 373) | fn name() -> Option<std::borrow::Cow<'static, str>> {
  method hash (line 379) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Signal (line 390) | pub struct Signal<'a, T> {
  function map (line 400) | pub fn map<U>(me: Self, f: fn(&T) -> &U) -> Map<'a, U> {
  function map_unchecked (line 421) | pub unsafe fn map_unchecked<U>(me: Self, f: fn(&T) -> &U) -> MapUnchecke...
  type Target (line 429) | type Target = T;
  method deref (line 431) | fn deref(&self) -> &Self::Target {
  method hash (line 437) | fn hash<H: Hasher>(&self, state: &mut H) {
  type UnsafeWrap (line 444) | struct UnsafeWrap<T: ?Sized>(T);
  type SignalMut (line 451) | pub struct SignalMut<'a, T> {
  function update (line 467) | pub fn update(me: Self, f: impl FnOnce(&mut T) + Send + 'static) {
  function set (line 479) | pub fn set(me: Self, value: T)
  function set_if_neq (line 487) | pub fn set_if_neq(me: Self, value: T)
  function with (line 497) | pub fn with(me: Self, f: impl FnOnce(&mut T) + Send + 'static) {
  function as_ref (line 519) | pub fn as_ref(me: Self) -> Signal<'a, T> {
  type Target (line 528) | type Target = T;
  method deref (line 530) | fn deref(&self) -> &Self::Target {
  type Contexts (line 589) | struct Contexts {
  type ScopeState (line 594) | pub type ScopeState<'a> = &'a ScopeData<'a>;
  type ScopeData (line 598) | pub struct ScopeData<'a> {
  method drop (line 622) | fn drop(&mut self) {
  type Scope (line 632) | pub struct Scope<'a, C: ?Sized> {
  function me (line 639) | pub fn me(self) -> Signal<'a, C> {
  function state (line 647) | pub fn state(self) -> ScopeState<'a> {
  method clone (line 653) | fn clone(&self) -> Self {
  type Target (line 661) | type Target = ScopeState<'a>;
  method deref (line 663) | fn deref(&self) -> &Self::Target {
  function use_ref (line 671) | pub fn use_ref<T: 'static>(cx: ScopeState<'_>, make_value: impl FnOnce()...
  type MutState (line 686) | struct MutState<T> {
  function use_mut (line 694) | pub fn use_mut<T: 'static>(cx: ScopeState<'_>, make_value: impl FnOnce()...
  function use_callback (line 722) | pub fn use_callback<'a, T, R>(
  type ContextError (line 747) | pub struct ContextError<T> {
  method clone (line 752) | fn clone(&self) -> Self {
  function fmt (line 760) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function fmt (line 768) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function use_context (line 780) | pub fn use_context<T: 'static>(cx: ScopeState<'_>) -> Result<&Rc<T>, Con...
  function use_provider (line 798) | pub fn use_provider<T: 'static>(cx: ScopeState<'_>, make_value: impl FnO...
  type Generational (line 816) | pub trait Generational {
    method generation (line 818) | fn generation(self) -> u64;
    method generation (line 822) | fn generation(self) -> u64 {
    method generation (line 829) | fn generation(self) -> u64 {
    method generation (line 836) | fn generation(self) -> u64 {
  function use_effect (line 843) | pub fn use_effect<D, T>(cx: ScopeState<'_>, dependency: D, effect: impl ...
  function use_memo (line 865) | pub fn use_memo<D, T>(
  function use_drop (line 895) | pub fn use_drop<'a>(cx: ScopeState<'a>, f: impl FnOnce() + 'a) {
  function use_local_task (line 979) | pub fn use_local_task<'a, F>(cx: ScopeState<'a>, make_task: impl FnOnce(...
  type BoxedFuture (line 999) | type BoxedFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
  type TaskFuture (line 1002) | struct TaskFuture {
  type Output (line 1009) | type Output = ();
  method poll (line 1011) | fn poll(
  function use_task (line 1103) | pub fn use_task<'a, F>(cx: ScopeState<'a>, make_task: impl FnOnce() -> F)

FILE: src/ui/material/button.rs
  function button (line 11) | pub fn button<'a, C>(content: C) -> Button<'a, C> {
  type Button (line 25) | pub struct Button<'a, C> {
  function background_color (line 36) | pub fn background_color(mut self, background_color: Color) -> Self {
  function elevation (line 42) | pub fn elevation(mut self, elevation: f32) -> Self {
  function padding (line 48) | pub fn padding(mut self, padding: UiRect) -> Self {
  method compose (line 55) | fn compose(cx: Scope<Self>) -> impl Compose {
  function modifier (line 74) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: src/ui/material/container.rs
  function container (line 15) | pub fn container<'a, C>(content: C) -> Container<'a, C> {
  type Container (line 33) | pub struct Container<'a, C> {
  function background_color (line 44) | pub fn background_color(mut self, background_color: Color) -> Self {
  function border_radius (line 50) | pub fn border_radius(mut self, border_radius: BorderRadius) -> Self {
  function elevation (line 56) | pub fn elevation(mut self, elevation: f32) -> Self {
  function padding (line 62) | pub fn padding(mut self, padding: UiRect) -> Self {
  method compose (line 69) | fn compose(cx: Scope<Self>) -> impl Compose {
  function modifier (line 102) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: src/ui/material/mod.rs
  type Colors (line 21) | pub struct Colors {
  type TypographyStyle (line 37) | pub struct TypographyStyle {
  type TypographyStyleKind (line 50) | pub enum TypographyStyleKind {
  type TypographyToken (line 63) | pub struct TypographyToken {
    type Output (line 75) | type Output = TypographyStyle;
    method index (line 77) | fn index(&self, index: TypographyStyleKind) -> &Self::Output {
  type TypographyKind (line 88) | pub enum TypographyKind {
  type Typography (line 104) | pub struct Typography {
    type Output (line 119) | type Output = TypographyToken;
    method index (line 121) | fn index(&self, index: TypographyKind) -> &Self::Output {
  type Theme (line 133) | pub struct Theme {
  method default (line 142) | fn default() -> Self {

FILE: src/ui/material/radio.rs
  function radio_button (line 12) | pub fn radio_button<'a>() -> RadioButton<'a> {
  type RadioButton (line 26) | pub struct RadioButton<'a> {
  function is_enabled (line 37) | pub fn is_enabled(mut self, is_enabled: bool) -> Self {
  function inner_radius (line 43) | pub fn inner_radius(mut self, inner_radius: f32) -> Self {
  function outer_radius (line 49) | pub fn outer_radius(mut self, outer_radius: f32) -> Self {
  function border_width (line 55) | pub fn border_width(mut self, border_width: f32) -> Self {
  function elevation (line 61) | pub fn elevation(mut self, elevation: f32) -> Self {
  method compose (line 68) | fn compose(cx: Scope<Self>) -> impl Compose {
  function modifier (line 114) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: src/ui/material/text.rs
  function body (line 12) | pub fn body<'a>(content: impl Into<String>) -> Text<'a> {
  function headline (line 17) | pub fn headline<'a>(content: impl Into<String>) -> Text<'a> {
  function label (line 22) | pub fn label<'a>(content: impl Into<String>) -> Text<'a> {
  function title (line 27) | pub fn title<'a>(content: impl Into<String>) -> Text<'a> {
  function text (line 32) | pub fn text<'a>(content: impl Into<String>) -> Text<'a> {
  type Text (line 44) | pub struct Text<'a> {
  function typography (line 53) | pub fn typography(mut self, typography: TypographyKind) -> Self {
  function typography_style (line 59) | pub fn typography_style(mut self, typography_style: TypographyStyleKind)...
  method compose (line 66) | fn compose(cx: crate::Scope<Self>) -> impl Compose {
  function modifier (line 83) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: src/ui/material/ui.rs
  function material_ui (line 13) | pub fn material_ui<'a, C: Compose>(content: C) -> MaterialUi<'a, C> {
  type MaterialUi (line 26) | pub struct MaterialUi<'a, C> {
  function theme (line 34) | pub fn theme(mut self, theme: Theme) -> Self {
  method compose (line 41) | fn compose(cx: Scope<Self>) -> impl Compose {
  function modifier (line 60) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: src/ui/mod.rs
  function scroll_view (line 22) | pub fn scroll_view<'a, C: Compose>(content: C) -> ScrollView<'a, C> {
  type ScrollView (line 35) | pub struct ScrollView<'a, C> {
  function line_size (line 45) | pub fn line_size(mut self, size: f32) -> Self {
  function scroll_x (line 51) | pub fn scroll_x(mut self, scroll_x: bool) -> Self {
  function scroll_y (line 57) | pub fn scroll_y(mut self, scroll_y: bool) -> Self {
  method compose (line 64) | fn compose(cx: Scope<Self>) -> impl Compose {
  function modifier (line 127) | fn modifier(&mut self) -> &mut Modifier<'a> {

FILE: tests/composer.rs
  type Counter (line 11) | struct Counter {
  method compose (line 16) | fn compose(cx: Scope<Self>) -> impl Compose {
  type NonUpdateCounter (line 25) | struct NonUpdateCounter {
  method compose (line 30) | fn compose(cx: Scope<Self>) -> impl Compose {
  function it_composes (line 36) | fn it_composes() {
  function it_composes_depth_first (line 61) | fn it_composes_depth_first() {
  function it_skips_recomposes (line 128) | fn it_skips_recomposes() {
  function it_composes_dyn_compose (line 153) | fn it_composes_dyn_compose() {
  function it_composes_from_iter (line 178) | fn it_composes_from_iter() {
  function it_composes_memo (line 203) | fn it_composes_memo() {