std/core

Modules

• std/core/array[Array], the inline storage primitive: a fixed number of items whose count is part of the type instead of its storage.
• std/core/bool[Bool], true and false: the primitive that if, while, &&, || and ! are built on directly, without going through a trait method the way + goes through Add.
• std/core/compareEquality, order and hashing: [Equals], [Ordering], [Compare] and [Hash], generated structurally for every type unless it implements one of them by hand, and combineHashes, what a hand-written hash folds its parts through.
• std/core/controlControl structures that are ordinary functions.
• std/core/convertConversion between types: [From]/[Into] for a conversion that always works, [TryFrom]/[TryInto] for one that can fail.
• std/core/error[Error], the trait-typed failure that lets an application pass a reason up through layers that have nothing to say about it, and its one member: cause, the chain to whatever error caused this one.
• std/core/functionsNames for the three closure shapes that signatures take most: a question about one value, an effect on one value and a conversion of one value into another.
• std/core/operatorsAdd, Subtract, Multiply, Divide, Remainder, Power and Negate, the traits the arithmetic operators go through, plus OrElse for ?? and Indexed/MutableIndexed/Slice/MutableSlice for a[i] and a[from..to].
• std/core/optionAbsence as a value: [Option], its two cases, and the vocabulary that works on the value that is there.
• std/core/rangeThe three ranges the syntax writes - [Range] for 0..10, [RangeFrom] for 0.., [RangeTo] for ..10 - the trait [Bounds] that reads any of them, and [RangeIterator], what it takes to walk a range of integers.
• std/core/resultFailure as a value: [Result], its two cases, and the vocabulary that works on the value of a successful one.
• std/core/sharedA type is a value: assigning it, passing it and capturing it is a copy.
• std/core/targetWhat a program is compiled for: [OperatingSystem], [Architecture] and [ByteOrder], each with one static current.
• std/core/void[Void], the result of a function that says nothing, [Never], the type of an expression that never produces a value, and panic, which is how a bug ends a program instead of returning one.

Everything

• alias ActionA closure called for its effect on one value, with nothing to return: what forEach takes.
• trait Adda + b.
• type ArchitectureThe processor architectures the toolchain builds for.
• type ArrayA fixed number of items, and the number is part of the type: Array<Float, 16>.
• extend Array<Item, Size> with EqualsEqual when the items at the same index are equal.
• extend Array<Item, Size> with ShowThe items in brackets, like a [List]: the size is in the type and would say nothing a reader cannot count.
• extend Array<Item, Size> with HashOrder-dependent, like [List.hash]: an Array is an ordered sequence.
• type Booltrue and false, and nothing else.
• trait BoundsWhat every range has in common: the two ends, each None where the range is open on that side.
• type ByteOrderThe order of the bytes of a number in memory, for a binary format that says "native order".
• trait CloseThe destructor of an object: what releases the resource behind it - a descriptor, a socket, a lock - once nothing holds the object any more.
• fn combineHashesFolds one more value into a running hash: wrapping, order-dependent, and deterministic across runs and platforms.
• trait Compare<, <=, >, >=.
• trait Dividea / b.
• fn doEvaluates a block immediately: const x = do { ... }.
• trait Equals== and !=.
• trait Error"Some error, hand it up." Result<Value, Error> is the trait-typed failure: every error type that carries this trait fits into it, so an application can pass a failure up through layers that have nothing to say about it without declaring a wrapper type per layer.
• trait FromInfallible conversion.
• trait HashGenerated structurally for every type.
• trait Indexeda[key].
• trait IntoThe other direction of [From], gained for free wherever Target: From<Self>.
• fn isSametrue if both are the same object.
• type LiteralParseErrorWhat Status.tryFrom(text) fails with when text is not one of a literal type's members:
• trait Multiplya * b.
• trait MutableIndexeda[key] = value.
• trait MutableSlicea[from..to] = values.
• trait Negate-a.
• type NeverThe type of an expression that does not return: panic, return, break, continue.
• type OperatingSystemThe operating systems the toolchain builds for.
• type OptionA value that may be absent.
• extend Option<Value> with ShowSome(value) or the bare None - a case with fields is written out, a case without one is its name.
• extend Option<Target> with From<Iterate<Value?>>All or nothing: names.map(findUser).to<List<User>?>() is Some(users) if every user was found.
• type OrderingWhat [Compare.compare] answers: which of the two values comes first, or that neither does.
• trait OrElsea ?? b: the value, or the fallback where there is none.
• fn panicFor bugs.
• trait Powera ** b: a raised to the power of b.
• alias PredicateA closure that answers a yes-or-no question about one value: what filter, find, any and takeWhile take.
• type Range0..10, 0..=10: a range with both ends.
• extend Range<Value> with Bounds<Value>Both ends are there, and inclusive says whether the high one is inside.
• extend Range<Int> with Iterate<Int>, LengthA range of integers with both ends is a sequence with a length.
• extend Range<Value> with ShowThe source form, and not the fields: 0..10, 0..=10.
• type RangeFrom0..: a range with a start and no end.
• extend RangeFrom<Value> with Bounds<Value>Open at the end, so there is no high end to include.
• extend RangeFrom<Int> with Iterate<Int>0.. counts on forever, which is what makes for index in 0.. and (0..).take(3) work.
• extend RangeFrom<Value> with Show0.., the source form.
• type RangeTo..10, ..=10: a range with an end and no start.
• extend RangeTo<Value> with Bounds<Value>Open at the start.
• extend RangeTo<Value> with Show..10, ..=10, the source form.
• trait Remaindera % b.
• type ResultThe result of an operation that can fail: Ok with the value, or Fail with the reason.
• extend Result<Value, Failure> with ShowOk(value) or Fail(failure).
• extend Result<Target, Failure> with From<Iterate<Result<Value, Failure>>>All or the first error: lines.map { text => Int.tryFrom text }.to<Result<List<Int>, NumberParseError>>() Stops pulling at the first Fail.
• fn retryconst response = retry 3 { http.get(url) }.
• type SharedA box that puts a value in a place several owners can hold, without declaring a whole shared type for it.
• trait ShowUsed by string interpolation.
• trait Slicea[from..to].
• extend Source with Into<Target> where Target: From<Source>The blanket implementation that gives every [From] its [Into] for free: nothing implements Into by hand.
• extend Source with TryInto<Target, Failure> where Target: TryFrom<Source, Failure>The blanket implementation that gives every [TryFrom] its [TryInto] for free: nothing implements TryInto by hand.
• trait Subtracta - b.
• extend Target with From<Never>Every type can be made from a Never, because there is no value to make it from: Never coerces to anything, so the body is the argument.
• alias TransformA closure that turns one value into another: what map takes, and the key of sorted and groupBy.
• trait TryFromFallible conversion: the [From] for a source that may not represent a valid value.
• trait TryIntoThe other direction of [TryFrom], gained for free wherever Target: TryFrom<Self, Failure>.
• fn unlessRuns the block unless the condition holds: if !condition { ... }, for a guard that reads better negated.
• type VoidThe type with exactly one value, and that value is the keyword literal void - as true and false are the values of Bool.