std/core/convert

Infallible conversion. Implement this one, Into comes for free.

const codepoint: Int = Int.from 'A'
print codepoint

This is also how a package converts its own type into a foreign one: a type of this package named as an argument of the trait is enough to own the implementation, so Float64 may be the target although it belongs to somebody else.

type Celsius {
  degrees: Float
}

extend Float64 with From<Celsius> {
  static fn from(value: Celsius): Float64 {
    value.degrees
  }
}

const degrees: Float64 = Celsius(21.5).into()
print degrees

• Into - the other direction, gained for free from this one.
• TryFrom - the same conversion where it can fail.

The other direction of From, gained for free wherever Target: From<Self>.

• Implement From and not this one; the compiler says so at an extend that tries.

• TryInto - the same step where the conversion can fail.

The blanket implementation that gives every From its Into for free: nothing implements Into by hand.

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. What this buys is ? on a Result<Value, Never> - the reading end of a Channel cannot fail, and without this every use of one would have to take the Result apart with a pattern.

Fallible conversion: the From for a source that may not represent a valid value. Implement this one, TryInto comes for free.

A type may implement it several times, once per source: Int8.tryFrom(300) narrows a number and Int8.tryFrom("42") reads text, and the argument decides which one is meant. Text is a source like any other - there is no separate trait for it, and no parse on a type.

const narrow: Result<Int8, NumberRangeError> = Int8.tryFrom 300
print narrow.isError()
const read: Result<Int8, NumberParseError> = Int8.tryFrom "42"
print read.isError()

• TryInto - the other direction, gained for free from this one.
• From - the same conversion where it cannot fail.

The other direction of TryFrom, gained for free wherever Target: TryFrom<Self, Failure>.

Write the target out. tryInto() answers a Result, so a ? in front of the annotation is what a reader sees first and the target itself has nowhere else to come from. Under a ? the annotation is the target alone, and the failure is the one the target's TryFrom from this source answers with:

const narrow: Result<Int8, NumberRangeError> = 300.tryInto()
print narrow.isError()

fn port(text: String): Result<Int8, NumberParseError> {
  const number: Int8 = text.tryInto()?
  Ok number
}

print port("42")

• Implement TryFrom and not this one. The blanket implementation below is the only TryInto there is, and the compiler says so at an extend that tries.

• TryFrom - the one to implement.
• Into - the same step where the conversion cannot fail.

The blanket implementation that gives every TryFrom its TryInto for free: nothing implements TryInto by hand.

What Status.tryFrom(text) fails with when text is not one of a literal type's members:

'away' is not one of "online", "offline"

Used by string interpolation. Generated for every type. A shared trait, so that objects with an identity (connections, files) can be printed, too. Equals and Hash are not: == always compares content. For identity there is isSame(a, b).

print 1.show()
print "already text".show()