#!/usr/bin/env dub
/+ dub.sdl:
    name "eh_timers"
    dependency "sparkles:event-horizon" path="../../../../.."
    buildType "checked" {
        buildOptions "optimize" "inline" "debugInfo"
    }
    platforms "linux"
+/
import 
(package) corecore.
(module) core.time
Module containing core time functionality, such as Duration (which
represents a duration of time) or MonoTime (which represents a
timestamp of the system's monotonic clock).
Various functions take a string (or strings) to represent a unit of time
(e.g. convert!("days", "hours")(numDays)). The valid strings to use
with such functions are "years", "months", "weeks", "days", "hours",
"minutes", "seconds", "msecs" (milliseconds), "usecs" (microseconds),
"hnsecs" (hecto-nanoseconds - i.e. 100 ns) or some subset thereof. There
are a few functions that also allow "nsecs", but very little actually
has precision greater than hnsecs.
Symbol 
Description 
Types
Duration 
Represents a duration of time of weeks or less (kept internally as hnsecs). (e.g. 22 days or 700 seconds). 
TickDuration 
DEPRECATED Represents a duration of time in system clock ticks, using the highest precision that the system provides. 
MonoTime 
Represents a monotonic timestamp in system clock ticks, using the highest precision that the system provides. 
Functions
convert 
Generic way of converting between two time units. 
dur 
Allows constructing a Duration from the given time units with the given length. 
weeks days hours
minutes seconds msecs
usecs hnsecs nsecs |
Convenience aliases for dur. |
| abs |  Returns the absolute value of a duration. |
From Duration 
From TickDuration 
From units 
To Duration 
tickDuration.to, std,conv!Duration() 
dur!"msecs"(5) or 5.msecs() 
| To TickDuration |
duration.to, std,conv!TickDuration() |
|
TickDuration.from!"msecs"(msecs) |
| To units |
duration.total!"days" |
tickDuration.msecs |
convert!("days", "msecs")(msecs) |
Source
core/time.d
@copyrightCopyright 2010 - 2012@licenseBoost License 1.0.@authorsJonathan M Davis and Kato Shoichitime : msecs;
import 
(package) stdstd.
(module) std.stdio
Category 
Symbols 
File handles 
_popen File isFileHandle openNetwork stderr stdin stdout 
Reading 
chunks lines readf readfln readln 
Writing 
toFile write writef writefln writeln 
Misc 
KeepTerminator LockType StdioException 
Standard I/O functions that extend core.stdc.stdio.  core.stdc.stdio
is publically imported when importing std.stdio.
There are three layers of I/O:
The lowest layer is the operating system layer. The two main schemes are Windows and Posix.
C's stdio.h which unifies the two operating system schemes.
std.stdio, this module, unifies the various stdio.h implementations into
    a high level package for D programs.
Source
std/stdio.d
@copyrightCopyright The D Language Foundation 2007-.@licenseBoost License 1.0.@authorsWalter Bright,
Andrei Alexandrescu,
Alex Rønne Petersenstdio : 
(alias template) eh_timers.writeln = std.stdio.writeln(T...)(T args)
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln;
import 
(package) sparklessparkles.
(module) sparkles.event_horizon
sparkles:event-horizon — the completion-first event loop with a native
algebraic-effect layer. This package module re-exports the public surface
(SPEC §16); import sparkles.event_horizon`` for the whole API, or a specific
module for a narrower dependency.event_horizon;

void 
void D main()main()
{
    
(struct) sparkles.event_horizon.group.LoopGroup
A running loop group. Non-copyable; owns its worker scheduler(s).LoopGroup 
(local variable) sparkles.event_horizon.group.LoopGroup groupgroup;
    if (
(struct) sparkles.event_horizon.group.LoopGroup
A running loop group. Non-copyable; owns its worker scheduler(s).LoopGroup.
expected.Expected!(void, IoError, NoGcHook) sparkles.event_horizon.group.LoopGroup.start(out sparkles.event_horizon.group.LoopGroup group, in sparkles.event_horizon.group.LoopGroupConfig cfg = LoopGroupConfig(Topology.single, 0u, 256u, Flag.yes, Flag.yes, 256u, Flag.no))
Probes the kernel and starts the group. io_uring probe failure is a
hard error (SPEC §3.4 — no epoll fallback).start(
(local variable) sparkles.event_horizon.group.LoopGroup groupgroup).
bool expected.Expected!(void, sparkles.base.io.errors.IoError, sparkles.base.text.errors.NoGcHook).hasError!()() const pure nothrow @nogc @property @safe
Checks if Expected has errorhasError)
        assert(false, "no completion backend");
    scope (exit) 
(local variable) sparkles.event_horizon.group.LoopGroup groupgroup.
void sparkles.event_horizon.group.LoopGroup.shutdown(core.time.Duration grace = dur(5L)) nothrow @safe
Tears down the group's workers.shutdown();

    int 
(local variable) int ticksticks;
    auto 
(local variable) expected.Expected!(int, Cause!(IoError), NoGcHook) runrun = 
(local variable) sparkles.event_horizon.group.LoopGroup groupgroup.
expected.Expected!(int, Cause!(IoError), NoGcHook) sparkles.event_horizon.group.LoopGroup.run!int(scope int delegate(ref sparkles.event_horizon.scope_.Scope!(Sched, IoError) root, ref sparkles.event_horizon.capability.Ctx!(RingClock, RingVfs, RingNet, RingProc) env) main) @system
Runs main as the root fiber inside the root scope, handing it the live
capability row. All authority originates here. Blocks the calling thread
until the root scope joins. The group remains available until explicit
shutdown or destruction.run((ref 
(alias) sparkles.event_horizon.group.RootScope = sparkles.event_horizon.scope_.Scope!(Sched, IoError)
The blessed live scope instantiation handed to the root fiber (SPEC §7.2,
§11): a Scope over the ring-backed Sched executor with the IoError
channel.RootScope 
(parameter) sparkles.event_horizon.scope_.Scope!(Sched, IoError) scsc, ref 
(alias) sparkles.event_horizon.live.Env = sparkles.event_horizon.capability.Ctx!(RingClock, RingVfs, RingNet, RingProc)
The default live capability row handed to the root fiber (SPEC §11).
fs is on every backend: RingVfs needs no ring file operations
(SPEC §10.5).Env 
(parameter) sparkles.event_horizon.capability.Ctx!(RingClock, RingVfs, RingNet, RingProc) envenv) {
        foreach (
(local variable) int ii; 1 .. 4)
        {
            assert(!
(parameter) sparkles.event_horizon.capability.Ctx!(RingClock, RingVfs, RingNet, RingProc) envenv.clock.
expected.Expected!(void, IoError, NoGcHook) sparkles.event_horizon.live.RingClock.sleep(core.time.Duration d)
Parks the calling fiber for d on an in-ring TIMEOUT.sleep(10.msecs).
bool expected.Expected!(void, sparkles.base.io.errors.IoError, sparkles.base.text.errors.NoGcHook).hasError!()() const pure nothrow @nogc @property @safe
Checks if Expected has errorhasError); // parks this fiber only
            
void std.stdio.writeln!(string, int)(string __param_0, int __param_1) @safe
Equivalent to write(args, '\n').  Calling writeln without
arguments is valid and just prints a newline to the standard
output.
Example
Reads stdin and writes it to stdout with an argument
counter.
import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}
@paramargs the items to write to stdout@throwsIn case of an I/O error, throws an StdioException.writeln("tick ", 
(local variable) int ii);
            ++
(local variable) int ticksticks;
        }
        return 0;
    });
    assert(
(local variable) expected.Expected!(int, Cause!(IoError), NoGcHook) runrun.
bool expected.Expected!(int, sparkles.event_horizon.cause.Cause!(IoError), sparkles.base.text.errors.NoGcHook).hasValue!()() const pure nothrow @nogc @property @safe
Checks if Expected has valuehasValue);
    assert(
(local variable) int ticksticks == 3);
}