Swift makes read-write object references read only

[mittelmark]

Here is my code which works fine in C, C++, C#, D, Java, Js, Py and Ts, but not in Swift:

 public static class Values {
         public static void AddValues (int n, List<float>! values) {
                 for (int i = 0; i < n; i++) {
                         float f = i*1.0;
                         values.Add(f);
                 }
         }
         public static void Main () {
                 List<float>() values;
                 AddValues(5,values);
                 AddValues(6,values);
                 Console.WriteLine($"Count: {values.Count}");
                 
         }
 }

In Swift the values argument becomes immutable:

// Generated automatically with "fut". Do not edit.

public class Values
{

        public static func addValues(_ n: Int, _ values: [Float])
        {
                for i in 0..<n {
                        let f: Float = Float(Double(i) * 1.0)
                        values.append(f)
                }
        }

        public static func main()
        {
                var values = [Float]()
                Values.addValues(5, values)
                Values.addValues(6, values)
                print("Count: \(values.count)")
        }
}

Values.main()

Which then leads to an error:

 8 |            for i in 0..<n {
 9 |                    let f: Float = Float(Double(i) * 1.0)
10 |                    values.append(f)
   |           `- error: cannot use mutating member on immutable value: 'values' is a 'let' constant
11 |            }

The suggested fix is to make the argument inout and adding a reference & in the call line:

 public static func addValues(_ n: Int, _ values: inout [Float]) {
        for i in 0..<n {
            let f: Float = Float(Double(i) * 1.0)
            values.append(f)
        }
    }
	public static func main()
	{
		var values = [Float]()
		Values.addValues(5, &values)
		Values.addValues(6, &values)
		print("Count: \(values.count)")
	}

[pfusik]

The problem here is that Swift arrays (emitted for Fusion Lists) are a value type. I considered emitting inout, but that's only a partial solution (e.g., it can only be applied to parameters, not local variables).

[mittelmark]

So you mean, we could get the inout in the parameter list, but not the &values in the caller? There is no workaround to modify a list within a Swift method via a Fusion method like it was the intention in the example above? One dirty way then is to do a Perl Oneliner on the relevant output code parts ...

[pfusik]

No, I mean inout doesn't handle code such as:

List<float> ref = someOtherList;

Why do you need to pass Lists to methods? Couldn't you make the Lists members of your class?

[mittelmark]

Sure I can rewrite the class code, currently the class is purely static. to make the list an object variable.

https://github.com/mittelmark/snha4any/blob/main/fusion/CSVParser.fu

I think I hit exactly your swift failing test code with the Add method:

https://github.com/fusionlanguage/fut/blob/master/test/ListPtr.fu

[pfusik]

Yes, this issue is known to me.
The problem with inout is that at first it looks like it has "pass by reference" semantics, but it hasn't, as can be seen in:

var a : [Int] = [ 1 ]
func foo(_ p: inout [Int]) {
	a[0] += 1
	print(p[0])
}
func bar(_ p: inout [Int]) {
	p[0] += 1
	print(a[0])
}
foo(&a)
// bar(&a)

Output

Simultaneous accesses to 0x7ff7505451b0, but modification requires exclusive access.
Previous access (a modification) started at inout.exe`main + 81 (0x7ff750541301).
Current access (a read) started at:
0    swiftCore.dll                      0x00007ffc596fed90 swift_stdlib_getDefaultErrorCode + 540
1    swiftCore.dll                      0x00007ffc596ff050 swift_beginAccess + 67
2    inout.exe                          0x00007ff7505412b0 main + 317
3    inout.exe                          0x00007ff7505412b0 main + 93
4    inout.exe                          0x00007ff7505412b0 main + 1616
5    KERNEL32.DLL                       0x00007ffcb5c4e940 BaseThreadInitThunk + 23
6    ntdll.dll                          0x00007ffcb6967bf0 RtlUserThreadStart + 44
Fatal access conflict detected.

Another possible solution is wrapping the list in your class:

class MyList
{
    internal List<float>() L;
}

Now you can have true references to MyList in Swift. Probably the long-term solution is to have fut create such a wrapper class, as it already does for arrays.

[mittelmark]

I tried the following Swift code and there are no surprises for me, inout seems to me to work like expected:

public class Test {

	private static func getCount(_ l: [Int32]) -> Int
	{
		return l.count
	}

	private static func add(_ l:inout [Int32])
	{
		l.append(Int32(42))
	}
        public static func foo(_ p: [Int]) {
            print(p[0])
        }
        public static func bar(_ p: inout [Int]) {
            p[0] += 1
            print(p[0])
        }
	public static func run() -> Bool
        {
            var a : [Int] = [ 1 ]                  

            var l = [Int32]()
            l.append(Int32(5))
            add(&l)
            foo(a)       
            bar(&a)                  
            bar(&a)                                    
            return l.count == 2 && getCount(l) == 2 && a[0] == 3
                  
	}
	public static func main()
	{
		if Test.run() {
			print("OK!")
		}
		else {
			print("Fail!")
		}
	}
}

Test.main()

I just get an OK.

I will try anyway that wrapper approach. May be calling it FloatVector ...

[mittelmark]

Ok, here the wrapper class which works in all languages.

public class FloatVector {
        internal List<float>() L;
        public int Count = 0;
        public void Add!(float f) {
                L.Add(f);
                Count = Count + 1;
        }
}

public static class Values {
        public static void AddValues (int n, FloatVector! values) {
                for (int i = 0; i < n; i++) {
                        float f = i*1.0;
                        values.Add(f);
                }
        }
        public static void Main () {
                FloatVector() values;
                AddValues(5,values);
                AddValues(6,values);
                Console.WriteLine($"Count: {values.Count}");
        }
         
 }

Is that the wrapping approach which you mean?

[mittelmark]

Any idea here.
I think that issue might be the last to get our code working in all 9 languages at the end.
See our progress here: https://github.com/mittelmark/snha4any
Otherwise we skip Swift for now. Not a big deal. As a proof of concept it worked very nice.
Thank you!

[pfusik]

Sorry, I missed your question. Yes, that's the way to pass Lists by reference in Swift. You probably don't need the separate Count field - just use L.Count.