古人說︰熟讀唐詩三百首，不會作詩也會吟。就像能寫小說的少，會讀小說的多。鏡花緣演繹『熟能生巧』，自有其理也。

 

─── 《L4K ︰ 通往 PYTHON 的道路 ── RUR-PLE 斟酌》

 

祇為一時手癢，好奇 MarioLANG 如何『打招呼』呢？

Good sample programs

Is anyone willing to make any of the classic program examples in this language, like Hello World, Cat Programs, or working 99 Bottles programs? —JWinslow23 (talk) 18:23, 21 September 2013 (UTC)

I created a Hello World program (hoping MarioLANG won’t crash when faced with ＄s and letter characters).

               MarioLANG Hello World    <
         = =============================^<
           |   Created by JWinslow23   |=^<
         = ==============================="=
++++++++++
========== =
          >)+++++++)++++++++++)+++)+((((-[!)++.)+.
         =================================#======= =
  .------.+++.).+++++++++++++++((.++).+++..+++++++<
= ==================================================
 >--------.)+.).
================ =        |*
                         
      
      
 
      
 
               =========== ======

Anyone have any others? —JWinslow23 (talk) 19:31, 21 September 2013 (UTC)

I suspect the letters will work fine as the spec says unknown characters are comments. I am more uncertain about your castle made of elevators. 😛

However, the original author never fleshed out everything exactly, and hasn’t been seen in 3 years. His website is dead (and not on Wayback) and I don’t remember him making any interpreter, so in my opinion whoever actually makes one gets to decide the missing details. —Ørjan (talk) 23:42, 21 September 2013 (UTC)

Oerjan, I didn’t mean to make the castle out of elevators. I’ll change it to more semantics.rkt
#lang racket

(provide (all-defined-out))

(struct env (memory heading skip?) #:mutable #:transparent)
(struct mem (byte previous next) #:mutable)
(struct cell (char [left #:mutable] [up #:mutable] [right #:mutable] [down #:mutable])
#:prefab)

(define (new-env)
(env (mem 0 #f #f) ‘right #f))

(define (decrease-pointer env)
(let ([pos (env-memory env)])
(when (eq? (mem-previous pos) #f)
(set-mem-previous! pos (mem 0 #f pos)))
(set-env-memory! env (mem-previous pos))
env))

(define (increase-pointer env)
(let ([pos (env-memory env)])
(when (eq? (mem-next pos) #f)
(set-mem-next! pos (mem 0 pos #f)))
(set-env-memory! env (mem-next pos))
env))

(define (update-byte! env func)
(let ([memory (env-memory env)])
(set-mem-byte! memory (func (mem-byte memory)))))
…
(define (exec-instruction cell env)
(if (env-skip? env)
(set-env-skip?! env #f)
(case (cell-char cell)
[(#\+) (update-byte! env add1)]
[(#\-) (update-byte! env sub1)]
[(#) (increase-pointer env)]
[(#\.) (write-byte (mem-byte (env-memory env))) (flush-output)]
[(#\:) (write-string (format “~a” (mem-byte (env-memory env))) (current-output-por
t))]
[(#\,) (set-mem-byte! (env-memory env) (read-byte (current-input-port)))]
[(#\;) (set-mem-byte! (env-memory env) (read (current-input-port)))]
[(#\>) (set-env-heading! env ‘right)]
[(#\<) (set-env-heading! env ‘left)]
[(#\@) (set-env-heading! env (case (env-heading env)
[(right) ‘left] [(left) ‘right]
[else (env-heading env)]))]
[(#\!) (set-env-heading! env #f)]
[(#\[) (when (= (mem-byte (env-memory env)) 0)
(set-env-skip?! env #t))])))
…
 

莫非這樣仍巧得

Turing-complete

Relationship to computation

One of the more common misconceptions about Turing-completeness is that it is something that is required to perform any sort of computations (and that, conversely, any system that can perform some computations is Turing-complete.)

This is not the case when talking about a restricted set of computations. A finite-state automaton, for example, can be constructed which computes the Ackermann function f(m, n) for 1 < m < 1000 and 1 < n < 1000. In fact, such an evaluation could be stored in a million-cell lookup table.

This issue is further explored in the next section.

Relationship to the physical world

Turing-completeness applies to abstract systems (such as languages and formal automata) but not to real ones (such as computers and interpreters.) Physical machines have the following properties:

• they do not have unbounded storage space; and
• they eventually break down.

For these reasons, it should be obvious that no actual computer can be Turing-complete. However, it is also obvious that physical computers are perfectly capable of performing practical, finite computations in spite of that.

By extension, implementations of languages (compilers and interpreters) on physical computers are also not Turing-complete, but are nonetheless capable of specifying computations.

Therefore, it can be useful to make a distinction between being “usable for computation” and being Turing-complete. A language can be “usable for computation” while not being Turing-complete; all Turing-complete systems are “usable for computation”, however.

SMETANA is “usable for computation”, in that it is limited only by the code size of the program one chooses to write. Arguments have been made that Malbolge is also “usable for computation.”

A formal definition of “usable for computation” is currently being sought.

Overspecification

Often, a programming language is “after the fact” in that its specification comes from an attempt to describe the behavior of an implementation of that language.

As has just been noted, such implementations, being based as they are on physical machines, cannot be Turing-complete. So when this is done, there is a danger that the language will be overspecified, and that limitations of the physical machine will be reflected in the description of the language. This, often needlessly, causes the language to fail to be Turing-complete.

An interesting example of this is the C programming language. The C specification requires an integer result from sizeof() operator. The sizeof() operator’s result is an unsigned integer, of type size_t, for ANSI C, or an int or long for traditional C. The range of these integers is bounded. Since the sizeof() any object in a C implementation must be a finite size, then C cannot be Turing-complete, because it cannot address an unbounded storage space.

There are sometimes ways out of this. If a language specification requires that the size of some address (for example) be “implementation-dependent but no less than 16 bits” then one can argue that there exists an “implementation” where the size of addresses is unbounded, and that this “implementation” is Turing-complete. (That is, provided that the concept of an “implementation” which can never be implemented on a real computer is unproblematic.)

………

 

『歸結』耶？