Demo of semantic concept folding in "neos" my universal compiler!

[Mr Flibble]

Hi!

Here is an example session demoing neos semantic concept folding working!
As I write this the only concept to support folding is the string concept
from character concepts. I will have a busy bank holiday weekend
implement more concepts!

Scroll down to bottom for listing of program being compiled.

neos 1.0.0.0 ED-209
Loading schema 'neoscript.neos'...
Language: Default neoGFX scripting language
Version: 1.0.0
Copyright (C) 2019 Leigh Johnston
prefold: <3: line 3, col 6> language.keyword ()
prefold: <4: line 3, col 7> string.utf8.character.alpha (n)
prefold: <5: line 3, col 8> string.utf8.character.alpha (e)
prefold: <5: line 3, col 9> string.utf8.character.alpha (o)
prefold: <5: line 3, col 10> string.utf8.character.alpha (s)
prefold: <5: line 3, col 11> string.utf8.character.period (.)
prefold: <6: line 3, col 12> string.utf8.character.alpha (s)
prefold: <7: line 3, col 13> string.utf8.character.alpha (t)
prefold: <7: line 3, col 14> string.utf8.character.alpha (r)
prefold: <7: line 3, col 15> string.utf8.character.alpha (i)
prefold: <7: line 3, col 16> string.utf8.character.alpha (n)
prefold: <7: line 3, col 17> string.utf8.character.alpha (g)
prefold: <4: line 3, col 18> module.package.name ()
prefold: <3: line 3, col 18> module.package.import ()
prefold: <3: line 3, col 18> module.package.instantiate ()
prefold: <3: line 4, col 6> language.keyword ()
prefold: <4: line 4, col 7> string.utf8.character.alpha (n)
prefold: <5: line 4, col 8> string.utf8.character.alpha (e)
prefold: <5: line 4, col 9> string.utf8.character.alpha (o)
prefold: <5: line 4, col 10> string.utf8.character.alpha (s)
prefold: <5: line 4, col 11> string.utf8.character.period (.)
prefold: <6: line 4, col 12> string.utf8.character.alpha (s)
prefold: <7: line 4, col 13> string.utf8.character.alpha (t)
prefold: <7: line 4, col 14> string.utf8.character.alpha (r)
prefold: <7: line 4, col 15> string.utf8.character.alpha (e)
prefold: <7: line 4, col 16> string.utf8.character.alpha (a)
prefold: <7: line 4, col 17> string.utf8.character.alpha (m)
prefold: <4: line 4, col 18> module.package.name ()
prefold: <3: line 4, col 18> module.package.import ()
prefold: <3: line 4, col 18> module.package.instantiate ()
prefold: <3: line 6, col 7> language.keyword ()
prefold: <4: line 6, col 10> language.keyword ()
prefold: <5: line 6, col 11> string.utf8.character.alpha (t)
prefold: <6: line 6, col 12> string.utf8.character.alpha (o)
prefold: <6: line 6, col 13> string.utf8.character.underscore (_)
prefold: <6: line 6, col 14> string.utf8.character.alpha (s)
prefold: <6: line 6, col 15> string.utf8.character.alpha (t)
prefold: <6: line 6, col 16> string.utf8.character.alpha (r)
prefold: <6: line 6, col 17> string.utf8.character.alpha (i)
prefold: <6: line 6, col 18> string.utf8.character.alpha (n)
prefold: <6: line 6, col 19> string.utf8.character.alpha (g)
prefold: <5: line 6, col 20> string.utf8 ()
prefold: <5: line 6, col 20> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
fold: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
fold: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
fold: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
fold: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
fold: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
fold: string.utf8(gnirts) <- string.utf8.character.underscore() =
string.utf8(gnirts_)
fold: string.utf8(gnirts_) <- string.utf8.character.alpha() =
string.utf8(gnirts_o)
fold: string.utf8(gnirts_o) <- string.utf8.character.alpha() =
string.utf8(gnirts_ot)
fold: string.utf8(gnirts_ot) <- string.utf8(gnirts_ot) =
string.utf8(to_string)
prefold: <10: line 6, col 21> string.utf8.character.alpha (x)
prefold: <10: line 6, col 22> string.utf8 ()
prefold: <10: line 6, col 22> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <9: line 6, col 22> language.function.parameter ()
prefold: <11: line 6, col 28> language.type.i32 ()
prefold: <7: line 6, col 28> language.function.parameters ()
prefold: <10: line 6, col 39> language.type.string ()
prefold: <9: line 6, col 39> language.function.return ()
prefold: <4: line 6, col 39> language.function.signature ()
prefold: <4: line 6, col 40> language.function.import ()
prefold: <3: line 7, col 7> language.keyword ()
prefold: <4: line 7, col 10> language.keyword ()
prefold: <5: line 7, col 11> string.utf8.character.alpha (t)
prefold: <6: line 7, col 12> string.utf8.character.alpha (o)
prefold: <6: line 7, col 13> string.utf8.character.underscore (_)
prefold: <6: line 7, col 14> string.utf8.character.alpha (i)
prefold: <6: line 7, col 15> string.utf8.character.alpha (n)
prefold: <6: line 7, col 16> string.utf8.character.alpha (t)
prefold: <6: line 7, col 17> string.utf8.character.alpha (e)
prefold: <6: line 7, col 18> string.utf8.character.alpha (g)
prefold: <6: line 7, col 19> string.utf8.character.alpha (e)
prefold: <6: line 7, col 20> string.utf8.character.alpha (r)
prefold: <5: line 7, col 21> string.utf8 ()
prefold: <5: line 7, col 21> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
fold: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
fold: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
fold: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
fold: string.utf8(rege) <- string.utf8.character.alpha() = string.utf8(reget)
fold: string.utf8(reget) <- string.utf8.character.alpha() =
string.utf8(regetn)
fold: string.utf8(regetn) <- string.utf8.character.alpha() =
string.utf8(regetni)
fold: string.utf8(regetni) <- string.utf8.character.underscore() =
string.utf8(regetni_)
fold: string.utf8(regetni_) <- string.utf8.character.alpha() =
string.utf8(regetni_o)
fold: string.utf8(regetni_o) <- string.utf8.character.alpha() =
string.utf8(regetni_ot)
fold: string.utf8(regetni_ot) <- string.utf8(regetni_ot) =
string.utf8(to_integer)
prefold: <10: line 7, col 22> string.utf8.character.alpha (s)
prefold: <10: line 7, col 23> string.utf8 ()
prefold: <10: line 7, col 23> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <9: line 7, col 23> language.function.parameter ()
prefold: <11: line 7, col 32> language.type.string ()
prefold: <7: line 7, col 32> language.function.parameters ()
prefold: <10: line 7, col 40> language.type.i32 ()
prefold: <9: line 7, col 40> language.function.return ()
prefold: <4: line 7, col 40> language.function.signature ()
prefold: <4: line 7, col 41> language.function.import ()
prefold: <3: line 8, col 7> language.keyword ()
prefold: <4: line 8, col 12> language.keyword ()
prefold: <5: line 8, col 13> string.utf8.character.alpha (i)
prefold: <6: line 8, col 14> string.utf8.character.alpha (n)
prefold: <6: line 8, col 15> string.utf8.character.alpha (p)
prefold: <6: line 8, col 16> string.utf8.character.alpha (u)
prefold: <6: line 8, col 17> string.utf8.character.alpha (t)
prefold: <5: line 8, col 18> string.utf8 ()
prefold: <5: line 8, col 18> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
fold: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
fold: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
fold: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
fold: string.utf8(tupn) <- string.utf8.character.alpha() = string.utf8(tupni)
fold: string.utf8(tupni) <- string.utf8(tupni) = string.utf8(input)
prefold: <10: line 8, col 19> string.utf8.character.alpha (s)
prefold: <10: line 8, col 20> string.utf8 ()
prefold: <10: line 8, col 20> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <9: line 8, col 20> language.function.parameter ()
prefold: <11: line 8, col 26> language.keyword ()
prefold: <10: line 8, col 26> language.function.parameter.direction.out ()
prefold: <12: line 8, col 33> language.type.string ()
prefold: <7: line 8, col 33> language.function.parameters ()
prefold: <4: line 8, col 34> language.function.signature ()
prefold: <4: line 8, col 35> language.function.import ()
prefold: <3: line 9, col 7> language.keyword ()
prefold: <4: line 9, col 12> language.keyword ()
prefold: <5: line 9, col 13> string.utf8.character.alpha (p)
prefold: <6: line 9, col 14> string.utf8.character.alpha (r)
prefold: <6: line 9, col 15> string.utf8.character.alpha (i)
prefold: <6: line 9, col 16> string.utf8.character.alpha (n)
prefold: <6: line 9, col 17> string.utf8.character.alpha (t)
prefold: <5: line 9, col 18> string.utf8 ()
prefold: <5: line 9, col 18> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
fold: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
fold: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
fold: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
fold: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
fold: string.utf8(tnirp) <- string.utf8(tnirp) = string.utf8(print)
prefold: <10: line 9, col 19> string.utf8.character.alpha (s)
prefold: <10: line 9, col 20> string.utf8 ()
prefold: <10: line 9, col 20> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <9: line 9, col 20> language.function.parameter ()
prefold: <11: line 9, col 25> language.keyword ()
prefold: <10: line 9, col 25> language.function.parameter.direction.in ()
prefold: <12: line 9, col 32> language.type.string ()
prefold: <7: line 9, col 32> language.function.parameters ()
prefold: <4: line 9, col 33> language.function.signature ()
prefold: <4: line 9, col 34> language.function.import ()
prefold: <3: line 12, col 4> language.keyword ()
prefold: <4: line 12, col 7> language.keyword ()
prefold: <5: line 12, col 8> string.utf8.character.alpha (a)
prefold: <6: line 12, col 9> string.utf8.character.alpha (d)
prefold: <6: line 12, col 10> string.utf8.character.alpha (d)
prefold: <5: line 12, col 11> string.utf8 ()
prefold: <5: line 12, col 11> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
fold: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
fold: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
fold: string.utf8(dda) <- string.utf8(dda) = string.utf8(add)
prefold: <10: line 12, col 12> string.utf8.character.alpha (x)
prefold: <10: line 12, col 13> string.utf8 ()
prefold: <10: line 12, col 13> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <9: line 12, col 13> language.function.parameter ()
prefold: <12: line 12, col 15> string.utf8.character.alpha (y)
prefold: <12: line 12, col 16> string.utf8 ()
prefold: <12: line 12, col 16> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
fold: string.utf8(y) <- string.utf8(y) = string.utf8(y)
prefold: <11: line 12, col 16> language.function.parameter ()
prefold: <13: line 12, col 22> language.type.i32 ()
prefold: <7: line 12, col 22> language.function.parameters ()
prefold: <10: line 12, col 30> language.type.i32 ()
prefold: <9: line 12, col 30> language.function.return ()
prefold: <4: line 12, col 30> language.function.signature ()
prefold: <8: line 14, col 11> language.keyword ()
prefold: <13: line 14, col 12> string.utf8.character.alpha (x)
prefold: <13: line 14, col 13> string.utf8 ()
prefold: <13: line 14, col 13> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <12: line 14, col 14> math.expression.operand ()
prefold: <15: line 14, col 16> string.utf8.character.alpha (y)
prefold: <15: line 14, col 17> string.utf8 ()
prefold: <15: line 14, col 17> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
fold: string.utf8(y) <- string.utf8(y) = string.utf8(y)
prefold: <14: line 14, col 17> math.expression.operand ()
prefold: <10: line 14, col 15> math.operator.add ()
prefold: <9: line 14, col 17> math.expression ()
prefold: <9: line 14, col 18> language.function.return ()
prefold: <7: line 14, col 18> language.statement ()
prefold: <5: line 15, col 2> language.function.scope ()
prefold: <4: line 15, col 2> language.function ()
prefold: <3: line 16, col 4> language.keyword ()
prefold: <4: line 16, col 7> language.keyword ()
prefold: <5: line 16, col 8> string.utf8.character.alpha (f)
prefold: <6: line 16, col 9> string.utf8.character.alpha (i)
prefold: <6: line 16, col 10> string.utf8.character.alpha (b)
prefold: <5: line 16, col 11> string.utf8 ()
prefold: <5: line 16, col 11> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
fold: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
fold: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
fold: string.utf8(bif) <- string.utf8(bif) = string.utf8(fib)
prefold: <10: line 16, col 12> string.utf8.character.alpha (x)
prefold: <10: line 16, col 13> string.utf8 ()
prefold: <10: line 16, col 13> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <9: line 16, col 13> language.function.parameter ()
prefold: <11: line 16, col 19> language.type.i32 ()
prefold: <7: line 16, col 19> language.function.parameters ()
prefold: <10: line 16, col 27> language.type.i32 ()
prefold: <9: line 16, col 27> language.function.return ()
prefold: <4: line 16, col 27> language.function.signature ()
prefold: <8: line 18, col 7> language.keyword ()
prefold: <17: line 18, col 9> string.utf8.character.alpha (x)
prefold: <17: line 18, col 10> string.utf8 ()
prefold: <17: line 18, col 10> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <16: line 18, col 11> math.expression.operand ()
prefold: <13: line 18, col 11> math.expression ()
prefold: <12: line 18, col 11> boolean.expression.operand ()
prefold: <18: line 18, col 13> math.universal.number.digit (2)
prefold: <18: line 18, col 14> math.universal.number ()
prefold: <18: line 18, col 14> math.expression.operand ()
prefold: <15: line 18, col 14> math.expression ()
prefold: <14: line 18, col 14> boolean.expression.operand ()
prefold: <12: line 18, col 12> boolean.operator.relational.lessthan ()
prefold: <10: line 18, col 14> boolean.expression ()
prefold: <13: line 19, col 15> language.keyword ()
prefold: <17: line 19, col 16> math.universal.number.digit (1)
prefold: <17: line 19, col 17> math.universal.number ()
prefold: <17: line 19, col 17> math.expression.operand ()
prefold: <14: line 19, col 17> math.expression ()
prefold: <14: line 19, col 18> language.function.return ()
prefold: <12: line 19, col 18> language.statement ()
prefold: <11: line 19, col 18> logic.operator.if ()
prefold: <14: line 20, col 9> language.keyword ()
prefold: <16: line 21, col 15> language.keyword ()
prefold: <21: line 21, col 16> string.utf8.character.alpha (a)
prefold: <22: line 21, col 17> string.utf8.character.alpha (d)
prefold: <22: line 21, col 18> string.utf8.character.alpha (d)
prefold: <21: line 21, col 19> string.utf8 ()
prefold: <21: line 21, col 19> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
fold: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
fold: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
fold: string.utf8(dda) <- string.utf8(dda) = string.utf8(add)
prefold: <27: line 21, col 20> string.utf8.character.alpha (f)
prefold: <28: line 21, col 21> string.utf8.character.alpha (i)
prefold: <28: line 21, col 22> string.utf8.character.alpha (b)
prefold: <27: line 21, col 23> string.utf8 ()
prefold: <27: line 21, col 23> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
fold: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
fold: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
fold: string.utf8(bif) <- string.utf8(bif) = string.utf8(fib)
prefold: <33: line 21, col 24> string.utf8.character.alpha (x)
prefold: <33: line 21, col 25> string.utf8 ()
prefold: <33: line 21, col 25> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <32: line 21, col 25> math.expression.operand ()
prefold: <34: line 21, col 26> math.universal.number.digit (1)
prefold: <34: line 21, col 27> math.universal.number ()
prefold: <34: line 21, col 27> math.expression.operand ()
prefold: <30: line 21, col 26> math.operator.subtract ()
prefold: <29: line 21, col 27> math.expression ()
prefold: <28: line 21, col 27> language.function.argument ()
prefold: <29: line 21, col 28> language.function.call ()
prefold: <26: line 21, col 28> math.expression.operand ()
prefold: <23: line 21, col 28> math.expression ()
prefold: <22: line 21, col 28> language.function.argument ()
prefold: <29: line 21, col 30> string.utf8.character.alpha (f)
prefold: <30: line 21, col 31> string.utf8.character.alpha (i)
prefold: <30: line 21, col 32> string.utf8.character.alpha (b)
prefold: <29: line 21, col 33> string.utf8 ()
prefold: <29: line 21, col 33> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
fold: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
fold: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
fold: string.utf8(bif) <- string.utf8(bif) = string.utf8(fib)
prefold: <35: line 21, col 34> string.utf8.character.alpha (x)
prefold: <35: line 21, col 35> string.utf8 ()
prefold: <35: line 21, col 35> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
fold: string.utf8(x) <- string.utf8(x) = string.utf8(x)
prefold: <34: line 21, col 35> math.expression.operand ()
prefold: <36: line 21, col 36> math.universal.number.digit (2)
prefold: <36: line 21, col 37> math.universal.number ()
prefold: <36: line 21, col 37> math.expression.operand ()
prefold: <32: line 21, col 36> math.operator.subtract ()
prefold: <31: line 21, col 37> math.expression ()
prefold: <30: line 21, col 37> language.function.argument ()
prefold: <31: line 21, col 38> language.function.call ()
prefold: <28: line 21, col 38> math.expression.operand ()
prefold: <25: line 21, col 38> math.expression ()
prefold: <24: line 21, col 38> language.function.argument ()
prefold: <25: line 21, col 39> language.function.call ()
prefold: <20: line 21, col 39> math.expression.operand ()
prefold: <17: line 21, col 39> math.expression ()
prefold: <17: line 21, col 40> language.function.return ()
prefold: <15: line 21, col 40> language.statement ()
prefold: <14: line 21, col 40> logic.operator.else ()
prefold: <7: line 21, col 40> language.statement ()
prefold: <5: line 22, col 2> language.function.scope ()
prefold: <4: line 22, col 2> language.function ()
prefold: <3: line 25, col 4> language.keyword ()
prefold: <4: line 25, col 9> language.keyword ()
prefold: <5: line 25, col 10> string.utf8.character.alpha (m)
prefold: <6: line 25, col 11> string.utf8.character.alpha (a)
prefold: <6: line 25, col 12> string.utf8.character.alpha (i)
prefold: <6: line 25, col 13> string.utf8.character.alpha (n)
prefold: <5: line 25, col 14> string.utf8 ()
prefold: <5: line 25, col 14> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(n)
fold: string.utf8(n) <- string.utf8.character.alpha() = string.utf8(ni)
fold: string.utf8(ni) <- string.utf8.character.alpha() = string.utf8(nia)
fold: string.utf8(nia) <- string.utf8.character.alpha() = string.utf8(niam)
fold: string.utf8(niam) <- string.utf8(niam) = string.utf8(main)
prefold: <4: line 25, col 16> language.function.signature ()
prefold: <8: line 26, col 5> string.utf8.character.alpha (s)
prefold: <8: line 26, col 6> string.utf8 ()
prefold: <8: line 26, col 6> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <7: line 26, col 6> language.function.local ()
prefold: <9: line 26, col 15> language.type.string ()
prefold: <5: line 26, col 16> language.function.locals ()
prefold: <5: line 27, col 1> language.function.locals ()
prefold: <13: line 28, col 5> string.utf8.character.alpha (p)
prefold: <14: line 28, col 6> string.utf8.character.alpha (r)
prefold: <14: line 28, col 7> string.utf8.character.alpha (i)
prefold: <14: line 28, col 8> string.utf8.character.alpha (n)
prefold: <14: line 28, col 9> string.utf8.character.alpha (t)
prefold: <13: line 28, col 10> string.utf8 ()
prefold: <13: line 28, col 10> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
fold: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
fold: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
fold: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
fold: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
fold: string.utf8(tnirp) <- string.utf8(tnirp) = string.utf8(print)
prefold: <20: line 28, col 12> string.utf8.character (E)
prefold: <20: line 28, col 13> string.utf8.character (n)
prefold: <20: line 28, col 14> string.utf8.character (t)
prefold: <20: line 28, col 15> string.utf8.character (e)
prefold: <20: line 28, col 16> string.utf8.character (r)
prefold: <20: line 28, col 17> string.utf8.character ( )
prefold: <20: line 28, col 18> string.utf8.character (a)
prefold: <20: line 28, col 19> string.utf8.character ( )
prefold: <20: line 28, col 20> string.utf8.character (p)
prefold: <20: line 28, col 21> string.utf8.character (o)
prefold: <20: line 28, col 22> string.utf8.character (s)
prefold: <20: line 28, col 23> string.utf8.character (i)
prefold: <20: line 28, col 24> string.utf8.character (t)
prefold: <20: line 28, col 25> string.utf8.character (i)
prefold: <20: line 28, col 26> string.utf8.character (v)
prefold: <20: line 28, col 27> string.utf8.character (e)
prefold: <20: line 28, col 28> string.utf8.character ( )
prefold: <23: line 29, col 14> string.utf8.character (i)
prefold: <23: line 29, col 15> string.utf8.character (n)
prefold: <23: line 29, col 16> string.utf8.character (t)
prefold: <23: line 29, col 17> string.utf8.character (e)
prefold: <23: line 29, col 18> string.utf8.character (g)
prefold: <23: line 29, col 19> string.utf8.character (e)
prefold: <23: line 29, col 20> string.utf8.character (r)
prefold: <23: line 29, col 21> string.utf8.character (:)
prefold: <23: line 29, col 22> string.utf8.character ( )
prefold: <19: line 29, col 24> string.utf8 ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
fold: string.utf8( ) <- string.utf8.character.alpha() = string.utf8( :)
fold: string.utf8( :) <- string.utf8.character.alpha() = string.utf8( :r)
fold: string.utf8( :r) <- string.utf8.character.alpha() = string.utf8( :re)
fold: string.utf8( :re) <- string.utf8.character.alpha() = string.utf8( :reg)
fold: string.utf8( :reg) <- string.utf8.character.alpha() = string.utf8(
:rege)
fold: string.utf8( :rege) <- string.utf8.character.alpha() = string.utf8(
:reget)
fold: string.utf8( :reget) <- string.utf8.character.alpha() = string.utf8(
:regetn)
fold: string.utf8( :regetn) <- string.utf8.character.alpha() =
string.utf8( :regetni)
fold: string.utf8( :regetni) <- string.utf8.character.alpha() =
string.utf8( :regetni )
fold: string.utf8( :regetni ) <- string.utf8.character.alpha() =
string.utf8( :regetni e)
fold: string.utf8( :regetni e) <- string.utf8.character.alpha() =
string.utf8( :regetni ev)
fold: string.utf8( :regetni ev) <- string.utf8.character.alpha() =
string.utf8( :regetni evi)
fold: string.utf8( :regetni evi) <- string.utf8.character.alpha() =
string.utf8( :regetni evit)
fold: string.utf8( :regetni evit) <- string.utf8.character.alpha() =
string.utf8( :regetni eviti)
fold: string.utf8( :regetni eviti) <- string.utf8.character.alpha() =
string.utf8( :regetni evitis)
fold: string.utf8( :regetni evitis) <- string.utf8.character.alpha() =
string.utf8( :regetni evitiso)
fold: string.utf8( :regetni evitiso) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop)
fold: string.utf8( :regetni evitisop) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop )
fold: string.utf8( :regetni evitisop ) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop a)
fold: string.utf8( :regetni evitisop a) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop a )
fold: string.utf8( :regetni evitisop a ) <- string.utf8.character.alpha()
= string.utf8( :regetni evitisop a r)
fold: string.utf8( :regetni evitisop a r) <- string.utf8.character.alpha()
= string.utf8( :regetni evitisop a re)
fold: string.utf8( :regetni evitisop a re) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a ret)
fold: string.utf8( :regetni evitisop a ret) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a retn)
fold: string.utf8( :regetni evitisop a retn) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a retnE)
fold: string.utf8( :regetni evitisop a retnE) <- string.utf8( :regetni
evitisop a retnE) = string.utf8(Enter a positive integer: )
prefold: <18: line 29, col 24> math.expression.operand ()
prefold: <15: line 29, col 24> math.expression ()
prefold: <14: line 29, col 24> language.function.argument ()
prefold: <15: line 29, col 25> language.function.call ()
prefold: <12: line 29, col 25> math.expression.operand ()
prefold: <9: line 29, col 25> math.expression ()
prefold: <8: line 29, col 25> language.statement ()
prefold: <9: line 29, col 26> language.function.return ()
prefold: <8: line 29, col 26> language.statement ()
prefold: <13: line 30, col 5> string.utf8.character.alpha (i)
prefold: <14: line 30, col 6> string.utf8.character.alpha (n)
prefold: <14: line 30, col 7> string.utf8.character.alpha (p)
prefold: <14: line 30, col 8> string.utf8.character.alpha (u)
prefold: <14: line 30, col 9> string.utf8.character.alpha (t)
prefold: <13: line 30, col 10> string.utf8 ()
prefold: <13: line 30, col 10> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
fold: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
fold: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
fold: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
fold: string.utf8(tupn) <- string.utf8.character.alpha() = string.utf8(tupni)
fold: string.utf8(tupni) <- string.utf8(tupni) = string.utf8(input)
prefold: <19: line 30, col 11> string.utf8.character.alpha (s)
prefold: <19: line 30, col 12> string.utf8 ()
prefold: <19: line 30, col 12> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <18: line 30, col 12> math.expression.operand ()
prefold: <15: line 30, col 12> math.expression ()
prefold: <14: line 30, col 12> language.function.argument ()
prefold: <15: line 30, col 13> language.function.call ()
prefold: <12: line 30, col 13> math.expression.operand ()
prefold: <9: line 30, col 13> math.expression ()
prefold: <8: line 30, col 13> language.statement ()
prefold: <9: line 30, col 14> language.function.return ()
prefold: <8: line 30, col 14> language.statement ()
prefold: <13: line 31, col 5> string.utf8.character.alpha (p)
prefold: <14: line 31, col 6> string.utf8.character.alpha (r)
prefold: <14: line 31, col 7> string.utf8.character.alpha (i)
prefold: <14: line 31, col 8> string.utf8.character.alpha (n)
prefold: <14: line 31, col 9> string.utf8.character.alpha (t)
prefold: <13: line 31, col 10> string.utf8 ()
prefold: <13: line 31, col 10> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
fold: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
fold: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
fold: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
fold: string.utf8(tnir) <- string.utf8.character.alpha() = string.utf8(tnirp)
fold: string.utf8(tnirp) <- string.utf8(tnirp) = string.utf8(print)
prefold: <20: line 31, col 12> string.utf8.character (F)
prefold: <20: line 31, col 13> string.utf8.character (i)
prefold: <20: line 31, col 14> string.utf8.character (b)
prefold: <20: line 31, col 15> string.utf8.character (o)
prefold: <20: line 31, col 16> string.utf8.character (n)
prefold: <20: line 31, col 17> string.utf8.character (a)
prefold: <20: line 31, col 18> string.utf8.character (c)
prefold: <20: line 31, col 19> string.utf8.character (c)
prefold: <20: line 31, col 20> string.utf8.character (i)
prefold: <20: line 31, col 21> string.utf8.character (()
prefold: <19: line 31, col 24> string.utf8 ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(()
fold: string.utf8(() <- string.utf8.character.alpha() = string.utf8((i)
fold: string.utf8((i) <- string.utf8.character.alpha() = string.utf8((ic)
fold: string.utf8((ic) <- string.utf8.character.alpha() = string.utf8((icc)
fold: string.utf8((icc) <- string.utf8.character.alpha() = string.utf8((icca)
fold: string.utf8((icca) <- string.utf8.character.alpha() =
string.utf8((iccan)
fold: string.utf8((iccan) <- string.utf8.character.alpha() =
string.utf8((iccano)
fold: string.utf8((iccano) <- string.utf8.character.alpha() =
string.utf8((iccanob)
fold: string.utf8((iccanob) <- string.utf8.character.alpha() =
string.utf8((iccanobi)
fold: string.utf8((iccanobi) <- string.utf8.character.alpha() =
string.utf8((iccanobiF)
fold: string.utf8((iccanobiF) <- string.utf8((iccanobiF) =
string.utf8(Fibonacci()
prefold: <18: line 31, col 24> math.expression.operand ()
prefold: <21: line 31, col 26> string.utf8.character.alpha (s)
prefold: <21: line 31, col 27> string.utf8 ()
prefold: <21: line 31, col 27> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <20: line 31, col 28> math.expression.operand ()
prefold: <16: line 31, col 25> math.operator.add ()
prefold: <24: line 31, col 31> string.utf8.character ())
prefold: <24: line 31, col 32> string.utf8.character (:)
prefold: <24: line 31, col 33> string.utf8.character ( )
prefold: <23: line 31, col 36> string.utf8 ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
fold: string.utf8( ) <- string.utf8.character.alpha() = string.utf8( :)
fold: string.utf8( :) <- string.utf8.character.alpha() = string.utf8( :))
fold: string.utf8( :)) <- string.utf8( :)) = string.utf8(): )
prefold: <22: line 31, col 36> math.expression.operand ()
prefold: <18: line 31, col 29> math.operator.add ()
prefold: <25: line 31, col 38> string.utf8.character.alpha (t)
prefold: <26: line 31, col 39> string.utf8.character.alpha (o)
prefold: <26: line 31, col 40> string.utf8.character.underscore (_)
prefold: <26: line 31, col 41> string.utf8.character.alpha (s)
prefold: <26: line 31, col 42> string.utf8.character.alpha (t)
prefold: <26: line 31, col 43> string.utf8.character.alpha (r)
prefold: <26: line 31, col 44> string.utf8.character.alpha (i)
prefold: <26: line 31, col 45> string.utf8.character.alpha (n)
prefold: <26: line 31, col 46> string.utf8.character.alpha (g)
prefold: <25: line 31, col 47> string.utf8 ()
prefold: <25: line 31, col 47> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
fold: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
fold: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
fold: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
fold: string.utf8(gnir) <- string.utf8.character.alpha() = string.utf8(gnirt)
fold: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
fold: string.utf8(gnirts) <- string.utf8.character.underscore() =
string.utf8(gnirts_)
fold: string.utf8(gnirts_) <- string.utf8.character.alpha() =
string.utf8(gnirts_o)
fold: string.utf8(gnirts_o) <- string.utf8.character.alpha() =
string.utf8(gnirts_ot)
fold: string.utf8(gnirts_ot) <- string.utf8(gnirts_ot) =
string.utf8(to_string)
prefold: <31: line 31, col 48> string.utf8.character.alpha (f)
prefold: <32: line 31, col 49> string.utf8.character.alpha (i)
prefold: <32: line 31, col 50> string.utf8.character.alpha (b)
prefold: <31: line 31, col 51> string.utf8 ()
prefold: <31: line 31, col 51> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
fold: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
fold: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
fold: string.utf8(bif) <- string.utf8(bif) = string.utf8(fib)
prefold: <37: line 31, col 52> string.utf8.character.alpha (t)
prefold: <38: line 31, col 53> string.utf8.character.alpha (o)
prefold: <38: line 31, col 54> string.utf8.character.underscore (_)
prefold: <38: line 31, col 55> string.utf8.character.alpha (i)
prefold: <38: line 31, col 56> string.utf8.character.alpha (n)
prefold: <38: line 31, col 57> string.utf8.character.alpha (t)
prefold: <38: line 31, col 58> string.utf8.character.alpha (e)
prefold: <38: line 31, col 59> string.utf8.character.alpha (g)
prefold: <38: line 31, col 60> string.utf8.character.alpha (e)
prefold: <38: line 31, col 61> string.utf8.character.alpha (r)
prefold: <37: line 31, col 62> string.utf8 ()
prefold: <37: line 31, col 62> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
fold: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
fold: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
fold: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
fold: string.utf8(rege) <- string.utf8.character.alpha() = string.utf8(reget)
fold: string.utf8(reget) <- string.utf8.character.alpha() =
string.utf8(regetn)
fold: string.utf8(regetn) <- string.utf8.character.alpha() =
string.utf8(regetni)
fold: string.utf8(regetni) <- string.utf8.character.underscore() =
string.utf8(regetni_)
fold: string.utf8(regetni_) <- string.utf8.character.alpha() =
string.utf8(regetni_o)
fold: string.utf8(regetni_o) <- string.utf8.character.alpha() =
string.utf8(regetni_ot)
fold: string.utf8(regetni_ot) <- string.utf8(regetni_ot) =
string.utf8(to_integer)
prefold: <43: line 31, col 63> string.utf8.character.alpha (s)
prefold: <43: line 31, col 64> string.utf8 ()
prefold: <43: line 31, col 64> language.identifier ()
fold: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
fold: string.utf8(s) <- string.utf8(s) = string.utf8(s)
prefold: <42: line 31, col 64> math.expression.operand ()
prefold: <39: line 31, col 64> math.expression ()
prefold: <38: line 31, col 64> language.function.argument ()
prefold: <39: line 31, col 65> language.function.call ()
prefold: <36: line 31, col 65> math.expression.operand ()
prefold: <33: line 31, col 65> math.expression ()
prefold: <32: line 31, col 65> language.function.argument ()
prefold: <33: line 31, col 66> language.function.call ()
prefold: <30: line 31, col 66> math.expression.operand ()
prefold: <27: line 31, col 66> math.expression ()
prefold: <26: line 31, col 66> language.function.argument ()
prefold: <27: line 31, col 67> language.function.call ()
prefold: <24: line 31, col 67> math.expression.operand ()
prefold: <20: line 31, col 37> math.operator.add ()
prefold: <30: line 31, col 73> string.utf8.character.LF ()
prefold: <27: line 31, col 74> string.utf8 ()
fold: string.utf8() <- string.utf8.character.LF() = string.utf8(
)
fold: string.utf8(
) <- string.utf8(
) = string.utf8(
)
prefold: <26: line 31, col 74> math.expression.operand ()
prefold: <22: line 31, col 69> math.operator.add ()
prefold: <15: line 31, col 74> math.expression ()
prefold: <14: line 31, col 74> language.function.argument ()
prefold: <15: line 31, col 75> language.function.call ()
prefold: <12: line 31, col 75> math.expression.operand ()
prefold: <9: line 31, col 75> math.expression ()
prefold: <8: line 31, col 75> language.statement ()
prefold: <9: line 31, col 76> language.function.return ()
prefold: <8: line 31, col 76> language.statement ()
prefold: <6: line 32, col 2> language.function.scope ()
prefold: <5: line 32, col 2> language.function ()
Compilation time: 566.517ms
neoscript]
neoscript]cte 0
neoscript]l examples/neoscript/fibonacci.neo
Compilation time: 46.531ms
neoscript]l examples/neoscript/fibonacci.neo
Compilation time: 45.957ms
neoscript]l examples/neoscript/fibonacci.neo
Compilation time: 46.498ms
neoscript]
neoscript]list
-- 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]

/Flibble

--
“You won’t burn in hell. But be nice anyway.” – Ricky Gervais

“I see Atheists are fighting and killing each other again, over who
doesn’t believe in any God the most. Oh, no..wait.. that never happens.” –
Ricky Gervais

"Suppose it's all true, and you walk up to the pearly gates, and are
confronted by God," Bryne asked on his show The Meaning of Life. "What
will Stephen Fry say to him, her, or it?"
"I'd say, bone cancer in children? What's that about?" Fry replied.
"How dare you? How dare you create a world to which there is such misery
that is not our fault. It's not right, it's utterly, utterly evil."
"Why should I respect a capricious, mean-minded, stupid God who creates a
world that is so full of injustice and pain. That's what I would say."

[Bart]

On 25/05/2019 23:49, Mr Flibble wrote:

> Here is an example session demoing neos semantic concept folding
> working! As I write this the only concept to support folding is the
> string concept from character concepts.

That's great - but what does it mean?

> def fn fib(x : i32) -> i32
> {
>     if (x < 2)
>         return 1;
>     else
>         return add(fib(x-1), fib(x-2));

Any reason you can't use "+" here, or is this just to exercise more of
the language? Because "+" seems to work for strings.

>     print("Fibonacci(" + s + "): " + to_string(fib(to_integer(s))) +

(For a scripting language, this looks rather clunky. But maybe it's
early days.)

[Mr Flibble]

On 26/05/2019 00:37, Bart wrote:
>
> (For a scripting language, this looks rather clunky. But maybe it's early
> days.)

I think you are missing the point: creating a scripting language is
secondary to what I am actually doing which is creating a universal
compiler that can compile any programming language.

[Bart]

On 26/05/2019 01:05, Mr Flibble wrote:
> On 26/05/2019 00:37, Bart wrote:
>>
>> (For a scripting language, this looks rather clunky. But maybe it's
>> early days.)
>
> I think you are missing the point: creating a scripting language is
> secondary to what I am actually doing which is creating a universal
> compiler that can compile any programming language.

Well, OK, I think many are sceptical about that.

To implement a language, you need something that describes or dictates
its syntax and semantics and features (plus a bunch of things you didn't
know it needed until you start a project like yours), stuff that
normally takes the form of a discrete, dedicated compiler. And a
discrete, dedicated interpreter for some languages. And a discrete,
dedicated something else for others.

You want to be able to represent that as data instead of code, fed into
a single universal program.

My experience of such things tells me that it is likely to be much
better to have lots of streamlined, dedicated programs that work
properly, than one giant program that tries to do everything, and does
it badly.

I've recently tried to combine two languages into one hybrid language.
That didn't really work - while I could have taken it to a conclusion,
it would have been poor. Instead the languages are distinct (two
compilers, which need to work very differently as one needs to be highly
dynamic), but are yet closely integrated.

And this is just two languages - which share syntax.

[Mr Flibble]

Just because you failed to get something to work it doesn't mean I will. I
know what I am doing. I am NOT creating "one giant program that tries to
do everything, and does it badly" and I am NOT "combining languages into a
hybrid language". I hate having to repeat myself but it seems I must: I am
making a universal compiler that can compile any programming language,
nothing more, nothing less.

[Melzzzzz]

Besto of luck!
>
> /Flibble
>


--
press any key to continue or any other to quit...
U ničemu ja ne uživam kao u svom statusu INVALIDA -- Zli Zec
Na divljem zapadu i nije bilo tako puno nasilja, upravo zato jer su svi
bili naoruzani. -- Mladen Gogala

[Bart]

On 26/05/2019 02:14, Mr Flibble wrote:

> On 26/05/2019 01:31, Bart wrote:

>> I've recently tried to combine two languages into one hybrid language.
>> That didn't really work - while I could have taken it to a conclusion,
>> it would have been poor. Instead the languages are distinct (two
>> compilers, which need to work very differently as one needs to be
>> highly dynamic), but are yet closely integrated.
>>
>> And this is just two languages - which share syntax.
>
> Just because you failed to get something to work it doesn't mean I will.
> I know what I am doing. I am NOT creating "one giant program that tries
> to do everything, and does it badly" and I am NOT "combining languages
> into a hybrid language". I hate having to repeat myself but it seems I
> must: I am making a universal compiler that can compile any programming
> language, nothing more, nothing less.

It won't be able to compile one of mine without some input from me that
tells you how.

Does it make much difference whether that input is a data file, or an
executable program (a compiler)? You will need something different for
each language, in the same way that you might need a different compiler
for each one.

But I can see some difficulty in describing everything about a language
purely using data. (Think of what's necessary in describing exactly how
the C macro preprocessor works using tables. Or how you would describe
the C include-file search algorithm. Or the ad-hoc logic needed to
compile of mine.) You need code.

[Mr Flibble]

My universal compiler is turing complete. It will be able to compile your
programming language as it can compile ANY programming language.

[Bart]

On 26/05/2019 11:52, Mr Flibble wrote:

> My universal compiler is turing complete. It will be able to compile
> your programming language as it can compile ANY programming language.

I'm not sure that makes sense, nor that that conclusion follows.

Just about every /language/ is Turing complete, and can therefore also
be used to implement any program including any compiler of any language.
There's just the small matter of writing that program.

[leigh.v....@googlemail.com]

The fact that you fail to grasp what I am doing doesn't change the fact that I am writing a universal compiler that can compile any programming language including yours.

/Leigh

[blt_ac...@023mckkh70e4ypdabual021.com]

On Sun, 26 May 2019 02:14:02 +0100
Mr Flibble <flibbleREM...@i42.co.uk> wrote:
>On 26/05/2019 01:31, Bart wrote:
>> I've recently tried to combine two languages into one hybrid language.
>> That didn't really work - while I could have taken it to a conclusion, it
>> would have been poor. Instead the languages are distinct (two compilers,
>> which need to work very differently as one needs to be highly dynamic),
>> but are yet closely integrated.
>>
>> And this is just two languages - which share syntax.
>
>Just because you failed to get something to work it doesn't mean I will. I
>know what I am doing. I am NOT creating "one giant program that tries to
>do everything, and does it badly" and I am NOT "combining languages into a
>hybrid language". I hate having to repeat myself but it seems I must: I am
>making a universal compiler that can compile any programming language,
>nothing more, nothing less.

Either you're
A) Suffering from a lack of sleep and running on caffeine
B) Having a manic episode or
C) Trolling

Take your pick.

And if your genius idea is to have some kind of plug in front end per language
that talks to a common back end, errr, thats been done for years.

[blt_9uc...@70_uwd4gabhkv.gov]

Probably not a coincidence that you call yourself Mr Flibble (except in the
above post, wrong identity selected?) since you're beginning to sound like
Rimmer when he went mad in that red dwarf episode.

[Mr Flibble]

On 26/05/2019 15:47, blt_ac...@023mckkh70e4ypdabual021.com wrote:
> On Sun, 26 May 2019 02:14:02 +0100
> Mr Flibble <flibbleREM...@i42.co.uk> wrote:
>> On 26/05/2019 01:31, Bart wrote:
>>> I've recently tried to combine two languages into one hybrid language.
>>> That didn't really work - while I could have taken it to a conclusion, it
>>> would have been poor. Instead the languages are distinct (two compilers,
>>> which need to work very differently as one needs to be highly dynamic),
>>> but are yet closely integrated.
>>>
>>> And this is just two languages - which share syntax.
>>
>> Just because you failed to get something to work it doesn't mean I will. I
>> know what I am doing. I am NOT creating "one giant program that tries to
>> do everything, and does it badly" and I am NOT "combining languages into a
>> hybrid language". I hate having to repeat myself but it seems I must: I am
>> making a universal compiler that can compile any programming language,
>> nothing more, nothing less.
>
> Either you're
> A) Suffering from a lack of sleep and running on caffeine
> B) Having a manic episode or
> C) Trolling
>
> Take your pick.

You forgot:

D) Telling the truth because you are that good.

And the correct answer would be:

D

>
> And if your genius idea is to have some kind of plug in front end per language
> that talks to a common back end, errr, thats been done for years.

Plugins are part of the solution but not in the way you suggest so what I
am doing, I believe, hasn't been done before. I am cleanrooming this
project and with it I hope to turn all "established" compiler theory on
its head. This will be a paradigm shift and perhaps even a technological
singularity in the world of computer software.

[Mr Flibble]

Red Dwarf episode "Quarantine" did indeed feature a mad Rimmer and of
course Mr Flibble but I will NOT be requiring the luck virus to implement
my universal compiler that can compile any programming language.

[blt_p...@dxcqkj09bcv1ov6dntww.edu]

On Sun, 26 May 2019 15:58:29 +0100

I'll assume that D is actually a laugh smiley.

>> And if your genius idea is to have some kind of plug in front end per
>language
>> that talks to a common back end, errr, thats been done for years.
>
>Plugins are part of the solution but not in the way you suggest so what I
>am doing, I believe, hasn't been done before. I am cleanrooming this
>project and with it I hope to turn all "established" compiler theory on
>its head. This will be a paradigm shift and perhaps even a technological
>singularity in the world of computer software.

Sure, and while you're at it you'll solve P vs NP and create world peace.

Let us know when its done so we can bask in your magnificence.

[Mr Flibble]

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄░░░░░░░░░
░░░░░░░░▄▀░░░░░░░░░░░░▄░░░░░░░▀▄░░░░░░░
░░░░░░░░█░░▄░░░░▄░░░░░░░░░░░░░░█░░░░░░░
░░░░░░░░█░░░░░░░░░░░░▄█▄▄░░▄░░░█░▄▄▄░░░
░▄▄▄▄▄░░█░░░░░░▀░░░░▀█░░▀▄░░░░░█▀▀░██░░
░██▄▀██▄█░░░▄░░░░░░░██░░░░▀▀▀▀▀░░░░██░░
░░▀██▄▀██░░░░░░░░▀░██▀░░░░░░░░░░░░░▀██░
░░░░▀████░▀░░░░▄░░░██░░░▄█░░░░▄░▄█░░██░
░░░░░░░▀█░░░░▄░░░░░██░░░░▄░░░▄░░▄░░░██░
░░░░░░░▄█▄░░░░░░░░░░░▀▄░░▀▀▀▀▀▀▀▀░░▄▀░░
░░░░░░█▀▀█████████▀▀▀▀████████████▀░░░░
░░░░░░████▀░░███▀░░░░░░▀███░░▀██▀░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

[Bart]

On 26/05/2019 15:58, Mr Flibble wrote:
> On 26/05/2019 15:47, blt_ac...@023mckkh70e4ypdabual021.com wrote:

>> And if your genius idea is to have some kind of plug in front end per
>> language
>> that talks to a common back end, errr, thats been done for years.
>
> Plugins are part of the solution but not in the way you suggest so what
> I am doing, I believe, hasn't been done before.  I am cleanrooming this
> project and with it I hope to turn all "established" compiler theory on
> its head.

Even ordinary compilers can be complex and large bits of software (look
at the monstrous llvm). Your sounds like it would have to be as complex
as the worst of those.

By contrast, my current compiler project will be one of the simplest
that I've tackled (and mine are generally simple): it will make the task
of compilation not only appear effortless, but actually be effortless.
Also one of the fastest to compile (and mine are already fast).

Compiler theory doesn't come into it (I've been doing this stuff too
long to need any formal theory).

[Mr Flibble]

On 26/05/2019 21:24, Bart wrote:
> On 26/05/2019 15:58, Mr Flibble wrote:
>> On 26/05/2019 15:47, blt_ac...@023mckkh70e4ypdabual021.com wrote:
>
>>> And if your genius idea is to have some kind of plug in front end per
>>> language
>>> that talks to a common back end, errr, thats been done for years.
>>
>> Plugins are part of the solution but not in the way you suggest so what
>> I am doing, I believe, hasn't been done before.  I am cleanrooming this
>> project and with it I hope to turn all "established" compiler theory on
>> its head.
>
> Even ordinary compilers can be complex and large bits of software (look at
> the monstrous llvm). Your sounds like it would have to be as complex as
> the worst of those.

"Sounds like" you are assuming things based on nothing and you know what
they say about assumptions.

>
> By contrast, my current compiler project will be one of the simplest that
> I've tackled (and mine are generally simple): it will make the task of
> compilation not only appear effortless, but actually be effortless. Also
> one of the fastest to compile (and mine are already fast).
>
> Compiler theory doesn't come into it (I've been doing this stuff too long
> to need any formal theory).

I can happily say that I haven't been writing compilers "too long" because
focusing on just one thing is a mistake: you are doing it wrong, m8.