Advanced
Mailing List Archive

Mailing List Archive

  1. Home >
  2. Python>
  3. Python
1 2 3 4  View All
New Python implementation
flibble at i42
Feb 11, 2021, 4:30 AM
Post #1 of 93 (539 views)
Permalink
Hi!

I am starting work on creating a new Python implementation from scratch using "neos" my universal compiler that can compile any programming language. I envision this implementation to be significantly faster than the currently extant Python implementations (which isn't a stretch given how poorly they perform).

Sample neos session (parsing a fibonacci program, neoscript rather than Python in this case):

neos 1.0.0.0 ED-209
] help
h(elp)
s(chema) <path to language schema> Load language schema
l(oad) <path to program> Load program
list List program
c(ompile) Compile program
r(un) Run program
![<expression>] Evaluate expression (enter interactive mode if expression omitted)
:<input> Input (as stdin)
q(uit) Quit neos
lc List loaded concept libraries
t(race) <0|1|2|3|4|5> [<filter>] Compiler trace
m(etrics) Display metrics for running programs
] lc
[neos.core] (file:///D:\code\neos\build\win32\vs2019\x64\Release\core.ncl)
[neos.boolean]
[neos.language]
[neos.logic]
[neos.math]
[neos.module]
[neos.object]
[neos.string]
[neos.math.universal] (file:///D:\code\neos\build\win32\vs2019\x64\Release\core.math.universal.ncl)
] s neoscript
Loading schema 'neoscript'...
Language: Default neoGFX scripting language
Version: 1.0.0
Copyright (C) 2019 Leigh Johnston
neoscript] l examples/neoscript/fibonacci.neo
neoscript] list
File 'examples/neoscript/fibonacci.neo':
-- neoscript example: Fibonacci

using neos.string;
using neos.stream;

import fn to_string(x : i32) -> string;
import fn to_integer(s : string) -> i32;
import proc input(s : out string);
import proc print(s : in string);

-- functions are pure
def fn add(x, y : i32) -> i32
{
return x + y;
}
def fn fib(x : i32) -> i32
{
if (x < 2)
return 1;
else
return add(fib(x-1), fib(x-2));
}

