Merge pull request #46 from CSBiology/deepCopy

Deep copy improvements

Author: kMutagene

src/DynamicObj/DynObj.fs

@@ -216,4 +216,34 @@ module DynObj =
     /// Prints a formatted string containing all static and dynamic properties of the given DynamicObj
     /// </summary>
     /// <param name="dynObj">The DynamicObj for which to print a formatted string for</param>
-    let print (dynObj:DynamicObj) = printfn "%s" (dynObj |> format)
+    let print (dynObj:DynamicObj) = printfn "%s" (dynObj |> format)
+
+    /// <summary>
+    /// function to deep copy a boxed object (if possible)
+    ///
+    /// The following cases are handled (in this precedence):
+    ///
+    /// - Basic F# types (bool, byte, sbyte, int16, uint16, int, uint, int64, uint64, nativeint, unativeint, float, float32, char, string, unit, decimal)
+    ///
+    /// - ResizeArrays and Dictionaries containing any combination of basic F# types
+    ///
+    /// - Dictionaries containing DynamicObj as keys or values in any combination with DynamicObj or basic F# types as keys or values
+    ///
+    /// - array&lt;DynamicObj&gt;, list&lt;DynamicObj&gt;, ResizeArray&lt;DynamicObj&gt;: These collections of DynamicObj are copied as a new collection with recursively deep copied elements.
+    ///
+    /// - System.ICloneable: If the property implements ICloneable, the Clone() method is called on the property.
+    ///
+    /// - DynamicObj (and derived classes): properties that are themselves DynamicObj instances are deep copied recursively.
+    ///   if a derived class has static properties (e.g. instance properties), these will be copied as dynamic properties on the new instance.
+    ///
+    /// Note on Classes that inherit from DynamicObj:
+    ///
+    /// Classes that inherit from DynamicObj will match the `DynamicObj` typecheck if they do not implement ICloneable.
+    /// The deep copied instances will be cast to DynamicObj with static/instance properties AND dynamic properties all set as dynamic properties.
+    /// It should be possible to 'recover' the original type by checking if the needed properties exist as dynamic properties,
+    /// and then passing them to the class constructor if needed.
+    /// </summary>
+    /// <param name="o">The object that should be deep copied</param>
+    /// <param name="includeInstanceProperties">Whether to include instance properties (= 'static' properties on the class) as dynamic properties on the new instance for matched DynamicObj.</param>
+    let tryDeepCopyObj (includeInstanceProperties:bool) (o:DynamicObj) =
+        CopyUtils.tryDeepCopyObj(o, includeInstanceProperties)

src/DynamicObj/DynamicObj.fs

@@ -168,4 +168,11 @@ module FableJS =
         let cloneICloneable (o:obj) : obj =
             jsNative
 
+    module Dictionaries =
+        [<Emit("""$0 instanceof Map""")>]
+        let isMap (o:obj) : bool =
+            jsNative
+        [<Emit("""$0 instanceof Dictionary""")>]
+        let isDict (o:obj) : bool =
+            jsNative
 #endif

src/DynamicObj/FableJS.fs

@@ -220,4 +220,10 @@ module FablePy =
         [<Emit("""$0.System_ICloneable_Clone()""")>]
         let cloneICloneable (o:obj) : obj =
             nativeOnly
+
+    module Dictionaries =
+        [<Emit("""isinstance($0, dict)""")>]
+        let isDict (o:obj) : bool =
+            nativeOnly
+
 #endif

src/DynamicObj/FablePy.fs

@@ -13,18 +13,10 @@
 open Fable.Pyxpecto
 open DynamicObj
 
-type T(dyn:string, stat:string) as this=
-    inherit DynamicObj()
+let r1 = ResizeArray([1; 2])
+let r2 = ResizeArray([1; 2])
+let r3 = r1
 
-    do 
-        this.SetProperty("Dyn", dyn)
-
-    member this.Stat = stat
-
-let first = T("dyn1", "stat1")
-let second = T("dyn2", "stat2")
-
-let _ = second.ShallowCopyDynamicPropertiesTo(first)
-
-first |> DynObj.print
-second |> DynObj.print
+printfn "%A" (LanguagePrimitives.PhysicalEquality r1 r2)
+printfn "%A" (LanguagePrimitives.PhysicalEquality r2 r2)
+printfn "%A" (LanguagePrimitives.PhysicalEquality r3 r1)

src/DynamicObj/Playground.fsx

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

tests/CSharpTests/CSharpTests.csproj

@@ -0,0 +1,2 @@
+module DeepCopyDynamicObj
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/Dictionaries.fs

@@ -0,0 +1,2 @@
+module DeepCopyDynamicObjCollections
+

tests/DynamicObject.Tests/CopyUtils.tryDeepCopyObj/DynamicObj.fs

@@ -0,0 +1,2 @@
+module DeepCopyICloneable
+