History variables: Difference between revisions

demonstrate how this might be implemented.

<br><br>

 

=={{header|Ada}}==

Specification:

 

generic

type Item_Type (<>) is private;

History: Vectors.Vector;

end record;

 

The implementation of "History_Variables":

 

 

-- set and get

end Undo;

 

 

 

===Sample 1: The History of an Integer Variable===

 

 

procedure Test_History is

Ada.Text_IO.Put_Line(Integer'Image(Sum));

 

 

{{out}}

===Sample 2: The History of a String===

 

 

procedure Test_History is

Ada.Text_IO.Put_Line(Integer'Image(Sum));

 

 

{{out}}

Algol W does not have history variables as standard, as with other languages here, we can add them using a simple linked list.

<br>As Algol W does not have generic types, a separate history variable type would be required for each type of variable.

% implements integer history variables %

% similar history types could be defined for other types of variable %

write( "Sum of the historic values: ", s )

end

{{out}}

<pre>

Sum of the historic values: 6

</pre>

 

=={{header|AspectJ}}==

AspectJ implementation for Java 7.

Type of the history variable (Java class):

{

private Object value;

{

}

Aspect (HistoryHandling.aj):

import java.util.HashMap;

import java.util.LinkedList;

 

private Map<HistoryVariable, Deque<Object>> history = new HashMap<>();

Usage:

{

public static void main(final String[] args)

System.out.println(hv.toString());

}

 

{{out}}

AutoHotkey records a history of your keypresses, but not your variables. The closest you can come is with a class:

{{works with|AutoHotkey 1.1}}

HV.var := 1

HV.var := 2

Return this[1]

}

 

=={{header|C sharp}}==

using System.Collections;

using System.Collections.Generic;

}

}

 

{{out}}

<pre>foobar <- foo <- 5

</pre>

 

via a watcher function that can track changes on a variable.

 

(def a (ref 0))

(def a-history (atom [@a])) ; define a history vector to act as a stack for changes on variable a

(add-watch a :hist (fn [key ref old new] (swap! a-history conj new)))

 

{{out|Sample Output}}

In Lisp the list is a natural and simple data structure for representing variables with history. By adding some simple macros we can make a small DSL that hides the list and makes it look like a history variable is it's own special thing.

 