-- procedures are impure
def proc main()
s : string;
{
print("Enter a positive "
"integer: ");
input(s);
print("Fibonacci(" + s + ") = " + to_string(fib(to_integer(s))) + "\n");
}
neoscript] t 1
neoscript] c
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() = string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.period()
folded: string.utf8(gnirts) <- string.utf8.character.period() = string.utf8(gnirts.)
folding: string.utf8(gnirts.) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.) <- string.utf8.character.alpha() = string.utf8(gnirts.s)
folding: string.utf8(gnirts.s) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.s) <- string.utf8.character.alpha() = string.utf8(gnirts.so)
folding: string.utf8(gnirts.so) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.so) <- string.utf8.character.alpha() = string.utf8(gnirts.soe)
folding: string.utf8(gnirts.soe) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.soe) <- string.utf8.character.alpha() = string.utf8(gnirts.soen)
folding: source.package.name() <- string.utf8(gnirts.soen)
folded: source.package.name() <- string.utf8(gnirts.soen) = source.package.name(neos.string)
folding: source.package.import() <- source.package.name(neos.string)
folded: source.package.import() <- source.package.name(neos.string) = source.package.import(neos.string)
folding: source.package.import(neos.string) <- source.package.import(neos.string)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() = string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() = string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() = string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() = string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) = language.identifier(to_string)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() = string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() = string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() = string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() = string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() = string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() = string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) = language.identifier(to_integer)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folded: source.package.import(neos.string) <- source.package.import(neos.string) = ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(m)
folding: string.utf8(m) <- string.utf8.character.alpha()
folded: string.utf8(m) <- string.utf8.character.alpha() = string.utf8(ma)
folding: string.utf8(ma) <- string.utf8.character.alpha()
folded: string.utf8(ma) <- string.utf8.character.alpha() = string.utf8(mae)
folding: string.utf8(mae) <- string.utf8.character.alpha()
folded: string.utf8(mae) <- string.utf8.character.alpha() = string.utf8(maer)
folding: string.utf8(maer) <- string.utf8.character.alpha()
folded: string.utf8(maer) <- string.utf8.character.alpha() = string.utf8(maert)
folding: string.utf8(maert) <- string.utf8.character.alpha()
folded: string.utf8(maert) <- string.utf8.character.alpha() = string.utf8(maerts)
folding: string.utf8(maerts) <- string.utf8.character.period()
folded: string.utf8(maerts) <- string.utf8.character.period() = string.utf8(maerts.)
folding: string.utf8(maerts.) <- string.utf8.character.alpha()
folded: string.utf8(maerts.) <- string.utf8.character.alpha() = string.utf8(maerts.s)
folding: string.utf8(maerts.s) <- string.utf8.character.alpha()
folded: string.utf8(maerts.s) <- string.utf8.character.alpha() = string.utf8(maerts.so)
folding: string.utf8(maerts.so) <- string.utf8.character.alpha()
folded: string.utf8(maerts.so) <- string.utf8.character.alpha() = string.utf8(maerts.soe)
folding: string.utf8(maerts.soe) <- string.utf8.character.alpha()
folded: string.utf8(maerts.soe) <- string.utf8.character.alpha() = string.utf8(maerts.soen)
folding: source.package.name() <- string.utf8(maerts.soen)
folded: source.package.name() <- string.utf8(maerts.soen) = source.package.name(neos.stream)
folding: source.package.import() <- source.package.name(neos.stream)
folded: source.package.import() <- source.package.name(neos.stream) = source.package.import(neos.stream)
folding: source.package.import(neos.stream) <- source.package.import(neos.stream)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() = string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) = language.identifier(input)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) = language.identifier(print)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folded: source.package.import(neos.stream) <- source.package.import(neos.stream) = ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() = string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() = string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() = string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() = string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) = language.identifier(to_string)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() = string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() = string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() = string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() = string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() = string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() = string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) = language.identifier(to_integer)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() = string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) = language.identifier(input)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) = language.identifier(print)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
folding: string.utf8(d) <- string.utf8.character.alpha()
folded: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
folding: string.utf8(dd) <- string.utf8.character.alpha()
folded: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
folding: language.identifier() <- string.utf8(dda)
folded: language.identifier() <- string.utf8(dda) = language.identifier(add)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
folding: language.identifier() <- string.utf8(y)
folded: language.identifier() <- string.utf8(y) = language.identifier(y)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
folding: language.identifier() <- string.utf8(y)
folded: language.identifier() <- string.utf8(y) = language.identifier(y)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
folding: string.utf8(d) <- string.utf8.character.alpha()
folded: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
folding: string.utf8(dd) <- string.utf8.character.alpha()
folded: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
folding: language.identifier() <- string.utf8(dda)
folded: language.identifier() <- string.utf8(dda) = language.identifier(add)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(n)
folding: string.utf8(n) <- string.utf8.character.alpha()
folded: string.utf8(n) <- string.utf8.character.alpha() = string.utf8(ni)
folding: string.utf8(ni) <- string.utf8.character.alpha()
folded: string.utf8(ni) <- string.utf8.character.alpha() = string.utf8(nia)
folding: string.utf8(nia) <- string.utf8.character.alpha()
folded: string.utf8(nia) <- string.utf8.character.alpha() = string.utf8(niam)
folding: language.identifier() <- string.utf8(niam)
folded: language.identifier() <- string.utf8(niam) = language.identifier(main)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) = language.identifier(print)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
folding: string.utf8( ) <- string.utf8.character.alpha()
folded: string.utf8( ) <- string.utf8.character.alpha() = string.utf8(
folding: string.utf8( <- string.utf8.character.alpha()
folded: string.utf8( <- string.utf8.character.alpha() = string.utf8( :r)
folding: string.utf8( :r) <- string.utf8.character.alpha()
folded: string.utf8( :r) <- string.utf8.character.alpha() = string.utf8( :re)
folding: string.utf8( :re) <- string.utf8.character.alpha()
folded: string.utf8( :re) <- string.utf8.character.alpha() = string.utf8( :reg)
folding: string.utf8( :reg) <- string.utf8.character.alpha()
folded: string.utf8( :reg) <- string.utf8.character.alpha() = string.utf8( :rege)
folding: string.utf8( :rege) <- string.utf8.character.alpha()
folded: string.utf8( :rege) <- string.utf8.character.alpha() = string.utf8( :reget)
folding: string.utf8( :reget) <- string.utf8.character.alpha()
folded: string.utf8( :reget) <- string.utf8.character.alpha() = string.utf8( :regetn)
folding: string.utf8( :regetn) <- string.utf8.character.alpha()
folded: string.utf8( :regetn) <- string.utf8.character.alpha() = string.utf8( :regetni)
folding: string.utf8( :regetni) <- string.utf8.character.alpha()
folded: string.utf8( :regetni) <- string.utf8.character.alpha() = string.utf8( :regetni )
folding: string.utf8( :regetni ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni ) <- string.utf8.character.alpha() = string.utf8( :regetni e)
folding: string.utf8( :regetni e) <- string.utf8.character.alpha()
folded: string.utf8( :regetni e) <- string.utf8.character.alpha() = string.utf8( :regetni ev)
folding: string.utf8( :regetni ev) <- string.utf8.character.alpha()
folded: string.utf8( :regetni ev) <- string.utf8.character.alpha() = string.utf8( :regetni evi)
folding: string.utf8( :regetni evi) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evi) <- string.utf8.character.alpha() = string.utf8( :regetni evit)
folding: string.utf8( :regetni evit) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evit) <- string.utf8.character.alpha() = string.utf8( :regetni eviti)
folding: string.utf8( :regetni eviti) <- string.utf8.character.alpha()
folded: string.utf8( :regetni eviti) <- string.utf8.character.alpha() = string.utf8( :regetni evitis)
folding: string.utf8( :regetni evitis) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitis) <- string.utf8.character.alpha() = string.utf8( :regetni evitiso)
folding: string.utf8( :regetni evitiso) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitiso) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop)
folding: string.utf8( :regetni evitisop) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop )
folding: string.utf8( :regetni evitisop ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop ) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a)
folding: string.utf8( :regetni evitisop a) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a )
folding: string.utf8( :regetni evitisop a ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a ) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a r)
folding: string.utf8( :regetni evitisop a r) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a r) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a re)
folding: string.utf8( :regetni evitisop a re) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a re) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a ret)
folding: string.utf8( :regetni evitisop a ret) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a ret) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a retn)
folding: string.utf8( :regetni evitisop a retn) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a retn) <- string.utf8.character.alpha() = string.utf8( :regetni evitisop a retnE)
folding: string.utf8( :regetni evitisop a retnE) <- string.utf8( :regetni evitisop a retnE)
folded: string.utf8( :regetni evitisop a retnE) <- string.utf8( :regetni evitisop a retnE) = string.utf8(Enter a positive integer: )
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() = string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) = language.identifier(input)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) = language.identifier(print)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(()
folding: string.utf8(() <- string.utf8.character.alpha()
folded: string.utf8(() <- string.utf8.character.alpha() = string.utf8((i)
folding: string.utf8((i) <- string.utf8.character.alpha()
folded: string.utf8((i) <- string.utf8.character.alpha() = string.utf8((ic)
folding: string.utf8((ic) <- string.utf8.character.alpha()
folded: string.utf8((ic) <- string.utf8.character.alpha() = string.utf8((icc)
folding: string.utf8((icc) <- string.utf8.character.alpha()
folded: string.utf8((icc) <- string.utf8.character.alpha() = string.utf8((icca)
folding: string.utf8((icca) <- string.utf8.character.alpha()
folded: string.utf8((icca) <- string.utf8.character.alpha() = string.utf8((iccan)
folding: string.utf8((iccan) <- string.utf8.character.alpha()
folded: string.utf8((iccan) <- string.utf8.character.alpha() = string.utf8((iccano)
folding: string.utf8((iccano) <- string.utf8.character.alpha()
folded: string.utf8((iccano) <- string.utf8.character.alpha() = string.utf8((iccanob)
folding: string.utf8((iccanob) <- string.utf8.character.alpha()
folded: string.utf8((iccanob) <- string.utf8.character.alpha() = string.utf8((iccanobi)
folding: string.utf8((iccanobi) <- string.utf8.character.alpha()
folded: string.utf8((iccanobi) <- string.utf8.character.alpha() = string.utf8((iccanobiF)
folding: string.utf8((iccanobiF) <- string.utf8((iccanobiF)
folded: string.utf8((iccanobiF) <- string.utf8((iccanobiF) = string.utf8(Fibonacci()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
folding: string.utf8( ) <- string.utf8.character.alpha()
folded: string.utf8( ) <- string.utf8.character.alpha() = string.utf8( =)
folding: string.utf8( =) <- string.utf8.character.alpha()
folded: string.utf8( =) <- string.utf8.character.alpha() = string.utf8( = )
folding: string.utf8( = ) <- string.utf8.character.alpha()
folded: string.utf8( = ) <- string.utf8.character.alpha() = string.utf8( = ))
folding: string.utf8( = )) <- string.utf8( = ))
folded: string.utf8( = )) <- string.utf8( = )) = string.utf8() = )
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() = string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() = string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() = string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() = string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) = language.identifier(to_string)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() = string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() = string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() = string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() = string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() = string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() = string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) = language.identifier(to_integer)
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
folding: string.utf8() <- string.utf8.character.LF()
folded: string.utf8() <- string.utf8.character.LF() = string.utf8( )
folding: string.utf8( ) <- string.utf8( )
folded: string.utf8( ) <- string.utf8( ) = string.utf8( )
Compilation time: 336.892ms
neoscript]

Message ends.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
rosuav at gmail
Feb 11, 2021, 7:13 AM
Post #2 of 93 (539 views)
Permalink
On Thu, Feb 11, 2021 at 11:36 PM Mr Flibble
<flibble@i42.removethisbit.co.uk> wrote:
>
>
> Hi!
>
> I am starting work on creating a new Python implementation from scratch using "neos" my universal compiler that can compile any programming language.

Is it your intention to support all of Python's syntax and semantics,
or is this an unrelated language with mandatory strict type tags and a
severely restricted set of data types? For instance, can your neos
compile this code?

def power():
return (2**3**4**2) % 1000000000

from time import time
start = time()
print(power())
time = time() - start
print("Took %s seconds" % time)

On my system, I get this from CPython 3.10:
176561152
Took 0.1589798927307129 seconds

And this from PyPy:
176561152
Took 0.0233387947083 seconds

> I envision this implementation to be significantly faster than the currently extant Python implementations (which isn't a stretch given how poorly they perform).

Riiiiiight, yep, all existing Python implementations are terribly
slow. Go ahead then; run the code above, show me a better time, and of
course compare to what a recent off-the-shelf CPython can do on the
same hardware. Then see how PyPy performs at the same job.

> Sample neos session (parsing a fibonacci program, neoscript rather than Python in this case):

Is neoscript an intermediate language like RPython, used only to
implement the compiler, or are you actually transforming Python code
into neoscript?

ChrisA
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
drsalists at gmail
Feb 11, 2021, 8:31 AM
Post #3 of 93 (539 views)
Permalink
On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble <flibble@i42.removethisbit.co.uk>
wrote:

>
> Hi!
>
> I am starting work on creating a new Python implementation from scratch
> using "neos" my universal compiler that can compile any programming
> language. I envision this implementation to be significantly faster than
> the currently extant Python implementations (which isn't a stretch given
> how poorly they perform).
>

I'd like to encourage you to give this a go. It's a huge task, but it's
needed.

You may be interested in the approaches of Pypy, Cython, Shedskin and
Nuitka.

Pypy is a Python written in RPython, where RPython is a restricted subset
of Python 2. It can translate RPython to C, or JIT compile pretty full
Python code - 2.x or 3.x. It has trouble with C extension modules, as the
CPython API for extension modules is pretty leaky. CFFI appears to be the
big hope of fixing this problem, but most C extension modules still use the
CPython C extension Module API.

Cython transpiles a Python-like language to C. It allows you to intermix
Python datatypes and C datatypes; the more you use C datatypes, the faster
the result is. It can be slower if you aren't careful with your type
conversions, but it can be faster if used well. It has a really nice
--annotate option that shows how close to C your program is, line by line.

Shedskin transpiles an implicitly static subset of Python 2 to C++. It's a
great tool, but sadly it is unlikely to make the jump from Python 2 to
Python 3, and Python 3 is definitely the future of Python.

Nuitka is a Python -> C/C++ transpiler. I know little about it, but it
sounds kind of like what you're proposing. It's been focusing on
compatibility first, followed by performance.

Good luck!
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 9:45 AM
Post #4 of 93 (539 views)
Permalink
On 11/02/2021 15:13, Chris Angelico wrote:
> On Thu, Feb 11, 2021 at 11:36 PM Mr Flibble
> <flibble@i42.removethisbit.co.uk> wrote:
>>
>>
>> Hi!
>>
>> I am starting work on creating a new Python implementation from scratch using "neos" my universal compiler that can compile any programming language.
>
> Is it your intention to support all of Python's syntax and semantics,

Yes.

> or is this an unrelated language with mandatory strict type tags and a
> severely restricted set of data types? For instance, can your neos
> compile this code?

No. The neos universal compiler itself is language agnostic: a pre-requisite for the requirement to be able to compile any programming language.

>
> def power():
> return (2**3**4**2) % 1000000000
>
> from time import time
> start = time()
> print(power())
> time = time() - start
> print("Took %s seconds" % time)
>
> On my system, I get this from CPython 3.10:
> 176561152
> Took 0.1589798927307129 seconds
>
> And this from PyPy:
> 176561152
> Took 0.0233387947083 seconds
>
>> I envision this implementation to be significantly faster than the currently extant Python implementations (which isn't a stretch given how poorly they perform).
>
> Riiiiiight, yep, all existing Python implementations are terribly
> slow. Go ahead then; run the code above, show me a better time, and of
> course compare to what a recent off-the-shelf CPython can do on the
> same hardware. Then see how PyPy performs at the same job.

You are timing the arithmetic library rather than the interpreter.

>
>> Sample neos session (parsing a fibonacci program, neoscript rather than Python in this case):
>
> Is neoscript an intermediate language like RPython, used only to
> implement the compiler, or are you actually transforming Python code
> into neoscript?

neoscript is the neos reference language (i.e. not an intermediate language) and will be unrelated to the Python implementation.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 9:56 AM
Post #5 of 93 (539 views)
Permalink
On 11/02/2021 16:31, Dan Stromberg wrote:
> On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble <flibble@i42.removethisbit.co.uk>
> wrote:
>
>>
>> Hi!
>>
>> I am starting work on creating a new Python implementation from scratch
>> using "neos" my universal compiler that can compile any programming
>> language. I envision this implementation to be significantly faster than
>> the currently extant Python implementations (which isn't a stretch given
>> how poorly they perform).
>>
>
> I'd like to encourage you to give this a go. It's a huge task, but it's
> needed.

Actually it is a relatively small task due to the neos universal compiler's architectural design. If it was a large task I wouldn't be doing it.

>
> You may be interested in the approaches of Pypy, Cython, Shedskin and
> Nuitka.

I am not particularly interested in any of the existing implementations as they bear no relation to the design of my language agnostic universal compiler, runtime, VM and JIT; the only use they will have will be to disambiguate certain Python language constructs that I cannot disambiguate from documentation alone: this is a natural consequence of Python not being standardized; those steering the language need to grow a pair and get Python standardized preferably as an ISO Standard.

>
> Pypy is a Python written in RPython, where RPython is a restricted subset
> of Python 2. It can translate RPython to C, or JIT compile pretty full
> Python code - 2.x or 3.x. It has trouble with C extension modules, as the
> CPython API for extension modules is pretty leaky. CFFI appears to be the
> big hope of fixing this problem, but most C extension modules still use the
> CPython C extension Module API.

RPython doesn't interest me. neos will be using libffi for FFI.

>
> Cython transpiles a Python-like language to C. It allows you to intermix
> Python datatypes and C datatypes; the more you use C datatypes, the faster
> the result is. It can be slower if you aren't careful with your type
> conversions, but it can be faster if used well. It has a really nice
> --annotate option that shows how close to C your program is, line by line.

I don't agree with the concept of delivering C compilers to end users. The only compilers I think end users should be running are GPU shader compilers and byecode/JIT compilers such as neos.

>
> Shedskin transpiles an implicitly static subset of Python 2 to C++. It's a
> great tool, but sadly it is unlikely to make the jump from Python 2 to
> Python 3, and Python 3 is definitely the future of Python.

Not interested in that (see previous answer replacing "C" with "C++").

>
> Nuitka is a Python -> C/C++ transpiler. I know little about it, but it
> sounds kind of like what you're proposing. It's been focusing on
> compatibility first, followed by performance.

Bears no relation to neos architecture.

>
> Good luck!

Thanks for the sentiment but I am not relying on luck.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
rosuav at gmail
Feb 11, 2021, 10:03 AM
Post #6 of 93 (539 views)
Permalink
On Fri, Feb 12, 2021 at 4:52 AM Mr Flibble
<flibble@i42.removethisbit.co.uk> wrote:
>
> On 11/02/2021 15:13, Chris Angelico wrote:
> > On Thu, Feb 11, 2021 at 11:36 PM Mr Flibble
> > <flibble@i42.removethisbit.co.uk> wrote:
> >>
> >>
> >> Hi!
> >>
> >> I am starting work on creating a new Python implementation from scratch using "neos" my universal compiler that can compile any programming language.
> >
> > Is it your intention to support all of Python's syntax and semantics,
>
> Yes.
>
> > or is this an unrelated language with mandatory strict type tags and a
> > severely restricted set of data types? For instance, can your neos
> > compile this code?
>
> No. The neos universal compiler itself is language agnostic: a pre-requisite for the requirement to be able to compile any programming language.
>

Okay, cool, then I misunderstood the point of neoscript (I thought you
would compile Python to neoscript and then neoscript to binary).

As Dan says, go for it, give it a go. I think it'll give you a very
good demonstration of how CPython, and especially PyPy, are actually
highly performant languages :)

> You are timing the arithmetic library rather than the interpreter.

Hmm, I didn't call on any library functions. The crucial and
time-consuming operations were entirely implemented using operators on
constants.

(I also deliberately reused the name "time" in multiple ways, just to
stress-test anything that tries to restrict data types.)

In any case, it's not Python if it can't handle arbitrarily large
numbers. Python is an excellent language for mathematics.

ChrisA
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
rosuav at gmail
Feb 11, 2021, 10:06 AM
Post #7 of 93 (539 views)
Permalink
On Fri, Feb 12, 2021 at 5:01 AM Mr Flibble
<flibble@i42.removethisbit.co.uk> wrote:
>
> On 11/02/2021 16:31, Dan Stromberg wrote:
> > On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble <flibble@i42.removethisbit.co.uk>
> > wrote:
> >
> >>
> >> Hi!
> >>
> >> I am starting work on creating a new Python implementation from scratch
> >> using "neos" my universal compiler that can compile any programming
> >> language. I envision this implementation to be significantly faster than
> >> the currently extant Python implementations (which isn't a stretch given
> >> how poorly they perform).
> >>
> >
> > I'd like to encourage you to give this a go. It's a huge task, but it's
> > needed.
>
> Actually it is a relatively small task due to the neos universal compiler's architectural design. If it was a large task I wouldn't be doing it.
>
> >
> > You may be interested in the approaches of Pypy, Cython, Shedskin and
> > Nuitka.
>
> I am not particularly interested in any of the existing implementations as they bear no relation to the design of my language agnostic universal compiler, runtime, VM and JIT; the only use they will have will be to disambiguate certain Python language constructs that I cannot disambiguate from documentation alone: this is a natural consequence of Python not being standardized; those steering the language need to grow a pair and get Python standardized preferably as an ISO Standard.
>

You keep insulting Python and the Python devs. Put up or shut up -
show some actual code before you make too many boasts.

Python DOES have a strong language specification. Its semantics are
documented. If you find places where the documentation is lacking,
point them out specifically, don't FUD your way through.

ChrisA
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 10:10 AM
Post #8 of 93 (539 views)
Permalink
On 11/02/2021 18:03, Chris Angelico wrote:

> In any case, it's not Python if it can't handle arbitrarily large
> numbers. Python is an excellent language for mathematics.

I am also creating Ada and Haskell implementations which have a similar requirement.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 10:14 AM
Post #9 of 93 (539 views)
Permalink
On 11/02/2021 18:06, Chris Angelico wrote:
> On Fri, Feb 12, 2021 at 5:01 AM Mr Flibble
> <flibble@i42.removethisbit.co.uk> wrote:
>>
>> On 11/02/2021 16:31, Dan Stromberg wrote:
>>> On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble <flibble@i42.removethisbit.co.uk>
>>> wrote:
>>>
>>>>
>>>> Hi!
>>>>
>>>> I am starting work on creating a new Python implementation from scratch
>>>> using "neos" my universal compiler that can compile any programming
>>>> language. I envision this implementation to be significantly faster than
>>>> the currently extant Python implementations (which isn't a stretch given
>>>> how poorly they perform).
>>>>
>>>
>>> I'd like to encourage you to give this a go. It's a huge task, but it's
>>> needed.
>>
>> Actually it is a relatively small task due to the neos universal compiler's architectural design. If it was a large task I wouldn't be doing it.
>>
>>>
>>> You may be interested in the approaches of Pypy, Cython, Shedskin and
>>> Nuitka.
>>
>> I am not particularly interested in any of the existing implementations as they bear no relation to the design of my language agnostic universal compiler, runtime, VM and JIT; the only use they will have will be to disambiguate certain Python language constructs that I cannot disambiguate from documentation alone: this is a natural consequence of Python not being standardized; those steering the language need to grow a pair and get Python standardized preferably as an ISO Standard.
>>
>
> You keep insulting Python and the Python devs. Put up or shut up -
> show some actual code before you make too many boasts.
>
> Python DOES have a strong language specification. Its semantics are
> documented. If you find places where the documentation is lacking,
> point them out specifically, don't FUD your way through.

For a language to transition from "toy" status it has to be formally standardized. It is unacceptable to define a language in terms of a particular implementation. A git repo of Source code and associated observable dynamic behaviour when that code is compiled and ran is a poor substitute for an official ISO Standard.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
pbryan at anode
Feb 11, 2021, 10:24 AM
Post #10 of 93 (539 views)
Permalink
On Thu, 2021-02-11 at 17:56 +0000, Mr Flibble wrote:

> Actually it is a relatively small task due to the neos universal
> compiler's architectural design.  If it was a large task I wouldn't
> be doing it.

When do you estimate this task will be completed?

> I am not particularly interested in any of the existing
> implementations as they bear no relation to the design of my language
> agnostic universal compiler, runtime, VM and JIT; the only use they
> will have will be to disambiguate certain Python language constructs
> that I cannot disambiguate from documentation alone: this is a
> natural consequence of Python not being standardized; those steering
> the language need to grow a pair and get Python standardized
> preferably as an ISO Standard.

I take it you don't hope to receive any support from those you're
insulting by such a statement?

> Thanks for the sentiment but I am not relying on luck.

By your conduct so far, I think you will also not be relying on the
goodwill of this community.

Paul

--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 10:29 AM
Post #11 of 93 (539 views)
Permalink
On 11/02/2021 18:24, Paul Bryan wrote:
> On Thu, 2021-02-11 at 17:56 +0000, Mr Flibble wrote:
>
>> Actually it is a relatively small task due to the neos universal
>> compiler's architectural design.  If it was a large task I wouldn't
>> be doing it.
>
> When do you estimate this task will be completed?
>
>> I am not particularly interested in any of the existing
>> implementations as they bear no relation to the design of my language
>> agnostic universal compiler, runtime, VM and JIT; the only use they
>> will have will be to disambiguate certain Python language constructs
>> that I cannot disambiguate from documentation alone: this is a
>> natural consequence of Python not being standardized; those steering
>> the language need to grow a pair and get Python standardized
>> preferably as an ISO Standard.
>
> I take it you don't hope to receive any support from those you're
> insulting by such a statement?
>
>> Thanks for the sentiment but I am not relying on luck.
>
> By your conduct so far, I think you will also not be relying on the
> goodwill of this community.

Personally I prefer telling it like it is (i.e. the truth) rather than walking on eggshells.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
python-list at python
Feb 11, 2021, 11:45 AM
Post #12 of 93 (539 views)
Permalink
On 12/02/2021 07.14, Mr Flibble wrote:
> On 11/02/2021 18:06, Chris Angelico wrote:
>> On Fri, Feb 12, 2021 at 5:01 AM Mr Flibble
>> <flibble@i42.removethisbit.co.uk> wrote:
>>>
>>> On 11/02/2021 16:31, Dan Stromberg wrote:
>>>> On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble
>>>> <flibble@i42.removethisbit.co.uk>
>>>> wrote:
>>>>
>>>>> I am starting work on creating a new Python implementation from
>>>>> scratch
... (which isn't a stretch given how poorly they perform).

>>>> I'd like to encourage you to give this a go.  It's a huge task, but
>>>> it's needed.
>>>
>>> Actually it is a relatively small task due to the neos universal
>>> compiler's architectural design.  If it was a large task I wouldn't
>>> be doing it.
>>>
>>>> You may be interested in...
>>>
>>> I am not particularly interested in any of the existing
>>> implementations as they bear no relation to the design of my language

...not being standardized; those steering
>>> the language need to grow a pair and get Python standardized
>>> preferably as an ISO Standard.
...
> For a language to transition from "toy" status it has to be formally
> standardized.  It is unacceptable to define a language in terms of a
> particular implementation. A git repo of Source code and associated
> observable dynamic behaviour when that code is compiled and ran is a
> poor substitute for an official ISO Standard.
>
> /Flibble


When I first met it, one of the concepts I found difficult to 'wrap my
head around' was the idea that "open software" allowed folk to fork the
original work and 'do their own thing'. My thinking was (probably)
"surely, the original is the authoritative version". Having other
versions seemed an invitation to confusion and dilution.

However, as soon as (open) software is made available, other people
start making it 'better' - whatever their own definition of "better".

Yes, it is both a joy and a complication.


Such is contrary to the principle of "standards". At its extreme, a
standard says there is only one way to do the-whatever. This is why many
'standard programming languages' then offer the 'out' of having various
levels of 'standard'. For example, despite being one of the longest
standardised languages, many COBOL implementations achieve only part of
"the standard" - and one has to dive (deep) into the 'small print' to
establish which 'bits' are in their particular 'pick and mix'. Yet, they
still (quite legally) refer to their product as 'standard'!

The second issue with standards is the time and effort it takes to
achieve an agreement and thus reach the point of publishing.

A third issue, and possibly the reason why attempting a standard is a
"losing battle", is that programming and languages are in a constant
state of flux - we call it "ongoing development". Even though Python
v3.10 is reaching a state of anticipation, there are organisations and
libraries that still work using Python 2. Thus, and HTML/"the browser
wars" is an example of this, as fast as a standard is discussed, someone
(even those contributing to said standards) is doing his/her best to
build 'more advanced features' beyond the standard... "Standards" and
'driving development forward' are at least in tension, at worst,
complete-opposites.

Standards, like "waterfall" project specifications, cannot be 'cast in
stone' because the world keeps changing. Standards are insufficiently
agile and Agile!


Whereas the likes of COBOL had "owners", if not as a point-of-fact, at
least in terms of (commercial) 'might' and 'power', Python has its
"Python Software Foundation" (https://www.python.org/psf/). Please feel
free to approach that group to talk about 'what is Python' and
'standardisation'.

Rather than a process of "imposing" a standard, Python has a more 'grass
roots' democratic process which involves PEPs (Python Enhancement
Proposal). These are 'great ideas', even intentions-to-build or
proofs-of-concept, documented, and presented for the community to
consider. The better ones make it through and become part of the
language and its eco-system.

Has the above proposal started on that 'standards path'? Is it
'documented', or merely an idea?


Another aspect of open source is its 'meritocracy' - respect for those
who have demonstrated their abilities (and commitment). Certain names
'crop-up' on PEPs, and more tellingly, on "accepted" PEPs.

Of the three names appearing in this thread, which two have been seen
before, and have contributed to PEPs or to this list, in the past?

Is there a choice to 'stand on the shoulders of giants', or to 'walk all
over ... in hob-nailed boots'? Has this conversation illustrated
respect, or (perhaps unintentionally) torn-down others' sweat-and-tears
without offering something (better) for consideration/approval/use? Is
there any proof that you/I/someone-else can actually "do" better? An
applicable saying is "the proof is in the pudding". So, rather than
claims, shouldn't we be dealing with facts, eg system-A does better than
system-B under the following conditions?


A community comprises people who are prepared to work towards some
commonality. Positivity and friendliness, ie 'honey', tend to work
better than 'vinegar'. Would you say that anything approaching "troll"
behavior is less-likely to achieve cohesion?

Few (successful) projects are managed by a single person. This list is a
great meeting-place to find others who might share your particular
interest - and further, who might be prepared to collaborate - as the
saying goes "scratch your own itch". Is this what you seek? Has the
choice of language/approach in this conversation been best-calculated to
'gather around' like-minded folk? Is there a difference between speaking
with determination and making a case, and being disrespectful of others?


Wishing you well. It seems (to (neos-ignorant) me at least) an ambitious
project. There are certainly times when 'execution speed' becomes a
major criteria. Many of us will look forward to (your development of) a
solution. Please let us know when it's ready for use/trials...




Personal comments:

1
Am admitting to a sense of wariness towards 'new' people who use a
made-up name - despite mine being somewhat obfuscated (NB calling
"David?" in any given community is likely to elicit multiple replies,
thus the "dn"/inviting colleagues to call me by my initials).

2
Noting a false (non-standard/RFC) email address, and consequently every
message's (non-standard) impact on the email-reflector.

3
My mind is whirling in an attempt to understand "show me a better time".
Does this perhaps indicate that @Chris' social life leaves something to
be desired? Are Python-nerds really the ones to turn-to for dating
advice, or is that not what @Chris means by "(having) a good time"?
--
Regards,
=dn
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
rosuav at gmail
Feb 11, 2021, 11:53 AM
Post #13 of 93 (539 views)
Permalink
On Fri, Feb 12, 2021 at 6:47 AM dn via Python-list
<python-list@python.org> wrote:
> 3
> My mind is whirling in an attempt to understand "show me a better time".
> Does this perhaps indicate that @Chris' social life leaves something to
> be desired? Are Python-nerds really the ones to turn-to for dating
> advice, or is that not what @Chris means by "(having) a good time"?

LOL! I was referring to the fact that my demonstration snippet
included a rudimentary timing bracket, and that, if existing Python
implementations are indeed abysmally slow, it should be possible to
run the same code on a different interpreter and get a lower number -
a "better" time being shorter.

ChrisA
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
python-list at python
Feb 11, 2021, 12:42 PM
Post #14 of 93 (539 views)
Permalink
On 12/02/2021 08.53, Chris Angelico wrote:
> On Fri, Feb 12, 2021 at 6:47 AM dn via Python-list
> <python-list@python.org> wrote:
>> 3
>> My mind is whirling in an attempt to understand "show me a better time".
>> Does this perhaps indicate that @Chris' social life leaves something to
>> be desired? Are Python-nerds really the ones to turn-to for dating
>> advice, or is that not what @Chris means by "(having) a good time"?
>
> LOL! I was referring to the fact that my demonstration snippet
> included a rudimentary timing bracket, and that, if existing Python
> implementations are indeed abysmally slow, it should be possible to
> run the same code on a different interpreter and get a lower number -
> a "better" time being shorter.


Agreed.

I've been 'bitten' by running 'the same' interpreter on different
hardware/configs and finding that one part of the program[me] ran faster
on the dev-machine, and another part faster on the prod-box. Felt a bit
like a no-win situation! Timing was an important contribution. However,
needing to perform same in-situ was a surprise. 'Gotcha'!

There are a lot of variables in the efficiency-game. It's not completely
cut-and-dried to say this, but as a general rule-of-thumb one does not
select Python for applications/components which have significant
execution-time constraints/requirements. However, Python is rarely
bettered when it comes to developer-time! Horses for courses...


As to being outrageously cheeky: even if COVID travel-restrictions have
been lifted, knowing the Tasman Sea remains between us,
allowed/emboldened me to go for the prize(?) for finding at least some
word-play to laugh-about in this whole conversation.

PS my version of bravery is that if you come after me carrying a big
stick, I shall run in the opposite direction - very quickly!

PPS speaking of travel: have you taken advantage of any of the
"vouchers" offered by your (Fed?State) government as an economic
stimulus/recovery for the hospitality industry?
--
Regards,
=dn
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
drsalists at gmail
Feb 11, 2021, 1:13 PM
Post #15 of 93 (539 views)
Permalink
On Thu, Feb 11, 2021 at 10:21 AM Mr Flibble <flibble@i42.removethisbit.co.uk>
wrote:

> For a language to transition from "toy" status it has to be formally
> standardized. It is unacceptable to define a language in terms of a
> particular implementation. A git repo of Source code and associated
> observable dynamic behaviour when that code is compiled and ran is a poor
> substitute for an official ISO Standard.
>
I'm inclined to agree, though Python has done surprisingly well at
fostering multiple implementations despite having a reference
implementation for so long.

The thing it'd probably help the most with, is slowly down the rate of
change in the language. The Core Devs seem to want to improve CPython
rapidly, which is not great for the many other implementations - EG Jython
and IronPython. Also, "improvements" in CPython are frequently tending
toward featuritis, since the complexity of a language tends to grow with
the square of its feature count.

Does your project have a name yet? I'd like to follow it through google
alerts or an announcement mailing list.
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 1:58 PM
Post #16 of 93 (539 views)
Permalink
On 11/02/2021 21:13, Dan Stromberg wrote:
> Does your project have a name yet? I'd like to follow it through google
> alerts or an announcement mailing list.

"neos" - https://neos.dev/ https://github.com/i42output/neos

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
RE: New Python implementation [ In reply to ]
python-list at python
Feb 11, 2021, 2:22 PM
Post #17 of 93 (538 views)
Permalink
I may be the only one who does not deal well with a condescending attitude.

I have to wonder what international standards body ever completes a task in finite time, only to find the real world has moved on. Having standards can be a great idea. When the standard does not properly describe any implementations either because some leave out things and others have partial or enhanced implementations, then it is just a goal.

May I ask if the proposed product itself needs standardization? Since it claims to support many (or amusingly ANY) language fully, perhaps they can share their Ada or other version before they do Python, or are they working on all of them at once?

Realistically, many languages have chosen various paths and a model that captures them all will have to be fairly complex and perhaps needlessly complex. Does it need multiple ways to deal with issues like scope and perhaps keep track of that if a program crosses several boundaries? Will it be able to handle something like an R program running a package that allows a parallel running of a Python program as they work jointly on the same or copied data structures? I have been writing those lately and in the future may incorporate additional languages to take advantage of the strengths and features of each while avoiding the weaknesses or missing aspects of another.

Anyone who considers the task specified to be a small problem is either brilliant or perhaps not well informed.

If they can do what they say well, great. But I have seen other such attempts such as finding a way to translate between word processor formats that try to deal with overlapping but different concepts and do imperfect translations. That may of course not be relevant here if what is produced is code that runs and yet follows the expected rules as if it was being interpreted.
But a more pleasant attitude may make the same points, not that I am sure what those are and what is being asked. It sounds more like being told.

-----Original Message-----
From: Python-list <python-list-bounces+avigross=verizon.net@python.org> On Behalf Of Mr Flibble
Sent: Thursday, February 11, 2021 1:15 PM
To: python-list@python.org
Subject: Re: New Python implementation

On 11/02/2021 18:06, Chris Angelico wrote:
> On Fri, Feb 12, 2021 at 5:01 AM Mr Flibble
> <flibble@i42.removethisbit.co.uk> wrote:
>>
>> On 11/02/2021 16:31, Dan Stromberg wrote:
>>> On Thu, Feb 11, 2021 at 4:35 AM Mr Flibble
>>> <flibble@i42.removethisbit.co.uk>
>>> wrote:
>>>
>>>>
>>>> Hi!
>>>>
>>>> I am starting work on creating a new Python implementation from
>>>> scratch using "neos" my universal compiler that can compile any
>>>> programming language. I envision this implementation to be
>>>> significantly faster than the currently extant Python
>>>> implementations (which isn't a stretch given how poorly they perform).
>>>>
>>>
>>> I'd like to encourage you to give this a go. It's a huge task, but
>>> it's needed.
>>
>> Actually it is a relatively small task due to the neos universal compiler's architectural design. If it was a large task I wouldn't be doing it.
>>
>>>
>>> You may be interested in the approaches of Pypy, Cython, Shedskin
>>> and Nuitka.
>>
>> I am not particularly interested in any of the existing implementations as they bear no relation to the design of my language agnostic universal compiler, runtime, VM and JIT; the only use they will have will be to disambiguate certain Python language constructs that I cannot disambiguate from documentation alone: this is a natural consequence of Python not being standardized; those steering the language need to grow a pair and get Python standardized preferably as an ISO Standard.
>>
>
> You keep insulting Python and the Python devs. Put up or shut up -
> show some actual code before you make too many boasts.
>
> Python DOES have a strong language specification. Its semantics are
> documented. If you find places where the documentation is lacking,
> point them out specifically, don't FUD your way through.

For a language to transition from "toy" status it has to be formally standardized. It is unacceptable to define a language in terms of a particular implementation. A git repo of Source code and associated observable dynamic behaviour when that code is compiled and ran is a poor substitute for an official ISO Standard.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list

--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
drsalists at gmail
Feb 11, 2021, 2:25 PM
Post #18 of 93 (538 views)
Permalink
On Thu, Feb 11, 2021 at 2:00 PM Mr Flibble <flibble@i42.removethisbit.co.uk>
wrote:

> On 11/02/2021 21:13, Dan Stromberg wrote:
> > Does your project have a name yet? I'd like to follow it through google
> > alerts or an announcement mailing list.
>
> "neos" - https://neos.dev/ https://github.com/i42output/neos
>

Pypi already appears to have another project named neos:
https://pypi.org/project/neos/
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 2:33 PM
Post #19 of 93 (538 views)
Permalink
On 11/02/2021 22:25, Dan Stromberg wrote:
> On Thu, Feb 11, 2021 at 2:00 PM Mr Flibble <flibble@i42.removethisbit.co.uk>
> wrote:
>
>> On 11/02/2021 21:13, Dan Stromberg wrote:
>>> Does your project have a name yet? I'd like to follow it through google
>>> alerts or an announcement mailing list.
>>
>> "neos" - https://neos.dev/ https://github.com/i42output/neos
>>
>
> Pypi already appears to have another project named neos:
> https://pypi.org/project/neos/

neos isn't a Python package so that isn't a problem.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
greg.ewing at canterbury
Feb 11, 2021, 3:12 PM
Post #20 of 93 (538 views)
Permalink
On 12/02/21 11:33 am, Mr Flibble wrote:
> neos isn't a Python package so that isn't a problem.

It might be a bit confusing if it ever becomes part of the
wider Python ecosystem, though.

--
Greg
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 4:05 PM
Post #21 of 93 (538 views)
Permalink
On 11/02/2021 23:12, Greg Ewing wrote:
> On 12/02/21 11:33 am, Mr Flibble wrote:
>> neos isn't a Python package so that isn't a problem.
>
> It might be a bit confusing if it ever becomes part of the
> wider Python ecosystem, though.
Python is but one language that neos will implement.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 11, 2021, 4:06 PM
Post #22 of 93 (538 views)
Permalink
On 11/02/2021 23:05, Paul Rubin wrote:
> Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> writes:
>> "neos" - https://neos.dev/ https://github.com/i42output/neos
>
> Good luck, let us know when it is done. What is there doesn't look like
> a credible start so far, but maybe you will surprise us. Have you
> actually written any code in the languages you say you are going to
> support? E.g. Ada, Haskell, Rust. I'd agree that Python is fairly
> simple compared to those.

Not credible? On what do you base that analysis?

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
python-list at python
Feb 11, 2021, 4:15 PM
Post #23 of 93 (526 views)
Permalink
On 11/02/2021 12:30, Mr Flibble wrote:

> I am starting work on creating a new Python implementation
> from scratch using "neos" my universal compiler that can
> compile any programming language.

Can i clarify that?
Are you saying that you are going to recompile the existing
C code for pyhton using yoour universal compiler and the
resulting binary file will be a new implementation of
the interpreter that you expect to be faster?

That's what it sounds like to me.
In which case the question is not whether you can write a
better interpreter than CPython but whether you can write
a better compiler than GNU/MING/VC etc

While a universal compiler is certainly an interesting
and challenging project I'm not sure how much it tells us
about existing Python implementations.

On the other hand, if you are planning on rewriting the
existing interpreter in something other than C, what
is that something?

> Sample neos session (parsing a fibonacci program,
> neoscript rather than Python in this case):

I'm not sure what relevance this has unless you want
to rewrite Python in neoscript? Or are you translating
the C into neoscript and then compiling it? But in a
later response you seem to say neoscript was not involved?

Slightly confused...

--
Alan G
Author of the Learn to Program web site
http://www.alan-g.me.uk/
http://www.amazon.com/author/alan_gauld
Follow my photo-blog on Flickr at:
http://www.flickr.com/photos/alangauldphotos


--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
tjreedy at udel
Feb 11, 2021, 6:45 PM
Post #24 of 93 (526 views)
Permalink
On 2/11/2021 5:33 PM, Mr Flibble wrote:
> On 11/02/2021 22:25, Dan Stromberg wrote:
>> On Thu, Feb 11, 2021 at 2:00 PM Mr Flibble
>> <flibble@i42.removethisbit.co.uk>
>> wrote:
>>
>>> On 11/02/2021 21:13, Dan Stromberg wrote:
>>>> Does your project have a name yet?  I'd like to follow it through
>>>> google
>>>> alerts or an announcement mailing list.
>>>
>>> "neos" - https://neos.dev/ https://github.com/i42output/neos
>>>
>>
>> Pypi already appears to have another project named neos:
>> https://pypi.org/project/neos/
>
> neos isn't a Python package so that isn't a problem.

Since it obviously is a Python package, as in importable into a Python
program, why do you deny it?

--
Terry Jan Reedy


--
https://mail.python.org/mailman/listinfo/python-list
Re: New Python implementation [ In reply to ]
flibble at i42
Feb 12, 2021, 1:42 PM
Post #25 of 93 (526 views)
Permalink
On 12/02/2021 02:45, Terry Reedy wrote:
> On 2/11/2021 5:33 PM, Mr Flibble wrote:
>> On 11/02/2021 22:25, Dan Stromberg wrote:
>>> On Thu, Feb 11, 2021 at 2:00 PM Mr Flibble <flibble@i42.removethisbit.co.uk>
>>> wrote:
>>>
>>>> On 11/02/2021 21:13, Dan Stromberg wrote:
>>>>> Does your project have a name yet?  I'd like to follow it through google
>>>>> alerts or an announcement mailing list.
>>>>
>>>> "neos" - https://neos.dev/ https://github.com/i42output/neos
>>>>
>>>
>>> Pypi already appears to have another project named neos:
>>> https://pypi.org/project/neos/
>>
>> neos isn't a Python package so that isn't a problem.
>
> Since it obviously is a Python package, as in importable into a Python program, why do you deny it?

You are mistaken: it isn't a Python package and it isn't importable into a Python program.

/Flibble

--
????
--
https://mail.python.org/mailman/listinfo/python-list
1 2 3 4  View All

©2024 GT.net. A Gossamer Threads company.
5th Floor, 455 Granville St., Vancouver, BC V6C 1T1, Canada | Legal