An alternative way of accessing the past

[ivanperez-keera]

Did we ever explore the possibility of looking into the past of a stream with a function with a signature like the following?

importCopilot.LanguageimportPreludehiding ((++))
importqualifiedPreludeat::Typeda=>a--^ Default value for times before zero->Streama--^ Stream to look into->Int--^ Number of steps to look back->Streama
at def s n
| n Prelude.>0=error"You cannot look into the future"| n Prelude.==0= s
| n Prelude.<0=replicate (negate n) def ++ s

It could use used as follows:

example::StreamBool
example = [True] ++ false
example1::StreamBool
example1 = at False example (-1)

I wonder if there would be any benefit to making at take a KnownNat (wrapped in something). I just would not want users to have to write Proxy in their expressions, or type expressions explicitly.

We could also provide:

at':: (Defaulta, Typeda)
=>Streama--^ Stream to look into->Int--^ Number of steps to look back->Streama
at' s n
| n Prelude.>0=error"You cannot look into the future"| n Prelude.==0= s
| n Prelude.<0=replicate (negate n) def ++ s

and users could write:

example1::StreamBool
example1 = at example (-1)

or:

example1::StreamBool
example1 = example `at'` (-1)

or define an operator (for example, (#!), and I'm picking a random name) as a synonym for at' so that users can write:

example1::StreamBool
example1 = example #! (-1)

[ivanperez-keera]

Positive numbers would be equivalent to a drop, of course, if we change the implementation of at':

It would provide a uniform, and I'd argue more natural, way of accessing streams:

 example #! (-1) -- look back into the past
example #!1-- look into the future, only valid if example knows enough about its own future