# You are allowed to redistribute it and sell it, alone or is a part of
# another product.
-# Service management trough the `for` control structure.
+# Service management through the `for` control structure.
#
# The module is a proof-of-concept to investigate the abuse of
# the `for` structure to implement various services.
# The service is not effectively started until the iterate method
# is called. Then, each step of the iteration is a step in the service.
#
-# While, for a typing point of view, abusers are just collections,
-# the point of this class is to tag services that return a ForAbuser
-# object.
-# Note that using abuser as genuine collection should work but is not
-# recommended since it may cause mental health issues.
+# While, for a typing point of view, abusers are just classes with an
+# iterator method, the point of this class is to tag services that return
+# a ForAbuser object.
+#
+# Note that using having `ForAbuser` as a genuine subclass of `Collection`
+# works but is not recommended since it may cause mental health issues.
interface ForAbuser[E]
- super Collection[E]
+ # Starts and control the service
+ fun iterator: Iterator[E] is abstract
end
# Abuser to read a file, see `file_open`
private class ReadFileForAbuser
- super ForAbuser[IFStream]
+ super ForAbuser[FileReader]
var path: String
redef fun iterator do return new ReadFileForAbuserIterator(path)
end
# Abuser iterator to read a file, see `file_open`
private class ReadFileForAbuserIterator
- super Iterator[IFStream]
- redef var item: IFStream
+ super Iterator[FileReader]
+ var path: String
+ redef var item: FileReader is noinit
redef var is_ok = true
- init(path: String)
+ init
do
# start of service is to open the file, and return in
- item = new IFStream.open(path)
+ item = new FileReader.open(path)
end
redef fun next
do
# The second element to compare
var b: E
# The result of the comparison (according to the user)
- var res writable = 0
+ var res = 0 is writable
end
# Abuser for sorting array, see `sort_fa`
private class SortAbuserIterator[E]
super Iterator[CompareQuery[E]]
# The index of the big loop
- var i: Int
+ var i: Int = 0
# The index of the small loop
- var j: Int
+ var j: Int = 0
# The array to sort
var array: Array[E]
# The query used to communicate with the user.
# For ecological concerns, a unique CompareQuery is instatiated.
- var query: nullable CompareQuery[E]
+ var query: nullable CompareQuery[E] = null
redef fun item do return query.as(not null)
- init(array: Array[E])
+ init
do
- self.array = array
# Initialize the algorithm, see `next` for the rest
- i = 0
- j = 0
if not is_ok then return
query = new CompareQuery[E](array[i], array[j])
end
end
redef class Array[E]
- # Sort an array trough a `for` abuse.
+ # Sort an array through a `for` abuse.
# The user uses the provided query (item) to implements its own comparison
#
# var a = [1, 3, 2]
- # for q in a do q.res = q.a <=> q.b
- # assert print a == 123
+ # for q in a.sort_fa do q.res = q.a <=> q.b
+ # assert a == [1, 2, 3]
#
# Implements a sort by permutation.
fun sort_fa: ForAbuser[CompareQuery[E]]
####
-# Open and read a file trough a `for` abuse.
+# Open and read a file through a `for` abuse.
# The abuse just ensures that the file is closed after the reading.
#
# for f in file_open("/etc/issue") do
-# print f.read_line
+# var l = f.read_line
+# print l
+# assert not l.is_empty
# end # f is automatically closed here
-fun file_open(path: String): ForAbuser[IFStream]
+fun file_open(path: String): ForAbuser[FileReader]
do
return new ReadFileForAbuser(path)
end