Skip to content

v1.91.0

Choose a tag to compare

View all tags
@claude claude released this 24 Oct 17:29
v1.91.0
5234c26
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Changes

  • Return errors from the Lisp-valued Go forms and the checks (#884)
  • Delete the elps#880 API break waivers released in v1.90.0 (#882)

Breaking changes

API break overrides added since v1.90.0 (surface | symbol | expires | issue | reason):

  • go | lisp.(*LEnv).Add | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Append | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).AppendInPlace | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).ApplyFunction | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CallBuiltin | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CallFunction | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CallGlobal | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CallValue | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Car | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Cdr | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).ChargeSteps | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CheckAlloc | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CheckCallable | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CheckClosure | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).CheckContext | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).DebugStack | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).DeepCopy | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).First | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MakeSequence | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapAssoc | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapDelete | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapDissoc | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapKeys | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapLookup | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapOf | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapPut | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapRange | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapSeqCells | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).MapSeqFunc | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Mod | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Mul | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).NewLambdaCode | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Nth | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Rest | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Second | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).SortedMapOf | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Step | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).StepEach | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.(*LEnv).Sub | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.ChargeRecord | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.ChargeStartedKiB | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.RequireNative | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
  • go | lisp.ResultAs | 2027-01-24 | elps#883 | Owner decision (Sam, on elps#883): every Go form returns its value with an error, and every check returns error, so a caller tests err != nil in place of v.IsError(). The error is the builtin's own *ErrorVal and lisp.Error(err) returns it as the LError; the values, errors and step counts are unchanged. substrate's v1.91.0 bump moves with it: v, err := env.F(...); if err != nil { return lisp.Error(err) }.
Assets 2
Loading