Is

Is is an esoteric programming language invented by User:A which operates on two separate memory components: a scalar bit value and a potentially infinite bit array.
==Commands==
i	Increment the current bit, contingently wrapping around.
s	Set the whole array into the pointed bit's value. At the program's start, all array elements are set to 0. If the modification repeats forever, then it will overflow.
==Examples==
===Truth-machine===
For input = 1, the code is:
 is
Set into:
 111111111111.......(which is the normal print 1 forever)
For input = 0, the code is:
 s
set into:
 000000000000.......(which is 0.It is impossible to only make one 0, unless the array only had 1 bit)
==Computability==
It can implement a Truth-machine.
But, it has no if statements! And repetition! And I/O! But, it even passed the test!!!
I am sure the Truth-machine is useless for testing all those characteristics.
==Interpreter==
An interpreter in the programming language Common Lisp shall be adduced:
 (defclass Memory ()
 ()
 (:documentation
 "Establishes an interface for all classes pursuing the modeling of
 an Is program memory's cell array component."))
 
 ;;; -------------------------------------------------------
 
 (defclass Infinite-Memory (Memory)
 ((cells
 :initform (make-array 0
 :element-type 'bit
 :initial-element 0
 :adjustable T
 :fill-pointer T)
 :type bit-vector
 :documentation "A resizable bit vector which simulates an
 \"infinite\" binary array."))
 (:documentation
 "Simulates an infinite vector of bits utilizing a dynamically
 resizing array."))
 
 ;;; -------------------------------------------------------
 
 (defclass Fixed-Size-Memory (Memory)
 ((cells
 :initarg :cells
 :type simple-bit-vector
 :documentation "A fixed-size array of bits."))
 (:documentation
 "Realizes a fixed-size vector of bits."))
 
 ;;; -------------------------------------------------------
 
 (defun make-infinite-memory ()
 "Creates and returns a fresh ``Infinite-Memory instance."
 (the Infinite-Memory (make-instance 'Infinite-Memory)))
 
 ;;; -------------------------------------------------------
 
 (defun make-fixed-size-memory (size)
 "Creates and returns a fresh ``Fixed-Size-Memory of the desiderated
 SIZE."
 (declare (type fixnum size))
 (the Fixed-Size-Memory
 (make-instance 'Fixed-Size-Memory :cells
 (make-array size
 :element-type 'bit
 :initial-element 0
 :adjustable NIL
 :fill-pointer NIL))))
 
 ;;; -------------------------------------------------------
 
 (defgeneric set-memory-cells-to (memory new-value)
 (:documentation
 "Stores the NEW-VALUE in all of the MEMORY's cells, concomitantly
 printing each cell's new state, and returns no value.")
 
 (:method ((memory Infinite-Memory) (new-value integer))
 (declare (type Infinite-Memory memory))
 (declare (type bit new-value))
 (with-slots (cells) memory
 (declare (type bit-vector cells))
 (loop
 for cell-index of-type fixnum
 = 0 then (mod (1+ cell-index) array-total-size-limit)
 do (when (>= cell-index (length cells))
 (vector-push-extend 0 cells))
 (setf (bit cells cell-index) new-value)
 (format T "~d" (bit cells cell-index))))
 (values))
 
 (:method ((memory Fixed-Size-Memory) (new-value integer))
 (declare (type Fixed-Size-Memory memory))
 (declare (type bit new-value))
 (with-slots (cells) memory
 (declare (type simple-bit-vector cells))
 (loop for cell-index of-type fixnum from 0 below (length cells) do
 (setf (sbit cells cell-index) new-value)
 (format T "~d" (sbit cells cell-index))))
 (values)))
 
 ;;; -------------------------------------------------------
 
 (defun interpret-Is (code &optional (memory (make-infinite-memory)))
 "Interprets the piece of Is source CODE, potentially deploying a
 bespoke MEMORY model, and returns no value."
 (declare (type string code))
 (let ((ip 0)
 (current-bit 0))
 (declare (type fixnum ip)
 (type bit current-bit))
 (symbol-macrolet
 ((current-character
 (the character
 (char code ip)))
 (program-has-completed-p
 (the boolean
 (not (array-in-bounds-p code ip)))))
 (declare (type character current-character)
 (type boolean program-has-completed-p))
 (loop until program-has-completed-p do
 (case current-character
 ((#\Space #\Tab #\Newline #\Return)
 NIL)
 (#\i
 (setf current-bit (- 1 current-bit)))
 (#\s
 (set-memory-cells-to memory current-bit))
 (otherwise
 (error "Invalid character \"~c\" at position ~d."
 current-character ip)))
 (incf ip))))
 (values))
 
 ;;; -------------------------------------------------------
 
 ;; Simulate a truth-machine with an input of "1":
 (interpret-is "is")
 
 ;; Simulate a truth-machine with an input of "0":
 (interpret-is "s" (make-fixed-size-memory 1))
 
Category:Languages
Category:No IO
Category:2018