Lines Matching full:nil
146 if b == nil {
147 return nil, nil // no such method
149 return b.BindReceiver(recv), nil
166 if err := UnpackPositionalArgs("all", args, kwargs, 1, &iterable); err != nil {
167 return nil, err
174 return False, nil
177 return True, nil
183 if err := UnpackPositionalArgs("any", args, kwargs, 1, &iterable); err != nil {
184 return nil, err
191 return True, nil
194 return False, nil
200 if err := UnpackPositionalArgs("bool", args, kwargs, 0, &x); err != nil {
201 return nil, err
203 return x.Truth(), nil
209 return nil, fmt.Errorf("bytes does not accept keyword arguments")
212 return nil, fmt.Errorf("bytes: got %d arguments, want exactly 1", len(args))
216 return x, nil
219 return Bytes(utf8Transcode(string(x))), nil
232 if err := AsInt(elem, &b); err != nil {
233 return nil, fmt.Errorf("bytes: at index %d, %s", i, err)
237 return Bytes(buf.String()), nil
241 return nil, fmt.Errorf("bytes: got %s, want string, bytes, or iterable of ints", x.Type())
248 return nil, fmt.Errorf("chr does not accept keyword arguments")
251 return nil, fmt.Errorf("chr: got %d arguments, want 1", len(args))
254 if err != nil {
255 return nil, fmt.Errorf("chr: %s", err)
258 return nil, fmt.Errorf("chr: Unicode code point %d out of range (<0)", i)
261 return nil, fmt.Errorf("chr: Unicode code point U+%X out of range (>0x10FFFF)", i)
263 return String(string(rune(i))), nil
269 return nil, fmt.Errorf("dict: got %d arguments, want at most 1", len(args))
272 if err := updateDict(dict, args, kwargs); err != nil {
273 return nil, fmt.Errorf("dict: %v", err)
275 return dict, nil
281 return nil, fmt.Errorf("dir does not accept keyword arguments")
284 return nil, fmt.Errorf("dir: got %d arguments, want 1", len(args))
296 return NewList(elems), nil
303 if err := UnpackPositionalArgs("enumerate", args, kwargs, 1, &iterable, &start); err != nil {
304 return nil, err
332 return NewList(pairs), nil
338 if err := UnpackArgs("fail", nil, kwargs, "sep?", &sep); err != nil {
339 return nil, err
350 writeValue(buf, v, nil)
354 return nil, errors.New(buf.String())
359 return nil, fmt.Errorf("float does not accept keyword arguments")
362 return Float(0.0), nil
365 return nil, fmt.Errorf("float got %d arguments, wants 1", len(args))
370 return Float(1.0), nil
372 return Float(0.0), nil
377 return x, nil
380 return nil, fmt.Errorf("float: empty string")
387 return inf, nil
389 return neginf, nil
393 return inf, nil
395 return neginf, nil
399 return nan, nil
404 return nil, fmt.Errorf("floating-point number too large")
406 if err != nil {
407 return nil, fmt.Errorf("invalid float literal: %s", s)
409 return Float(f), nil
411 return nil, fmt.Errorf("float got %s, want number or string", x.Type())
425 if err := UnpackPositionalArgs("getattr", args, kwargs, 2, &object, &name, &dflt); err != nil {
426 return nil, err
430 if err != nil {
433 if dflt != nil {
434 return dflt, nil
436 return nil, nameErr(b, err)
438 if v != nil {
439 return v, nil
441 // (nil, nil) => no such field
443 if dflt != nil {
444 return dflt, nil
446 return nil, fmt.Errorf("getattr: %s has no .%s field or method", object.Type(), name)
453 if err := UnpackPositionalArgs("hasattr", args, kwargs, 2, &object, &name); err != nil {
454 return nil, err
458 if err == nil {
459 return Bool(v != nil), nil
468 return True, nil
472 return False, nil
478 if err := UnpackPositionalArgs("hash", args, kwargs, 1, &x); err != nil {
479 return nil, err
495 return nil, fmt.Errorf("hash: got %s, want string or bytes", x.Type())
497 return MakeInt(h), nil
521 if err := UnpackArgs("int", args, kwargs, "x", &x, "base?", &base); err != nil {
522 return nil, err
527 if base != nil {
530 if err != nil {
531 return nil, fmt.Errorf("int: for base, got %s, want int", base.Type())
534 return nil, fmt.Errorf("int: base must be an integer >= 2 && <= 36")
538 if res == nil {
539 return nil, fmt.Errorf("int: invalid literal with base %d: %s", b, s)
541 return res, nil
544 if base != nil {
545 return nil, fmt.Errorf("int: can't convert non-string with explicit base")
550 return one, nil
552 return zero, nil
557 if err != nil {
558 return nil, fmt.Errorf("int: %s", err)
560 return i, nil
563 // parseInt defines the behavior of int(string, base=int). It returns nil on error.
604 return nil
618 return nil
630 return nil
636 if err := UnpackPositionalArgs("len", args, kwargs, 1, &x); err != nil {
637 return nil, err
641 return nil, fmt.Errorf("len: value of type %s has no len", x.Type())
643 return MakeInt(len), nil
649 if err := UnpackPositionalArgs("list", args, kwargs, 0, &iterable); err != nil {
650 return nil, err
653 if iterable != nil {
664 return NewList(elems), nil
670 return nil, fmt.Errorf("%s requires at least one positional argument", b.Name())
673 if err := UnpackArgs(b.Name(), nil, kwargs, "key?", &keyFunc); err != nil {
674 return nil, err
689 if iter == nil {
690 return nil, fmt.Errorf("%s: %s value is not iterable", b.Name(), iterable.Type())
695 return nil, nameErr(b, "argument is an empty sequence")
700 if keyFunc == nil {
704 res, err := Call(thread, keyFunc, keyargs, nil)
705 if err != nil {
706 return nil, err // to preserve backtrace, don't modify error
714 if keyFunc == nil {
718 res, err := Call(thread, keyFunc, keyargs, nil)
719 if err != nil {
720 return nil, err // to preserve backtrace, don't modify error
725 if ok, err := Compare(op, key, extremeKey); err != nil {
726 return nil, nameErr(b, err)
732 return extremum, nil
738 return nil, fmt.Errorf("ord does not accept keyword arguments")
741 return nil, fmt.Errorf("ord: got %d arguments, want 1", len(args))
750 return nil, fmt.Errorf("ord: string encodes %d Unicode code points, want 1", n)
752 return MakeInt(int(r)), nil
757 return nil, fmt.Errorf("ord: bytes has length %d, want 1", len(x))
759 return MakeInt(int(x[0])), nil
761 return nil, fmt.Errorf("ord: got %s, want string or bytes", x.Type())
768 if err := UnpackArgs("print", nil, kwargs, "sep?", &sep); err != nil {
769 return nil, err
781 writeValue(buf, v, nil)
786 if thread.Print != nil {
791 return None, nil
798 if err := UnpackPositionalArgs("range", args, kwargs, 1, &start, &stop, &step); err != nil {
799 return nil, err
808 return nil, nameErr(b, "step argument must not be zero")
811 return rangeValue{start: start, stop: stop, step: step, len: rangeLen(start, stop, step)}, nil
878 return rangeEqual(x, y), nil
880 return !rangeEqual(x, y), nil
902 if err != nil {
928 if err := UnpackPositionalArgs("repr", args, kwargs, 1, &x); err != nil {
929 return nil, err
931 return String(x.String()), nil
937 if err := UnpackPositionalArgs("reversed", args, kwargs, 1, &iterable); err != nil {
938 return nil, err
954 return NewList(elems), nil
960 if err := UnpackPositionalArgs("set", args, kwargs, 0, &iterable); err != nil {
961 return nil, err
964 if iterable != nil {
969 if err := set.Insert(x); err != nil {
970 return nil, nameErr(b, err)
974 return set, nil
987 ); err != nil {
988 return nil, err
1004 if key != nil {
1007 k, err := Call(thread, key, Tuple{v}, nil)
1008 if err != nil {
1009 return nil, err // to preserve backtrace, don't modify error
1025 keys []Value // nil => values[i] is key
1033 if s.keys == nil {
1037 if err != nil {
1043 if s.keys != nil {
1052 return nil, fmt.Errorf("str does not accept keyword arguments")
1055 return nil, fmt.Errorf("str: got %d arguments, want exactly 1", len(args))
1059 return x, nil
1062 return String(utf8Transcode(string(x))), nil
1064 return String(x.String()), nil
1085 if err := UnpackPositionalArgs("tuple", args, kwargs, 0, &iterable); err != nil {
1086 return nil, err
1089 return Tuple(nil), nil
1101 return elems, nil
1107 return nil, fmt.Errorf("type does not accept keyword arguments")
1110 return nil, fmt.Errorf("type: got %d arguments, want exactly 1", len(args))
1112 return String(args[0].Type()), nil
1118 return nil, fmt.Errorf("zip does not accept keyword arguments")
1124 if iter != nil {
1131 if it == nil {
1132 return nil, fmt.Errorf("zip: argument #%d is not iterable: %s", i+1, seq.Type())
1166 return NewList(result), nil
1174 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &key, &dflt); err != nil {
1175 return nil, err
1177 if v, ok, err := b.Receiver().(*Dict).Get(key); err != nil {
1178 return nil, nameErr(b, err)
1180 return v, nil
1181 } else if dflt != nil {
1182 return dflt, nil
1184 return None, nil
1189 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1190 return nil, err
1197 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1198 return nil, err
1205 return NewList(res), nil
1210 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1211 return nil, err
1213 return NewList(b.Receiver().(*Dict).Keys()), nil
1219 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &k, &d); err != nil {
1220 return nil, err
1222 if v, found, err := b.Receiver().(*Dict).Delete(k); err != nil {
1223 return nil, nameErr(b, err) // dict is frozen or key is unhashable
1225 return v, nil
1226 } else if d != nil {
1227 return d, nil
1229 return nil, nameErr(b, "missing key")
1234 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1235 return nil, err
1240 return nil, nameErr(b, "empty dict")
1243 if err != nil {
1244 return nil, nameErr(b, err) // dict is frozen
1246 return Tuple{k, v}, nil
1251 var key, dflt Value = nil, None
1252 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &key, &dflt); err != nil {
1253 return nil, err
1256 if v, ok, err := dict.Get(key); err != nil {
1257 return nil, nameErr(b, err)
1259 return v, nil
1260 } else if err := dict.SetKey(key, dflt); err != nil {
1261 return nil, nameErr(b, err)
1263 return dflt, nil
1270 return nil, fmt.Errorf("update: got %d arguments, want at most 1", len(args))
1272 if err := updateDict(b.Receiver().(*Dict), args, kwargs); err != nil {
1273 return nil, fmt.Errorf("update: %v", err)
1275 return None, nil
1280 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1281 return nil, err
1288 return NewList(res), nil
1294 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &object); err != nil {
1295 return nil, err
1298 if err := recv.checkMutable("append to"); err != nil {
1299 return nil, nameErr(b, err)
1302 return None, nil
1307 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1308 return nil, err
1310 if err := b.Receiver().(*List).Clear(); err != nil {
1311 return nil, nameErr(b, err)
1313 return None, nil
1320 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &iterable); err != nil {
1321 return nil, err
1323 if err := recv.checkMutable("extend"); err != nil {
1324 return nil, nameErr(b, err)
1327 return None, nil
1333 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &value, &start_, &end_); err != nil {
1334 return nil, err
1339 if err != nil {
1340 return nil, nameErr(b, err)
1344 if eq, err := Equal(recv.elems[i], value); err != nil {
1345 return nil, nameErr(b, err)
1347 return MakeInt(i), nil
1350 return nil, nameErr(b, "value not in list")
1358 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 2, &index, &object); err != nil {
1359 return nil, err
1361 if err := recv.checkMutable("insert into"); err != nil {
1362 return nil, nameErr(b, err)
1376 recv.elems = append(recv.elems, nil)
1380 return None, nil
1387 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &value); err != nil {
1388 return nil, err
1390 if err := recv.checkMutable("remove from"); err != nil {
1391 return nil, nameErr(b, err)
1394 if eq, err := Equal(elem, value); err != nil {
1395 return nil, fmt.Errorf("remove: %v", err)
1398 return None, nil
1401 return nil, fmt.Errorf("remove: element not found")
1410 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &i); err != nil {
1411 return nil, err
1418 return nil, nameErr(b, outOfRange(origI, n, list))
1420 if err := list.checkMutable("pop from"); err != nil {
1421 return nil, nameErr(b, err)
1425 return res, nil
1430 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1431 return nil, err
1444 return String(res.String()), nil
1453 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1454 return nil, err
1460 return stringCodepoints{s, ords}, nil
1462 return stringElems{s, ords}, nil
1469 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1470 return nil, err
1472 return bytesIterable{b.Receiver().(Bytes)}, nil
1479 var _ Iterable = (*bytesIterable)(nil)
1505 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &sub, &start_, &end_); err != nil {
1506 return nil, err
1511 if err != nil {
1512 return nil, nameErr(b, err)
1519 return MakeInt(strings.Count(slice, sub)), nil
1524 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1525 return nil, err
1530 return False, nil
1533 return Bool(recv != ""), nil
1538 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1539 return nil, err
1544 return False, nil
1547 return Bool(recv != ""), nil
1552 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1553 return nil, err
1558 return False, nil
1561 return Bool(recv != ""), nil
1566 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1567 return nil, err
1570 return Bool(isCasedString(recv) && recv == strings.ToLower(recv)), nil
1591 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1592 return nil, err
1597 return False, nil
1600 return Bool(recv != ""), nil
1605 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1606 return nil, err
1617 return False, nil
1623 return False, nil
1628 return False, nil
1633 return Bool(cased), nil
1638 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1639 return nil, err
1642 return Bool(isCasedString(recv) && recv == strings.ToUpper(recv)), nil
1671 return nil, fmt.Errorf("format: single '}' in format")
1691 return nil, fmt.Errorf("format: unmatched '{' in format")
1726 …return nil, fmt.Errorf("format: cannot switch from manual field specification to automatic field n…
1730 return nil, fmt.Errorf("format: tuple index out of range")
1737 …return nil, fmt.Errorf("format: cannot switch from automatic field numbering to manual field speci…
1741 return nil, fmt.Errorf("format: tuple index out of range")
1753 if arg == nil {
1757 …return nil, fmt.Errorf("format: attribute syntax x.y is not supported in replacement fields: %s", …
1760 …return nil, fmt.Errorf("format: element syntax a[i] is not supported in replacement fields: %s", n…
1763 return nil, fmt.Errorf("format: nested replacement fields not supported")
1765 return nil, fmt.Errorf("format: keyword %s not found", name)
1771 return nil, fmt.Errorf("format spec features not supported in replacement fields: %s", spec)
1779 writeValue(buf, arg, nil)
1782 writeValue(buf, arg, nil)
1784 return nil, fmt.Errorf("format: unknown conversion %q", conv)
1787 return String(buf.String()), nil
1815 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &iterable); err != nil {
1816 return nil, err
1828 return nil, fmt.Errorf("join: in list, want string, got %s", x.Type())
1832 return String(buf.String()), nil
1837 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1838 return nil, err
1840 return String(strings.ToLower(string(b.Receiver().(String)))), nil
1847 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &sep); err != nil {
1848 return nil, err
1851 return nil, nameErr(b, "empty separator")
1869 return tuple, nil
1877 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 2, &old, &new, &count); err != nil {
1878 return nil, err
1880 return String(strings.Replace(recv, old, new, count)), nil
1898 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &x, &start, &end); err != nil {
1899 return nil, err
1904 if start, end, err := indices(start, end, len(s)); err != nil {
1905 return nil, nameErr(b, err)
1923 return nil, fmt.Errorf("%s: want string, got %s, for element %d",
1927 return True, nil
1930 return False, nil
1932 return Bool(f(s, string(x))), nil
1934 return nil, fmt.Errorf("%s: got %s, want string or tuple of string", b.Name(), x.Type())
1942 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &chars); err != nil {
1943 return nil, err
1967 return String(s), nil
1972 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1973 return nil, err
1993 return String(buf.String()), nil
1998 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
1999 return nil, err
2001 return String(strings.ToUpper(string(b.Receiver().(String)))), nil
2010 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &sep_, &maxsplit); err != nil {
2011 return nil, err
2016 if sep_ == nil || sep_ == None {
2028 return nil, fmt.Errorf("split: empty separator")
2044 return nil, fmt.Errorf("split: got %s for separator, want string", sep_.Type())
2051 return NewList(list), nil
2111 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &keepends); err != nil {
2112 return nil, err
2130 return NewList(list), nil
2136 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 0, &iterable); err != nil {
2137 return nil, err
2142 if err != nil {
2143 return nil, nameErr(b, err)
2145 return union, nil
2152 if err := UnpackPositionalArgs(b.Name(), args, kwargs, 1, &sub, &start_, &end_); err != nil {
2153 return nil, err
2158 if err != nil {
2159 return nil, nameErr(b, err)
2174 return nil, nameErr(b, "substring not found")
2176 return MakeInt(-1), nil
2178 return MakeInt(i + start), nil
2189 if err := dict.SetKey(item[0], item[1]); err != nil {
2196 if iter == nil {
2203 if iter2 == nil {
2217 if err := dict.SetKey(k, v); err != nil {
2227 if err := dict.SetKey(pair[0], pair[1]); err != nil {
2244 return nil