`(list ,value))

 

(undo-hvar v)

(format t "Restored value = ~a~%" (get-hvar v)))

{{out}}

<pre>Initial value = 1

D does not have history variables. The following implementation provides a generic HistoryVariable that protects the historical values by defining them as 'const'.

 

 

/// A history variable.

s = "goodby";

writefln("%(%s\n%)", s.history);

{{out|Sample Output}}

<pre>2013-Jan-19 23:04:55.1660302; 1

2013-Jan-19 23:04:55.1662596; goodby

</pre>

 

=={{header|EchoLisp}}==

No native support. We implement an anonymous stack associated with the variable, and a few syntax rules to define the needed operations.

(define-syntax-rule (make-h-var name) (define name (stack (gensym))))

(define-syntax-rule (h-get name) (stack-top name))

(h-undo x) → 42

(h-undo x) → ❌ error: no more values x

 

=={{header|Elena}}==

import system'collections;

import system'routines;

console.printLine(o);

o.undo().undo().undo();

console.printLine(o.Value ?? "nil")

{{out}}

<pre>

 

=={{header|Factor}}==

 

1 <history> {

[ go-back ]

[ value>> "Restored value: %u\n" printf ]

{{out}}

<pre>

=={{header|Forth}}==

Forth does not have history variables, but it is trivial to define them. This one uses a linked list. The history variable is initialized to zero to avoid expensive sanity checks in ''H@''. ''H--'' undoes the assignment of a value and effectively returns a history variable to its former state.

: h@ @ @ ;

: h! swap here >r , dup @ , r> swap ! ;

: .history @ begin dup cell+ @ -1 <> while dup ? cell+ @ repeat drop ;

 

A sample session:

=={{header|Go}}==

We're all in this for the extra points. Mallon and Takota seem happy with sequences, but time and timestamps were mentioned on LtU. Beyond a separate sequence for each history variable, timestamps enable multiple variables to be seen in a common temporal sequence. In Go, with it's attention to concurrency, this might be done with flexibility for proper handling of shared variables, and efficient handling of variables limited to a single thread.

 

import (

fmt.Println(rv)

}

{{out}}

<pre>

There are no native Haskell history variables, but they are simple to implement.

 

 

newtype HVar a = HVar (IORef [a])

undoHVar var

undoHVar var

 

=={{header|J}}==

J does not natively support "history variables", but the functionality is easy to add:

 

set_hist_=:4 :0

V=.varref x

)

length_hist_=: #@getall

 

Example use:

 

9

'x' set_hist_ 10

┌─┬──┬──┐

│9│10│11│

 

Note that each value is contained in a box, so different values do not need to be type compatible with each other. If this is considered a defect then assertions could be added to enforce type compatibility across assignments.

Java does not support history variables, but they are easy to implement using the lists that come with Java's Collections framework.

 

This implementation does not allow the History Variable to be "empty". It can be assigned one or multiple "nulls", but it can never have an undefined value (such as being created and not initialized).

import java.util.LinkedList;

import java.util.List;

}

}

Test Program:

 

public static void main(String[] args) {

 

}

 

{{out}}

</pre>

 

This implementation does not allow the History Variable to be "empty". It can be assigned one or multiple "nulls", but it can never have an undefined value (such as being created and not initialized).

Test Program using a "String with History":

import java.util.LinkedList;

import java.util.List;

}

}

{{out}}

<pre>

=={{header|Julia}}==

Julia currently does not support overloading the assignment "=" operator.

num::Number

history::Vector{Number}

 

println("Past history of variable x: $(x.history). Current value is $(x.num)")

 

=={{header|Kotlin}}==

 

class HistoryVariable<T>(initialValue: T) {

v.showHistory()

println("\nCurrentvalue is ${v.currentValue}")

 

{{out}}

=={{header|Lua}}==

Lua does not natively support history variables. However, as with other languages here, something roughly equivalent could be implemented with a "stack wrapper". The only complicated issue might be how to treat nil's (null values). The implementation below allows initial nil's, and allows undo()'s back to nil, but does <i>not</i> consider nil as part of the "history".

local HistoryVariable = {

new = function(self)

end,

get = function(self)

hv:undo(); print("undo() to:", hv:get())

hv:undo(); print("undo() to:", hv:get())

{{out}}

<pre>defined: table: 0000000000939240

value is: nil

set() to: 1

First we see how we work with Stack (each module/function see a "current stack", we can make pointers to new stacks, but we can't get pointer of current stack). There are some statement no demonstrate here, such as Shift and ShiftBack (move top to a place, and move back to top), and Over (make new items by copying items).

 

Flush ' empty curtrent stack

\\ a is a pointer to a new stack object

b=stackitem(z, 2)

Print stackitem(b, 4)=1000

 

So now lets see the code:

 

Module CheckHistoryVariables {

Class History {

}

CheckStringHistoryVariables

 

=={{header|Oberon-2}}==

MODULE HVar;

IMPORT Out, Conv;

ShowVal(history.Undo());

END HVar.

 

=={{header|OCaml}}==

The easiest solution is to use the Stack module coming with OCaml's standard library:

open Stack

(* The following line is only for convenience when typing code *)

hs |> H.pop |> Printf.printf "%d\n";

hs |> H.pop |> Printf.printf "%d\n"

 

{{out}}

=={{header|OxygenBasic}}==

Simple history class for fixed length types that do not contain volatile pointer members.

'============

class History

 

del hv

 

=={{header|PARI/GP}}==

1+7

sin(Pi)

\a2

\a3

 

=={{header|Peloton}}==

Notify Protium we are interested in the variable mv

<@ DEFHST>mv</@>

Undo once: <@ ACTUNDVAR>mv</@><@ SAYVAR>mv</@>

Undo twice: <@ ACTUNDVAR>mv</@><@ SAYVAR>mv</@>

 

Same code, Simplified Chinese dialect

Notify Protium we are interested in the variable mv

<# 定义变量史>mv</#>

Undo once: <# 运行撤消变量>mv</#><# 显示变量>mv</#>

Undo twice: <# 运行撤消变量>mv</#><# 显示变量>mv</#>

 

{{out}}

=={{header|Perl}}==

Implemented via tie (and what's the usefulness of this?)

 

sub TIESCALAR {

 

History::off($x);

undo 1, current value: c

undo 2, current value: b

undo 3, current value: a

 

=={{header|Phix}}==

No native support, but trivial to implement.<br>

{{out}}

<pre>

{"history",{1,2,3}}

</pre>

Writing this as a separate reusable component (but omitting destroy/freelist handling for simplicity):

And use it like this

Same output. Of course test2 does not ''have'' to be a constant, but it may help.

 

=={{header|PicoLisp}}==

(when (val "Var")

(with "Var"

 

(de restoreH ("Var")

Test:

<pre>: (setH 'A "Hello world")

 

=={{header|PL/I}}==

declare t float controlled;

 

put (t); free t;

end;

 

=={{header|PureBasic}}==

 

Structure historyint

Debug "undo, x = "+Str(x\value())

Next

 

{{out}}

=={{header|Python}}==

 

 

HIST = {}

 

sys.settrace(trace)

 

=={{header|Racket}}==

Racket does not come with history variables, but they can be provided as a library as follows:

 

#lang racket

 

(hvar-undo! hv)

(check-equal? (hvar-current hv) 0)

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2018.03}}

has @.history;

has $!var handles <Str gist FETCH Numeric>;

 

.say for foo.history;

{{out}}

<pre>[Instant:1523396079.685629 (Any)]

<br><br>The history list part of the &nbsp' '''varSet''' &nbsp; subroutine could be separated into its

<br>own if you wanted to keep the subroutine's function pure.

varSet!.=0 /*initialize the all of the VARSET!'s. */

call varSet 'fluid',min(0,-5/2,-1) ; say 'fluid=' fluid

say 'history entry' ?j "for var" ?z":" varSet!.?J.?x

end /*?j*/

'''output'''

<pre>

 

===Version 2===

/* REXX ***************************************************************

* Demonstrate how the history of assignments can be kept and shown

end

Return varset.0.varu /*return the number of assignments. */

 

=={{header|Ruby}}==

This uses trace_var, which only works for global variables:

trace_var(:$foo){|v| foo_hist.unshift(v)}

 

 

p foo_hist # => ["banana", "pear", "apple"]

 

=={{header|Rust}}==

struct HVar<T> {

history: Vec<T>,

println!("{:?}", var.revert());

println!("{:?}", var.get());

{{out}}

<pre>([0, 1], 2)

=={{header|Scala}}==

Scala doesn't have a native support for history variables, but it's quite easy to implement them. The following class uses same conventions as ML's mutable reference cells. (i.e. <code>!</code> as accessor, and <code>:=</code> as mutator.)

override def self = !this

override def toString = "HVar(" + !this + ")"

v

}

Usage:

h: HVar[Int] = HVar(3)

 

 

scala> h.undo

 

=={{header|Sidef}}==

Implemented as a class:

 

has history = []

 

say "History: #{foo.history}"

{{out}}

<pre>

Smalltalk doesn't have native support for history variables. It could be implemented using (implementation dependent) tracing facilities, or by changing the code generator (which is part of the library and open for change).

The following implementation is portable and in the spirit of the Lisp implementation above, and defines a new "assignment operator":

instanceVariableNames:'values'

classVariableNames:''

x value.

x history.

 

=={{header|Swift}}==

Swift does not support history variables. However, you can add a watcher that can track when the variable will change.

var history:Int = 0 {

willSet {

history = 4

println(historyOfHistory)

 

another approach, using generics:

plug this code into a Playground to see the output

{{works with|Swift|2.x+}}

 

struct History <T> {

h.undo() // outputs "First"

 

 

=={{header|Tcl}}==

Though Tcl's variables don't have history by default, it can be added easily through the use of traces:

proc histvar {varName operation} {

upvar 1 $varName v ___history($varName) history

upvar 1 $varName v ___history($key) history

set v [lindex $history end]

Demonstrating how to use it:

histvar foo start

set foo {a b c d}

histvar foo undo

puts $foo

{{out}}

<pre>

{{trans|Kotlin}}

Not built in but we can soon make a suitable class.

construct new(initValue) {

_history = [initValue]

v.currentValue = 3

v.showHistory()

 

{{out}}

=={{header|zkl}}==

No native support, here is a something that can be done with a class:

var [private] _v, _history=List(), maxSz;

fcn init(v,maxEntries=3){ maxSz=maxEntries; set(v) }

fcn{ _history.pump(List,fcn([(t,v)]){ T(Time.Date.ctime(t),v) }) };

fcn __opAdd(x){ set(_v + x); self }

hv+4;

hv.set("Shuttle prepared for liftoff");

hv+": orbit achived";

hv.history.concat("\n").println();

{{out}}

<pre>