! #1/20 1417587541 501 20 100644 28 ` __.SYMDEF SORTED#1/36 1417587536 501 20 100644 1420 ` lazy_static-518089d616e0fe56.o  __text__TEXT__debug_info__DWARF__debug_abbrev__DWARF__debug_line__DWARF."__debug_str__DWARFP(__debug_loc__DWARF__debug_ranges__DWARF__apple_names__DWARF$__apple_objc__DWARF$__apple_namespac__DWARF;$__apple_types__DWARF_,7CX% rustc version 0.13.0-nightly (5484d6f6d 2014-12-02 00:22:00 +0000)./src/lazy_static.rs/Users/Charlie/.cargo/git/checkouts/lazy-static.rs-3326f1888a1f3bad/masterHSAH HSAH HSAH HSAH #1/20 1417587536 501 20 100600 6537 ` rust.metadata.bin lazy_staticx86_64-apple-darwin9431eb3dcc0ca719@doc/*! A macro for declaring lazily evaluated statics. Using this macro, it is possible to have `static`s that require code to be executed at runtime in order to be initialized. This includes anything requiring heap allocations, like vectors or hash maps, as well as anything that requires function calls to be computed. # Syntax ```ignore lazy_static! { [pub] static ref NAME_1: TYPE_1 = EXPR_1; [pub] static ref NAME_2: TYPE_2 = EXPR_2; ... [pub] static ref NAME_N: TYPE_N = EXPR_N; } ``` # Semantic For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that implements `Deref` and stores it in a static with name `NAME`. On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs can return a reference to the same object. Like regular `static mut`s, this macro only works for types that fulfill the `Sync` trait. # Example Using the macro: ```rust #![feature(phase)] #[phase(plugin)] extern crate lazy_static; use std::collections::HashMap; lazy_static! { static ref HASHMAP: HashMap = { let mut m = HashMap::new(); m.insert(0u, "foo"); m.insert(1u, "bar"); m.insert(2u, "baz"); m }; static ref COUNT: uint = HASHMAP.len(); static ref NUMBER: uint = times_two(21); } fn times_two(n: uint) -> uint { n * 2 } fn main() { println!("The map has {} entries.", *COUNT); println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap()); println!("A expensive calculation on a static results in: {}.", *NUMBER); } ``` # Implementation details The `Deref` implementation uses a hidden `static mut` that is guarded by a atomic check using the `sync::Once` abstraction. All lazily evaluated values are currently put in a heap allocated box, due to the Rust language currently not providing any way to define uninitialized `static mut` values. */"@ crate_typedylib@licenseMIT*@!feature macro_rules$@feature phase@ no_std$@feature globs$std3b1b5fdd7102064aalloc7dce4a243fef8ce1coref5f431360b33e2d6libc9a03ce5eb32c3b07!unicode40c8d8e804ea1a55% collections888a1b18a95def27randf5dee2428eb390b1 rustrt9b297e17401c9e86@@@macro_rules! lazy_static { (static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => { lazy_static!(PRIV static ref $N : $T = $e; $($t)*) }; (pub static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => { lazy_static!(PUB static ref $N : $T = $e; $($t)*) }; ($VIS:ident static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => { lazy_static!(MAKE TY $VIS $N) impl Deref<$T> for $N { fn deref<'a>(&'a self) -> &'a $T { use std::sync::{Once, ONCE_INIT}; use std::mem::transmute; #[inline(always)] fn require_sync(_: &T) { } unsafe { static mut s: *const $T = 0 as *const $T; static mut ONCE: Once = ONCE_INIT; ONCE.doit(|| { s = transmute::, *const $T>(box() ($e)); }); let static_ref = &*s; require_sync(static_ref); static_ref } } } lazy_static!($($t)*) }; (MAKE TY PUB $N:ident) => { #[allow(non_camel_case_types)] #[allow(dead_code)] pub struct $N {__private_field: ()} pub static $N: $N = $N {__private_field: ()}; }; (MAKE TY PRIV $N:ident) => { #[allow(non_camel_case_types)] #[allow(dead_code)] struct $N {__private_field: ()} static $N: $N = $N {__private_field: ()}; }; () => () }@@@ I(#0:0my   +]bglqv{  %*/49>CHMRW\afkpuz $).38=BGLQV[`rw| !&+05:?DINSX]bglqv{  %*/49>CHMRW\afkpuz $).38=BGLQV[`e@ #1/48 1417587536 501 20 100600 826 ` lazy_static-518089d616e0fe56.0.bytecode.deflateRUST_OBJECTeRMHAln6L)-vטb)Ń豗ĊP$IaM搊zX)w:u%O͋wbT_